Server : VMware 16 OS : Linux CentOS 7

Volume ?

Physical Volume (물리적 볼륨) : /dev/sda1, /dev/sda2 등의 파티션 Volume Group (볼륨 그룹) : Physical Volume(물리적 볼륨)을 합쳐서 1개의 그룹으로 만드는 것 Logical Volume (논리적 볼륨) : Volume Group(볼륨 그룹)을 논리적으로 나눈 것

확장 순서

VMware Disk 용량 증설 -> 물리 파티션 용량 추가 -> 볼륨 그룹 용량 증설 -> 논리 파티션 증설

작업

root 폴더의 용량이 부족해 해당 폴더를 증설

1. 용량확인

df -h . 명령어를 활용해 디스크 사용량을 확인 할 수 있으며, 총 26GB 중 24GB를 사용 하고 있어 디스크 용량을 늘릴 필요가 있음

2. VMware 용량 증설. 기존 30GB에서 200GB로 변경

Edit virtural machine settings 클릭 후

Expand 클릭

원하는 size 입력후 Expand 클릭

3. 파티션 구성 확인

[root@target ~]# lsblk
NAME            MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sda               8:0    0  200G  0 disk 
├─sda1            8:1    0    1G  0 part /boot
└─sda2            8:2    0   25G  0 part 
  ├─centos-root 253:0    0   26G  0 lvm  /
  └─centos-swap 253:1    0    3G  0 lvm  [SWAP]
sr0              11:0    1  4.4G  0 rom  /run/media/admin/CentOS 7 x86_64

• lsblk 명령어로 전체 구성을 확인 할 수 있다. 총 200GB 중, 사용 중(할당)일 용량은 26GB로써 200GB로 정상적으로 추가 된 것을 확인

4. growpart 설치

yum install cloud-utils-growpart

5. 물리 볼륨(물리 파티션) 용량 추가

growpart /dev/sda 2

growpart 명령어를 통해 물리 파티션에 용량을 추가. root가 포함되어 있는 sda2 물리 파티션에 추가한다

[root@target ~]# lsblk
NAME            MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sda               8:0    0  200G  0 disk 
├─sda1            8:1    0    1G  0 part /boot
└─sda2            8:2    0  199G  0 part 
  ├─centos-root 253:0    0   26G  0 lvm  /
  └─centos-swap 253:1    0    3G  0 lvm  [SWAP]
sr0              11:0    1  4.4G  0 rom  /run/media/admin/CentOS 7 x86_64

sda2 영역이 증설된 모습을 확인 할 수 있다. (25GB -> 199GB)

6. 볼륨 그룹 확인

pvresize /dev/sda2 = /dev/sda2 영역에 추가 되어있는 모든 용량을 파티션에 할당 vgdisplay = Volume Group 구성 확인

[root@source ~]# pvresize /dev/sda2
  Physical volume "/dev/sda2" changed
  1 physical volume(s) resized or updated / 0 physical volume(s) not resized

[root@source ~]# vgdisplay
  --- Volume group ---
  VG Name               centos
  System ID             
  Format                lvm2
  Metadata Areas        1
  Metadata Sequence No  5
  VG Access             read/write
  VG Status             resizable
  MAX LV                0
  Cur LV                2
  Open LV               2
  Max PV                0
  Cur PV                1
  Act PV                1
  VG Size               <199.00 GiB
  PE Size               4.00 MiB
  Total PE              50943
  Alloc PE / Size       50943 / <199.00 GiB
  Free  PE / Size       0 / 0   
  VG UUID               hBI25A-0Xjv-G3i7-hCng-5dp7-q7xg-PmgGQs

7. 논리 볼륨(논리 파티션) 용량 확장

lvextend -r -l +100%FREE /dev/mapper/centos-root =+100%FREE > 볼륨 그룹 내, 남아있는 모든 용량(100%)을 대상 경로에 전부 할당

[root@source ~]# lvextend -r -l +100%FREE /dev/mapper/centos-root

8. 증설 확인

정상적으로 증설이 잘 마무리된 모습

Oracle DB에 접속을해 DML 및 DDL 등의 명령어로 작업을 수행하면, 모든 작업의 기록은 redo log 파일에 저장이된다.

작업의 양이 많아지면 redo log파일에 기록하는 내용도 굉장히 많아지게 된다. 그렇게 되면 데이터를 기록하기 위해서 redo log파일을 늘려야 하는 일이 발생 하기도 한다.

하지만 Oracle redo log 파일은 계속 증가하는 것이 아니라 몇개의 log 파일을 만들어 놓고 번갈아 가면서 기록하는 구조로 되어 있다.

이렇게 작업을 하게 되면 새로운 작업의 내용이 예전의 작업내용을 덮어 쓰므로 이전 작업의 내용을 잃게 된다는 단점이 있다 .

이러한 단점을 해결 하기 위한 방법이 redo log 파일의 내용을 다른 디렉터리에 자동으로 복사해서 저장하도록 운영하는 방법이다. 이렇게 운영하는 방법을 아카이브 로그 모드(Archive Log Mode) 이다.

Oracle 에서 Default로 No Archive Log Mode 이며, Archive Log Mode로 운영하기 위해서는 아래와 같이 설정을 진행 해야 한다.

테스트 환경

Server : VMware OS : CentOS 7 DB : Oracle 19c ASM Single

Guide

1. 현재 아카이브 모드 확인

SQL> archive log list
Database log mode           No Archive Mode
Automatic archival           Disabled
Archive destination           USE_DB_RECOVERY_FILE_DEST
Oldest online log sequence     76
Current log sequence           78

2. 아카이브 모드 변경

SQL> alter system set log_archive_dest='/u01/app/oracle/fast_recovery_area/ORCL/archivelog' scope=spfile ;
Database altered.

SQL> alter system set log_archive_format='%d_%t_%s_%r.dbf' scope=spfile sid='*';
Database altered.

• log_archive_dest 의 경로는 아카이브 로그를 저장 할 디렉터리의 경로를 지정 해주면 된다.

SQL> shutdown immediate

Database closed.
Database dismounted.
ORACLE instance shut down.



SQL> startup mount

ORACLE instance started.




SQL> archive log list;

Database log mode           No Archive Mode
Automatic archival           Disabled
Archive destination           USE_DB_RECOVERY_FILE_DEST
Oldest online log sequence     76
Current log sequence           78



SQL> alter database archivelog;

Database altered.



SQL> alter database open;

Database altered.



SQL> archive log list;

Database log mode           Archive Mode
Automatic archival           Disabled
Archive destination           USE_DB_RECOVERY_FILE_DEST
Oldest online log sequence     76
Current log sequence           78

테이블이란 , Row(행)과 Column(열)로 구성된 표 형식의 오브젝트로 데이터를 보관하는 역할을 함. DB 내에 생성할 수 있는 테이블의 수는 제한이 없으며, 물리적인 제약이 없는 한 얼마든지 생성 할 수 있음.

Row 저장 방식 이란 ?

테이블의 Row는 테이블이 저장되는 테이블 스페이스를 구성하는 데이터 파일의 블록에 저장된다. 로우를 입력하는 처리(insert 문)를 수행하면, 블록의 데이터 저장 영역 중 밑단 부분 부터 데이터를 저장한다. 일반적으로 여러 Row를 하나의 블록에 저장한다. 오라클은 로우 데이터를 데이터 저장영역이 가득찰 때까지 집어 넣지는 않는다.

Row Migration

PCTFREE를 설정해블록에 빈 공간을 마련해두는 이유는 Update 문 수행 등으로 인해 데이터가 변경되 로우의 크기가 커질 수 있기 때문이다. 이때 데이터가 블록의빈 공간에 들어갈 수 없을정도로 커지면, 'Row Migration'이 발생한다. Row Migration이 발생하면, 변경으로 인해 증가한 데이터 뿐만 아니라 전체 Row의 데이터가 다른 블록으로 복사 된다. 해당 Row의 위치를 갖고있는 인덱스 등의 모든 오브젝트를 변경해야하는 일이 생기므로 원래의 블록에 새로 복사된 위치의 Pointer를 남긴다.

Row Chaining

Row Chaining이란, 입력할 Row의 데이터 크기가 블록의 데이터 저장 공간보다 클 때발생하는 현상이다. 데이터 크기가 블록의 데이터 저장공간 보다 클 때 한 Row를 여러개의 조각으로 분리하고 각 조각을 다른 블록에 저장한다.

참고

https://devfunny.tistory.com/297 https://blog.naver.com/itperson/220879812591

• Server : VMware Workstation 16
• OS : CenOS 7
• Version : Oracle 19c

< 사전 준비 사항 >

• /etc/hosts 파일 설정

127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6

vi /etc/hosts 명령어 입력 후 실제 서버의 IP주소와 hostsname을 반드시 등록!!

127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6

192.168.142.144 source source.localdomain

• 컴파일러를 비롯한 필수 시스템 SW 설치 (하나씩 설치하기 귀찮으니 yum update 명령어를 통해 전체 업데이트 함)

$ yum update

위 사진 처럼 나온다면 y 입력후 enter 누르고 설치 진행

약 5분 정도 기다리면 완료

• 커널파라미터 수정(/etc/sysctl.conf)

[root@localhost ~]# vi /etc/sysctl.conf

root 계정에서 vi /etc/sysctl.conf 명령어를 사용해 아래내용 추가

fs.aio-max-nr = 1048576
fs.file-max = 6815744
kernel.shmall = 2097152
kernel.shmmax = 4294967295
kernel.shmmni = 4096
kernel.sem = 250 32000 100 128
net.ipv4.ip_local_port_range = 9000 65500
net.core.rmem_default = 262144
net.core.rmem_max = 4194304
net.core.wmem_default = 262144
net.core.wmem_max = 1048576

kernel.shmall = 8388608
kernel.shmmax = 34359738368

kernel.core_pattern = %e.%p.core

위 사진 처럼 등록 후 :wq! 로 저장

변경내용 적용 /etc/sysctl.conf에 내용이 변경되었으면 꼭 적용 시켜줘야함 !!!

[root@localhost ~]# sysctl -p

• swap 공간 확보

모든 운영체제는 디스크에 swap 공간을 사용하도록 되어있다. 리눅스의 경우 운영체제 설정 시 swap 영역으로 사용하기 위한 스왑파티션을 만든다. -> 이공간이 최소 2G byte 이상 되어야함

공간이 충분하므로 PASS

Oracle 다운로드 및 설치

https://www.oracle.com/database/technologies/oracle-database-software-downloads.html

위 링크에서 19c 리눅스 버전으로 다운로드

설치할때 로그인은 필수 이므로 회원가입이 안되었다면 회원가입후 진행

1. 리눅스 환경설정

1-1) 종속성 패키지 설치

계정 : root

yum -y install compat-libcap1
yum -y install compat-libstdc++-33
yum -y install libstdc++-devel
yum -y install gcc 
yum -y install gcc-c++
yum -y install ksh
yum -y install libaio-devel

※ 오라클 설치에 반드시 필요한 패키지이므로 오라클 설치전에 미리 설치함.

[root@localhost /]# groupadd -g 1200 dba
[root@localhost /]# useradd -g dba -u 1200 ora19c
[root@localhost /]# passwd ora19c
//GID 1200 dba 그룹생성, UID 1200 ora19c 계정 생성, ora19c 패스워드 설정

[root@localhost /]# mkdir -p /app/ora19c
[root@localhost /]# chown -R ora19c.dba /app
[root@localhost /]# chmod -R 755 /app
// /app/ora19c 디렉토리 생성 및 소유자 : ora19c, 소유그룹 : dba, 권한 drxr-xr-x 설정

• WinSCP로 다운로드 받은 zip 파일 전송하기

• /etc/security/limits.conf 수정

[root@localhost ~]# vi /etc/security/limits.conf 

...//아래 내용 추가

#oracle setup
ora19c soft nproc 2047
ora19c hard nproc 16384
ora19c soft nofile 1024
ora19c hard nofile 65536
ora19c soft stack 10240
ora19c hard stack 20480

• selinex 사용 정지

  [root@localhost ~]# vi /etc/sysconfig/selinux 

...//변경
SELINEX=disabled
...

• 방화벽 정지

[root@localhost ~]# systemctl stop firewalld
[root@localhost ~]# systemctl disable firewalld

1-4) 오라클 계정 생성

생성해주었던 ora19c 계정으로 로그인해 ~/.bash_profile 에 내용 추가

[ora19c@localhost ~]$ vi ~/.bash_profile

#oracle setup
export ORACLE_HOSTNAME=source
export TMP=/tmp
export TMPDIR=$TMP export ORACLE_OWNER=ora19c
export ORACLE_BASE=/app
export ORACLE_HOME=/app
export PATH=$PATH:$ORACLE_HOME/bin:$ORACLE_HOME:/usr/bin
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$ORACLE_HOME/lib:/lib:/usr/lib
export ORACLE_SID=source
export NLS_LANG=AMERICAN_AMERICA.KO16MSWIN949
export ORACLE_TERM=xterm
export TNS_ADMIN=$ORACLE_HOME/network/admin
export CLASSPATH=$ORACLE_HOME/JRE:$ORACLE_HOME/jlib:$ORACLE_HOME/rdbms/jlib
export EDITOR=vi
 if [ $USER = "ora19c" ]; then
   if [ $SHELL = "/bin/ksh" ]; then
        ulimit -p 16384
        ulimit -n 65536
   else
        ulimit -u 16384 -n 65536
   fi
 fi

2. 설치과정

1) 다운로드 받은 oracle19c를 WinSCP 프로그램을 활용해 VMware 서버로 옮기기

호스트 이름에 IP를 입력하고 리눅스 OS 계정과 비밀번호를 입력후 로그인

/app 경로로 다운로드 받은 zip 파일을 옮겨줌

2) unzip을 사용해 다운로드 받은 파일을 풀어줌

3) xhost 등록

root 계정에서 xhost + 명령어 입력

다시 ora19c 계정으로 와서 export DISPLAY=:0 입력 후 설치한 경로로 이동후 ./runInstaller 입력

4) install

다음 클릭

다음 클릭

전역 데이터베이스 이름(OracleSID) 설정 후 비밀번호 입력

예 클릭

자동으로 구성 스크립트 실행 체크 후 root 계정 비밀번호 입력

모두 무시 체크 후 다음

설치 클릭

예 클릭

3. 오라클 실행

• sqlplus / as sysdba 실행

[ora19c@localhost dbs]$ sqlplus / as sysdba

select status from v$instance 입력후 status 값이 위 사진처럼 OPEN 상태면 설치완료

1. REST
2. @RestController
3. @PathVariable
4. @RequestBody
5. 댓글 처리

1. REST

Representational state transfer의 약자로서 하나의 URI는 하나의 고유한 리소스(Resource)를 대표하도록 설계 되는 개념에 전송방식을 결합한 것

• URI > URL 개념으로 URI는 현실, 구체적이며 URL은 상대적으로 상징적 의미를 지님
• HTTP Method (GET,POST,PUT,PATCH, DELETE 등)으로 나타냄

2. @RestController

문자열 반환

• produces 속성은 해당 메소드가 생산하는 MIME 타입을 의미
• 문자열로 직접 지정 혹은 메소드 내의 MediaType을 이용할 수 있음

• ContextType이 produces 속성값에 의해 나타낸 것을 볼 수 있음

객체 반환

• 객체를 반환하는 작업은 JSON이나 XML을 이용
• @AllArgsConstructor는 모든 속성을 사용하는 생성자를 만드는 어노테이션
• @NoArgsConstructor는 비어 있는 생성자(기본생성자) 를 만드는 어노테이션

• SampleVO 객체를 JSON 형식으로 반환

컬렉션 타입

• 컬렉션 타입으로 객체를 반환
• 1 ~ 10 까지 반복하여 출력
• 기본 출력은 XML 형식, .json을 출력하면 JSON 형식으로 출력

• /sample/getList 로 기본 출력

• /sample/getList.json 으로 JSON 형식으로 출력

ResponseEntity

• 데이터와 함께 HTTP 헤더의 상태 메시지도 같이 전달

• 주소창에 param으로 준 값을 입력

• if문의 조건에 따라 height 값이 150 이하로 입력 하면 상태코드는 502

3. @PathVariable

REST 방식에서 자주 사용 됨 URL 경로의 일부를 파라미터로 사용할 때 이용

• @PathVariable 어노테이션을 파라미터 안에 넣는다.
• return시 배열을 생성
• 어노테이션 변수명은 GetMapping 에서 {}에 선언한 변수명과 일치 해야 한다.

• URL에 cat, pid 값을 작성

4. @RequestBody

JSON 데이터를 원하는 타입의 객체로 변환해야 할 때 사용 요청 내용을 이용하여 해당 파라미터 타입으로 변환을 요구

• 요청(request)한 내용을 처리해야 하기 때문에 @PostMapping 선언

• postman 프로그램으로 테스트
• ticket 객체에 값을 넣지 않아 빈객체가 나오지만 에러는 발생하지 않음

5. 댓글 처리

RESTful 방식, Ajax를 이용해 댓글 처리

영속 영역

• sqldeveloper 로 댓글 처리를 위한 tbl_reply 테이블 생성

• 도메인 객체(ReplyVO) 생성

• Mapper 인터페이스 생성

• 쿼리문 작성을 위한 XML 생성 후 namespace 설정(Mapping)

• JUnit Test를 통해 ReplyMapper 객체가 정상 적으로 Mapping 되었는지 확인

Create Test

• ReplyMapper 인터페이스에 insert 메소드 등록

• XML에 insert 쿼리문 작성

• Test를 통해 insert문이 제대로 작동 하는지 확인

Read Test

• ReplyMapper 인터페이스에 read 메소드 등록

• XML에 Read하기 위한 select 문 작성

• Test를 통해 select 문이 정상적으로 작동하는지 확인

Update Test

• ReplayMapper 인터페이스에 update 메소드 등록

• update를 위한 쿼리문 작성

• Test를 통해 update문이 정상적으로 작동하는지 확인

Delete Test

• ReplyMapper 인터페이스에 delete 메소드 등록

• delete를 위한 쿼리문 작성

• Test를 통해 delete문이 정상적으로 작동하는지 확인

Service

Service의 로직은 위 방식과 동일하기 때문에 메소드별 설명은 생략

• ReplyService 인터페이스에 각 메소드 등록

• ReplyServiceImpl은 ReplyService를 상속받아 각 메소드를 오버라이딩 한후 mapper 메소드를 return

Controller - insert

• @RequestMapping을 사용해 /replies/로 상위 경로 설정
• REST 방식으로 구현 하기 위해 @RestController 어노테이션 선언
• insert시 consumes 와 produces를 이용하여 JSON 방식의 데이터만 처리 및 문자열만 반환

• postman 프로그램을 활용해 post 요청 후 정상적으로 작동 되는 것을 DB에서 확인

Controller - read

• @PathVariable을 사용해 bno, page를 URL로 표시
• Criteria 객체를 생성하여 페이지 번호를 @PathVariable에서 입력

• URL에 입력한 값이 출력

• rno를 @PathVariable로 입력하여 댓글 조회

• 댓글 번호에 따른 조회 결과

Controller - update

• 수정할 값을 받기 때문에 request 객체를 이용하여 작성

• Method는 PUT과 PATCH를 이용하여 수정 PUT : 해당 자원의 전체를 변경 PATCH : 일부를 변경

• RequestBody를 이용하여 들어온 요청에 대하여 JSON 방식으로 받음

• VO에 rno를 담고 수정 되면 success, 실패시 error

• PATCH 방식으로 요청 하면 값이 수정된 것을 확인 할 수 있다.

Controller - delete

• @DeleteMapping 으로 선언하여 DELETE 방식으로 요청오면 해당 rno는 삭제 되고 성공 하면 success 실패시 error를 리턴 한다.

1. Oracle DB Hint
2. Paging
3. 검색기능

1. Oracle DB Hint

Select 문을 실행할 때 힌트(hint)를 사용하여 개발자가 실행 조건을 걸어주는 것

• 힌트 구문에서 에러가 발생하여도 SQL 실행에 지장을 주지 않는다.
• Order By 절의 FullScan하는 단점을 극복할 수 있다.
• INDEX_ASC or DESC (테이블명 PK)를 사용하여 정렬을 생략
• FULL(테이블명)으로 FullScanning 가능

Order By

• order by 정렬은 데이터가 많은 경우 엄청난 성능의 저하를 가져오기 때문에 데이터가 적거나, 정렬을 빠르게 하는 방법이 있지 않으면 지양한다.
• 계획 설명에서 보이듯 테이블을 FULL로 scan 한 것을 볼 수 있다.

Hint(INDEXT 사용)

/*+ INDEX_DESC(테이블명 제약조건명) */

• 힌트를 적용하려면 /*+ */ 와 같은 키워드 안에 작성하여 적용해야 한다.
• order by를 사용했을 때와 다르게 sort를 하지 않았고 제약조건을 사용하여 Range Scan을 했다.
• 힌트에서 자동으로 정렬을 해줘 order by 절로 정렬 하지않아도 정렬이 되어 있다.

ROWNUM

SQL이 실행된 결과에 넘버링을 해주는 역할 모든 SELECT문에 사용 가능

• ROWNUM을 선언하여 나오는 결과의 순서를 매긴다.
• 테이블에 존재하는 것이 아니라 가져온 데이터를 이용하여 순서를 매긴다.
• 위 예제는 Full Scan을 하면서 정렬이 되지 않았을 때 ROWNUM을 매기고 차후에 정렬이 되기 때문에 뒤죽박죽 상태란 것을 알 수 있다.

• Hint에 INDEX를 사용하여 기본 정렬 상태에서 ROWNUM을 적용한다면 순서에 맞게 매겨진다.
• 실행 계획에도 Full Scan이 아닌 Range Scan임을 확인 할 수 있다.

인라인 뷰(in-line view)

페이징 처리하기 위해 인라인뷰로 처리해야만 문제가 발생하지 않는다.

• 위와 같이 ROWNUM이 높은 순서대로 출력 된다.
• 이 때 2페이지부분을 구하기 위해 다시 쿼리문을 작성한다.

• 에러는 나오지 않지만 아무런 결과가 나오지 않는다.
• 그 이유는 ROWNUM은 새로운 데이터를 가져오는 순간 1로 시작되어 어떠한 조건이 1보다 큰 경우를 만족을 못하면 결과가 없게 된다.

• 위와 같이 FROM절에 인라인뷰를 이용하여 SELECT 문에는 ROWNUM의 총 갯수를 정해주고 정한 RN의 조건을 설정해 조건에 해당되는 데이터가 출력하게 쿼리문을 작성한다.

2. Paging

게시판의 기본 구조인 페이징 처리를 Mybatis 와 Spring을 활용해 구현

Mapper Test

• 페이징 처리를 위해 페이지 번호, 한 페이지의 글 갯수를 나타내 줘야 하기 때문에 객체를 생성
• 생성자를 생성해 각각의 파라미터 값을 선언

• 해당 도메인 객체를 가지는 BoardMapper 인터페이스에 메소드 등록
• VO객체를 사용하기 위해 List로 담아 선언

• 인라인 뷰를 적용한 쿼리문 작성

• 3페이지에 해당 되는 10개의 글을 출력하는 Test

• 10개 글 출력

Service Test

• 기존 getList() 메소드를 페이징 처리를 위해 Criterita 객체를 파라미터에 선언

• ServiceImpl 에서 또한 기존 getList() 메소드를 페이징 처리를 위해 Criteria 객체를 파라미터에 선언후 BoardMapper에 선언한 getListWithPaging 메소드 호출

• Serivce Test 또한 출력이 잘되는 것을 확인 할 수 있다.

Controller Test

• Service Test 까지 했으면, Web View와 직접적인 관련이 있는 Controller Test까지 진행한다.
• 페이징 처리 된 list를 호출 하기 위해 Criteria 파라미터를 선언하고 model 객체로 메소드를 담는다.

• get 방식으로 /board/list 까지 가져간다

• Controller 또한 에러 없이 Test가 됬다.

페이징 처리

• 페이징 처리를 위해 PageDTO 도메인 객체를 생성 한다.
• PageDTO에 기존에 만들었던 객체인 Criteria를 선언하여 페이지 관련된 값을 넘겨 받고, total을 선언하여 총 데이터 수를 입력한다.
• 파라미터 값을 넣어 연산이 가능한 로직을 작성한다.

• list에 Criteria 객체를 생성하고 Model객체를 생성하여 데이터를 담는다
• PageDTO를 선언하여 파라미터 값에 값을 선언후 pageMaker에 담는다.

• Model 객체로 pageMaker에 보낸 데이터를 el태그를 통해 페이지 뷰에 작성
• 이전, 현재, 다음 페이지의 el태그 선언

결과화면

3. 검색기능

Select문을 활용해 검색기능과 화면처리

• 페이징 처리에 검색 조건이 들어가면서 Criteria 객체에 type, keyword 변수가 추가 되고 삼항연산자를 사용하여 null이면 배열을 만들고 아니면 split을 이용해 각 타입을 분리한다.

• 위와 같이 작성하고 prefixOverrides를 사용해 맨 앞에온 OR은 지우고 괄호와 AND를 prefix와 suffix로 나타낸다.
• Criteria 객체에서 생성한 TypeArr의 type을 foreach를 통해 반복
• choose when 구문으로 조건별 LIKE를 선언해 키워드 입력 시 OR을 이용하여 구문을 생성

• 뷰 페이지에서 select option 태그를 사용해 pageMaker의 cri 객체의 type이 각 검색할 내용들이라면 selected 하고 아니면 공백을 둔다
• keyword를 입력하는 input 태그를 추가한다.

• 검색 이후 페이지를 이동해도 동일한 검색 list가 출력되어야 하기 때문에 hidden으로 type과 keyword 선언

결과화면

1. MVC CRUD Mapper Test
2. MVC CRUD Service Test
3. MVC CRUD Controller Test

1. MVC CRUD Mapper Test

Create, Read, Update, Delete를 Mapping이 되었는지 확인하기 위해 각 Mapper를 JUnit으로 Test

• 연동테스트를 위해 DB에 테이블 생성 및 더미 데이터 추가
• 데이터를 추가한 후 commit을 꼭 해야한다.

영속 계층 구현

1. 테이블 컬럼 구조 반영 VO 클래스 생성
2. Mybatis의 Mapper 인터페이서 작성 및 XML
3. 작성한 인터페이스 테스트

• DB에서 생성한 객체를 담을 수 있도록 도메인 객체를 위와 같이 생성
  

• Mybatis와 연동하기 위해 mapper 패키지를 scan 하기위해 위와 같이 작성
  

• SQL과 Mapping할 메소드들을 인터페이스로 선언

• 인터페이스에서 선언한 메소드와 같은 id로 선언하고 쿼리문 작성
• <![CDATA[...]]> 는 쿼리문의 부등호를 사용하기 위해 사용

• JUnit으로 Mapping이 잘되었는지 Test

Create Test

• 자동으로 PK가 결정시 처리 방법

1. insert만 처리되고 PK를 알 필요가 없는 경우
2. insert문이 실행되고 생성된 PK를 알아야 하는 경우

• 1번 방법인 기본 insert문과 2번 방법인 SelectKey 방법을 사용

• 1번 방법은 insert시 PK인 bno가 null 값으로 출력 되지만

• 2번 SelectKey 방법은 insert시 PK인 bno가 정상적으로 출력이 된다.

Read Test

• Select문을 사용하므로 resultType 선언
• bno에 해당하는 내용을 읽을 것이기 때문에 where절에 bno 선언

• VO 객체를 생성하여 bno가 5인 객체를 담고 log로 출력

Delete Test

Update Test

• VO 객체를 생성
• 생성한 객체에 set메소드를 통하여 수정할 변수들을 선언
• 선언한 bno에 대한 객체가 수정

2. MVC CRUD Service Test

Create, Read, Update, Delete를 비즈니스 로직을 위해 각 Service를 Test

• 비즈니스 계층을 위해 패키지를 생성
• BoardServiceImple은 느슨한 결합을 하기 위해 메소드를 구현하는 역할

• service 패키지를 스캔하기 위해 xml에 등록

Create Test

• BoardService 인터페이스를 생성해 메소드 등록

• @AllArgsConstructor 어노테이션은 단일 파라미터일 경우 자동으로 의존성 주입을 하는 어노테이션이다. 때문에 따로 Setter를 선언할 필요가 없다
• DB연동 체크를 위해 BoardMapper 객체를 생성
• Service 인터페이스에 메소드를 등록 했으므로 Override를 통해 구현

• Service를 Test 해야하기 때문에 객체를 생성후 @Autowired를 선언하여 의존성 주입
• VO 객체 생성 후 작성할 내용을 set메소드를 사용해 작성한다.
• service객체에서 생성한 메소드 선언

Read Test

Update Test

• 객체에서 1을 조회한다. 조회하는 이유는 bno가 1인 객체를 수정하기 위함이다.
• 조회한 값이 null 이면 return 하고 값이 있다면 set을 사용해 제목 수정한후 modify 메소드 호출

Delete Test

3. MVC CRUD Controller Test

Create, Read, Update, Delete를 웹으로 구현하기 위해 Controller를 Test

• @Controller 어노테이션을 통해 객체로 등록될 수 있도록 한다.
• RequestMapping으로 상위 경로를 설정
• @AllArgsConstructor로 파라미터 하나인 객체를 의존성 주입

• @WebApplicationConfiguration을 사용해 WebApplicationContext를 이용 할 수 있도록 설정
• @RunWith 는 JUnit을 사용할 수 있게 한다.
• @ContextConfiguration으로 설정 파일을 로드
• MockMvc는 WAS를 구동하지 않고 테스트를 할 수 있게 해준다.
• @Before 는테스트 메소드 실행 전 실행하게 해준다.

Create Test

• @GetMapping은 register.jsp로 이동하기 위함이다.
• 데이터 타입이 void 이면 url자체를 리턴한다.
• @PostMapping은 Post 방식을 처리하기 위함이다.
• command 방식으로 VO 객체를 가져온다.
• Redirect를 위해 RedirectAttributes를 선언
• Service에서 로직 처리한 메소드를 호출
• addFlashAttribute로 bno를 result에 담아 list로 redirect

• mockMvc 객체 내에 내장되어 있는 함수를 사용해 post 방식으로 register 경로로 데이터를 전달
• .param을 사용하여 전달할 파라미터값을 선언

Read Test

• Model 객체를 생성하여 데이터를 가지고 전달
• getList() 메소드를 list에 담는다.

Update Test

• VO 객체를 생성하고 list로 이동하기 위해 redirect 객체 선언
• 만약 수정을 한다면 success를 result에 담아 list로 redirect

• Post방식으로 modify로 이동
• .param으로 수정될 내용을 담는다.

Delete Test

• bno 값을 RequestParam으로 파라미터 값을 넣어준다.
• RequestParam은 HttpServletRequest와 같은 역할을 한다.

• Post 방식으로 14인 bno를 가지고 간다.

1. JUnit
2. Orcale Database 연동
3. Mybatis 연동
4. log4j
5. MVC Controller

1. JUnit

단위 테스트 도구로서 테스트를 쉽게 할 수 있게 만들어주는 라이브러리

• 어노테이션으로 간결하게 지원

예제

pom.xml에 위와 같이 라이브러리 등록

• chef 클래스는 @Component를 사용해 빈 등록
• @Data : Lombok을 사용해 자동으로 set/get 메소드 생성
• Restaurant 클래스에서 chef 객체를 선언하고 @Data를 통해 @Setter를 사용해 의존성 주입

• src/test/java 패키지에서 test 클래스를 생성
• JUnit Test Case 클래스를 선언하여 생성
• @RunWith는 현재 테스트 코드가 스프링을 실행하는 역할을 할 것이라는 것을 뜻함
• @ContextConfiguration은 지정된 클래스나 문자열을 이용해 객체를 스프링에 등록
• @Log4j는 log를 기록하는 Logger를 변수로 생성
• restaurant 객체를 생성하여 의존성 주입

• Restaurant에서 new 연산자를 통해 객체를 생성하지 않았음에도 객체가 생성됨

• @Component를 통해 빈 객체에 등록했기 때문

2. Orcale Database 연동

• Connection Pool을 위해 Hikari 라이브러리를 사용하기 위해 위와 pom.xml 과 servlet-xml에 위와 같이 셋팅

3. Mybatis 연동

• pom.xml 에 라이브러리 추가
• spring-jdbc / spring-tx : 스프링에서 DB처리와 트랜잭션 처리를 위함
• mybatis / mybatis-spring : 스프링과 연동

• SqlSessionFactory 등록
• mybatis 셋팅은 SQL을 별도로 설정을 분리하고 자동으로 처리될 수 있도록 Mapper 선언

• 어노테이션을 활용해 쿼리문을 짤 수 도 있다.

• timeMapper객체를 생성하고 의존성 주입

• 연동이 잘 되었는지 JUnit으로 테스트

4.log4jdbc-log4j2 설정

SQL문의 값을 제대로 확인하기 위해 SQL로그를 편리하게 바꿔주는 라이브러리

• pom.xml에 라이브러리 등록

• src/main/resources 에 log4jdbc.log4f2.properties 추가

• Hikari 셋팅을 위와 같이 해준다

• 위와 같이 가독성 좋게 로그가 출력

5. MVC Controller

MVC 패턴에서의 Controller의 역할

• HttpServletRequest, HttpServletResponse를 거의 사용할 필요 없이 구현이 가능
• 다양한 타입의 파라미터 처리 및 리턴이 가능
• Get,Post 방식에 대한 어노테이션으로 처리가 가능
• 상속/인터페이스 방식 대신 어노테이션 만으로도 설정이 가능

예제

• @Controller 는 해당 클래스를 자동적으로 스프링에 객체로 등록하게 해준다
• @RequestMapping은 메소드의 경로를 표현한다. 클래스에 선언할 시 클래스의 하위 메소드의 상위 주소를 가진다.

• SampleDTO에 @Data 어노테이션 적용

• 위 방식은 SampleDTO를 직접 파라미터에 선언하는 command 방식
• 객체 자체를 출력하면 내부 변수들이 출력

• @RequestParam을 사용해 객체의 변수명을 가져오고 변수를 셋팅
• 각 객체에 대한 변수를 선언 하여 출력

1. Mybatis
2. CRUD
3. @RequestParam
4. @ModelAttibute
5. @PathVariable(RESTful)
6. tiles

1. Mybatis 연동

 <Context docBase="spring_web" 
          path="/spring_web" 
          reloadable="true" 
          source="org.eclipse.jst.jee.server:spring_web">
          <Resource auth="Container" 
                  driverClassName="oracle.jdbc.driver.OracleDriver" 
                  maxActive="100" maxIdle="30" maxWait="10000" name="jdbc/oracle"
                  password="1234" type="javax.sql.DataSource" 
                  url="jdbc:oracle:thin:@localhost:1521:XE" username="kosta236"/>
 </Context>

위와 같은 형식으로 server.xml에 등록 해준다.

<!-- Mybatis Setting -->

    <bean id="sqlSessionTemplate"
        class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"></constructor-arg>    
    </bean>

    <bean id="sqlSessionFactory"
        class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="myDataSource"/>
        <property name="configLocation" value="/WEB-INF/mybatis-config.xml"></property>
    </bean>

    <bean id="myDataSource"
        class="org.springframework.jndi.JndiObjectFactoryBean">
        <property name="jndiName" value="jdbc/oracle"/>
        <property name="resourceRef" value="true"/>
    </bean>

sqlSessionTemplate을 사용하기 위해 위와 같은 과정을 진행한다.

@Repository
public class BoardDao {

    @Autowired
    private SqlSessionTemplate sqlTemplate;

    public void insert(Board board) {
        sqlTemplate.getMapper(BoardMapper.class).insertBoard(board);
    }
}

최종적으로 DAO에서 sqlSessionTemplate을 사용하여 Mapping 한다.

2.CRUD

CRUD (Create, Read, Update, Delete)를 Spring을 이용하여 구현

<mapper namespace="kosta.mapper.BoardMapper">
    <cache />

    <insert id="insertBoard" parameterType="Board">
        insert into board(
            seq,title,writer,contents, regdate, hitcount
        )values(
            board_seq.nextval, #{title}, #{writer}, #{contents}, sysdate, 0 
        )

    </insert>

      <select id="listBoard" resultType="Board">
        select * from board
        order by seq desc
    </select>

    <select id="detailBoard" resultType="Board" parameterType="int">
        select * from board where seq=#{seq}
    </select> 

    <update id="updateBoard" parameterType="Board">
        update board set title=#{title}, contents=#{contents} where seq=#{seq}
    </update>

    <delete id="deleteBoard" parameterType="int">
        delete from board where seq=#{seq}
    </delete>   
</mapper>

Mapping할 CRUD의 쿼리문을 사용하기 위한 xml파일을 생성해 위와 같이 코딩 select를 제외한 모든 DML에는 parameterType을 선언

public interface BoardMapper {
    List<Board> listBoard();
    int insertBoard(Board board);
    Board detailBoard(int seq);
    int updateBoard(Board board);
    int deleteBoard(int seq);

}

CRUD에 해당되는 추상 메소드들을 Mapping

package kosta.model;

import java.io.Serializable;

import javax.validation.constraints.Pattern;
import javax.validation.constraints.Size;

import org.hibernate.validator.constraints.NotEmpty;

public class Board implements Serializable{

    private int seq;

    @NotEmpty(message = "반드시 입력하세요")
    @Size(min = 2, max = 5, message = "글자수 2~5까지")
    private String title;

    @Pattern(regexp = "[0-9a-zA-Z가-힣]*", message = "특수문자 금지")
    private String writer;

    private String contents;
    private String regdate;
    private int hitcount;

    public Board() {

    }

    public Board(int seq, String title, String writer, String contents, String regdate, int hitcount) {
        super();
        this.seq = seq;
        this.title = title;
        this.writer = writer;
        this.contents = contents;
        this.regdate = regdate;
        this.hitcount = hitcount;
    }

    public int getSeq() {
        return seq;
    }

    public void setSeq(int seq) {
        this.seq = seq;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getWriter() {
        return writer;
    }

    public void setWriter(String writer) {
        this.writer = writer;
    }

    public String getContents() {
        return contents;
    }

    public void setContents(String contents) {
        this.contents = contents;
    }

    public String getRegdate() {
        return regdate;
    }

    public void setRegdate(String regdate) {
        this.regdate = regdate;
    }

    public int getHitcount() {
        return hitcount;
    }

    public void setHitcount(int hitcount) {
        this.hitcount = hitcount;
    }

    @Override
    public String toString() {
        return "Board [seq=" + seq + ", title=" + title + ", writer=" + writer + ", contents=" + contents + ", regdate="
                + regdate + ", hitcount=" + hitcount + "]";
    }

}

Serializable한 DTO 객체 생성

@Repository
public class BoardDao {

    @Autowired
    private SqlSessionTemplate sqlTemplate;

    public void insert(Board board) {
        sqlTemplate.getMapper(BoardMapper.class).insertBoard(board);
    }

    public List<Board> list() {
        return sqlTemplate.getMapper(BoardMapper.class).listBoard();
    }

    public Board detail(int seq) {
        return sqlTemplate.getMapper(BoardMapper.class).detailBoard(seq);
    }

    public void update(Board board) {
        sqlTemplate.getMapper(BoardMapper.class).updateBoard(board);
    }

    public void delete(int seq) {
        sqlTemplate.getMapper(BoardMapper.class).deleteBoard(seq);
    }
}

@Repository를 사용하여 빈 등록을 해 Container에 객체 생성 @Autowired를 통해 의존성 주입 sql 객체를 생성한 sqlTemplate으로 Mapping

@Controller
public class BoardController {
    @Autowired
    private BoardDao dao;

    //@RequestMapping(value = "/board_insert", method = RequestMethod.GET)
    @GetMapping("/board_insert")
    public String board_form(@ModelAttribute("boardCommand") Board board) {
        System.out.println("form 페이지 이동");
        return "insert_form";
    }

    //@RequestMapping(value = "/board_insert", method = RequestMethod.POST)
    @PostMapping("/board_insert")
    public String board_insert(@ModelAttribute("boardCommand") @Valid Board board, BindingResult errors) {

        if(errors.hasErrors()) {
            System.out.println("에러발생");
            return "insert_form";
        }

        dao.insert(board);

        return "redirect:board_list";
    }

    @RequestMapping("/board_list")
    public String board_list(Model model) {
        List<Board> list = dao.list();

        model.addAttribute("list",list);

        return "list";
    }

    /*
     * @RequestMapping("/board_detail") public String
     * board_detail(@RequestParam("seq") int seq, Model model) {
     * model.addAttribute("board",dao.detail(seq));
     * 
     * return "detail"; }
     */

    @RequestMapping("/board_detail{seq}")
    public String board_detail(@PathVariable int seq, Model model) {
        model.addAttribute("board",dao.detail(seq));

        return "detail";
    }

    @GetMapping("/board_update")
    public String update_form(@RequestParam("seq") int seq, Model model) {
        model.addAttribute("board", dao.detail(seq));

        return "updateForm";
    }

    @PostMapping("/board_update")
    public String board_update(Board board) {
        dao.update(board);

        return "redirect:board_list";
    }

    @RequestMapping("/board_delete")
    public String delete_board(@RequestParam("seq") int seq) {
        dao.delete(seq);

        return("redirect:board_list");
    }

}

클래스에 @Controller를 선언하여 Controller임을 알려주고 @RequestMapping을 통하여 URL Mapping String을 이용하여 바로 view로 return 각 메소드별 data를 받는 파라미터에 따라 Mapping

3. @RequestParam

파라미터값을 가져올 수 있는 어노테이션이다. 가져오는 파라미터값을 명확하게 하기 위해 사용한다.

• 1:1로 파라미터를 받는 경우에 사용한다.
• name, value : 파라미터 이름
• required : 해당 파라미터가 필요한지의 여부
• defaultValue : 해당 파라미터의 기본 값

@GetMapping("/board_update")
    public String update_form(@RequestParam("seq") int seq, Model model) {
        model.addAttribute("board", dao.detail(seq));

        return "updateForm";
    }

seq라는 파라미터값을 가져와 seq 라는 변수를 선언

4. @ModelAttribute

파라미터값을 가져올 수 있는 어노테이션

• @RequestParam 과의 차이점으로는 도메인, 오브젝트를 통하여 파라미터를 받는다.

• Validation을 사용하여 에러 처리가 가능하다.

  @PostMapping("/board_insert")
   public String board_insert(@ModelAttribute("boardCommand") @Valid Board board, BindingResult errors) {
  
       if(errors.hasErrors()) {
           System.out.println("에러발생");
           return "insert_form";
       }
  
       dao.insert(board);
  
       return "redirect:board_list";
   }
  

• boardCommand 라는 commandName을 가진 form 태그의 정보들을 한 번에 가져오기 위해 사용

5. @PathVariable(RESTful)

URL 경로에 변수를 넣어주는 어노테이션

• @RequestMapping의 URL 정의 부분과 메소드 내의 파라미터 부분에 정의하여 사용

• null 혹은 공백값이 들어가는 파라미터라면 적용이 되지 않는다.

• 해당 어노테이션과 동일한 이름(템플릿 변수)를 가지는 파라미터에 적용

  @RequestMapping("/board_detail{seq}")
   public String board_detail(@PathVariable int seq, Model model) {
       model.addAttribute("board",dao.detail(seq));
  
       return "detail";
   }
  

• URL 주소 옆에 해당 변수 값을 {} 내에 추가

• @PathVariable을 통해 int seq를 선언한다.

6. tiles

tiles는 View의 기존 구조를 쉽게 적용하기 위한 템플릿 프레임워크이다.

• 페이지 수정이 쉬워 유지보수가 용이
• 일관적인 페이지 관리 가능

1. pom.xml에 라이브러리 추가

        <dependency>
            <groupId>org.apache.tiles</groupId>
            <artifactId>tiles-jsp</artifactId>
            <version>3.0.7</version>
        </dependency>

        <dependency>
            <groupId>org.apache.tiles</groupId>
            <artifactId>tiles-core</artifactId>
            <version>3.0.7</version>
        </dependency>

        <dependency>
            <groupId>org.apache.tiles</groupId>
            <artifactId>tiles-servlet</artifactId>
            <version>3.0.7</version>
        </dependency>

• 총 세가지의 라이브러리를 추가
• 버전은 3.0.7로 통일

2. Dispatcher Servlet.xml에 View Resolver, xml 추가

<!-- Tiles Setting -->

    <bean id="viewResolver2"
        class="org.springframework.web.servlet.view.UrlBasedViewResolver">
        <property name="viewClass"
            value="org.springframework.web.servlet.view.tiles3.TilesView"/>
        <property name="order" value="1"/>    
    </bean>

    <bean id="tilesConfigurer" 
        class="org.springframework.web.servlet.view.tiles3.TilesConfigurer">
        <property name="definitions">
            <list>
                <value>/WEB-INF/tiles2def.xml</value>
            </list>
        </property>
    </bean>

• 중요한 부분은 order 속성을 최우선 1번 지정하여 tiles에 해당되는 로직을 우선적으로 로드 시킨 다는 의미이다.
• 이에 따라 다른 order 속성도 차후 번호를 선언하여 주어야 한다.

3. tile-def.xml 설정

<tiles-definitions>

    <definition name="base_layout" template="/view/module/template.jsp">
        <put-attribute name="header" value="/view/module/header.jsp"/>    
        <put-attribute name="logo" value="/view/module/logo.jsp"/>    
        <put-attribute name="footer" value="/view/module/footer.jsp"/>    
    </definition>

    <definition name="insert_form" extends="base_layout">
        <put-attribute name="body" value="/view/insert_form.jsp"/>
    </definition>

    <definition name="list" extends="base_layout">
        <put-attribute name="body" value="/view/list.jsp"/>
    </definition>


</tiles-definitions>

• 위 설정 파일은 tiles의 layout을 적용하는 화면을 설정
• base_layout이라는 name을 가진 템플릿은 value로 설정한 경로의 내용에 맞는 header와 footer를 가지고 있다.
• 나머지 name을 가진 태그들은 base_layout을 상속받아 기본적으로 header, footer의 속성을 가지고 있을 수 있게 선언
• name은 URL을 통해서 가는 View와 이름이 같아야 한다.

4. 기본 레이아웃을 JSP에 추가

• template.jsp 에서 tiles 태그를 사용해 xml에서 정해준 name을 선언

5. 결과

어플리케이션의 확장을 위해 Model, View, Controller로 분리하여 개발 하는 방법

• 컴포넌트의 변경이 다른 영역 컴포넌트에 영향을 미치지 않음
• 컴포넌트 간의 결합성이 낮아 프로그램 수정이 용이

장점

• 화면과 비즈니스 로직을 분리해서 작업 가능
• 영역별 개발로 확장성이 뛰어남
• 표준화된 코드를 사용하여 공동작업 및 유지보수가 편리함

단점

• 개발과정이 복잡, 초기 개발속도가 늦을 수 있음
• 초보자가 활용하기엔 난이도가 높음

MVC 패턴 구조 순서

Dispatcher Servlet : url의 요청을 받아서 연결 시켜줌 Handler Mapping : Dispatcher Servlet이 Controller로 매핑 하는 방식을 결정 Controller : 로직을 처리 ModelAndView : view 이름, data를 담는다 ViewResolver : view 타입을 정함 View : 받은 data를 출력

요청 처리 순서

1. Dispatcher Servlet이 request를 수신 -> 어느 컨트롤러에 요청할지 Handler Mapping에게 보냄
2. Handler Mapping은 Dispatcher Servlet에게 요청을 받아 URL과 Mapping
3. Dispatcher Servlet은 요청을 Controller에게 전송하여 Controller는 요청을 처리 후 Model을 생성하고 View를 return
4. ModelAndView 오브젝트는 수행결과를 포함하여 Dispathcer Servlet에 return
5. ViewResolver가 JSP로 출력하도록 논리적 이름을 실제로 변환
6. View에 출력

Maven 셋팅

• Spring MVC : mvc를 사용하기 위함
• validator : @valid, @InitBinder 어노테이션을 주기 위함

Dispatcher Servlet 셋팅

• springapp인 servlet-name을 선언
• mapping시 동일한 name을 선언
• url-pattern은 /를 주어 모든 요청에 대한 Dispathcer Serlvet이 처리하는 URL Mapping 패턴을 정의

• web.xml에서 주었던 name으로 xml 생성
• context 태그를 이용하여 kosta 패키지 안의 어노테이션을 scan
• mvc 태그를 이용하여 Mapping되는 Controller가 없어도 Handler가 default로 빈 객체로 등록되어 요청을 전달
• ViewResolver는 Controller가 넘긴 view 이름을 받아 view를 찾음

📘 MVC 예제

• getMessage 메소드에서 String 타입을 return

• @Controller로 Controller인 클래스를 지정해주고 setter를 통해 의존성 주입
• @RequestMapping을 통해 URL 지정을 해주고 ModelAndView 객체를 생성하여 view의 이름과 메세지의 data를 담아 return

• message라고 정한 data를 가져온다.

Board.java - 객체

package kosta.model;

import java.io.Serializable;

public class Board implements Serializable {
    private int seq;
    private String title;
    private String writer;
    private String contents;
    private String regdate;
    private int hitcount;

    public Board() {

    }

    public Board(int seq, String title, String writer, String contents, String regdate, int hitcount) {
        super();
        this.seq = seq;
        this.title = title;
        this.writer = writer;
        this.contents = contents;
        this.regdate = regdate;
        this.hitcount = hitcount;
    }

    public int getSeq() {
        return seq;
    }

    public void setSeq(int seq) {
        this.seq = seq;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getWriter() {
        return writer;
    }

    public void setWriter(String writer) {
        this.writer = writer;
    }

    public String getContents() {
        return contents;
    }

    public void setContents(String contents) {
        this.contents = contents;
    }

    public String getRegdate() {
        return regdate;
    }

    public void setRegdate(String regdate) {
        this.regdate = regdate;
    }

    public int getHitcount() {
        return hitcount;
    }

    public void setHitcount(int hitcount) {
        this.hitcount = hitcount;
    }

    @Override
    public String toString() {
        return "Board [seq=" + seq + ", title=" + title + ", writer=" + writer + ", contents=" + contents + ", regdate="
                + regdate + ", hitcount=" + hitcount + "]";
    }


}

BoardDao.java

public class BoardDao2 {
    private static BoardDao2 dao = new BoardDao2();

    public static BoardDao2 getInstance() {
        return dao;
    }

    public SqlSessionFactory getSqlSessionFactory() {
        //mybatis-config.xml => SqlSessionFactory 변환
        String resource = "mybatis-config.xml";
        InputStream in = null;

        try {
            in = Resources.getResourceAsStream(resource);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return new SqlSessionFactoryBuilder().build(in);
    }



    public int insertBoard(Board board) {
        SqlSession sqlSession = getSqlSessionFactory().openSession();
        int re = -1;

        try {
            //re = sqlSession.insert("kosta.mapper.BoardMapper.insertBoard", board);
            re = sqlSession.getMapper(BoardMapper.class).insertBoard(board);
            if(re>0) {
                sqlSession.commit();
            }else {
                sqlSession.rollback();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(sqlSession != null) {
                sqlSession.close();
            }
        }

        return re;
    }

    public List<Board> listBoard(){
        SqlSession sqlSession = getSqlSessionFactory().openSession();
        List<Board> list = null;

        try {
            //list = sqlSession.selectList("kosta.mapper.BoardMapper.listBoard");
            list = sqlSession.getMapper(BoardMapper.class).listBoard();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(sqlSession != null) {
                sqlSession.close();
            }
        }
        return list;
    }

    public Board detailBoard(int seq) {
        SqlSession sqlSession = getSqlSessionFactory().openSession();
        Board board = null;

        try {
            board = sqlSession.getMapper(BoardMapper.class).detailBoard(seq);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(sqlSession != null) {
                sqlSession.close();
            }
        }
        return board;
    }

BoardService.java

package kosta.service;

import java.util.List;

import javax.servlet.http.HttpServletRequest;

import kosta.model.Board;
import kosta.model.BoardDao2;

public class BoardService {
    private static BoardService service = new BoardService();
    private static BoardDao2 dao;

    public static BoardService getInstance() {
        dao = BoardDao2.getInstance();
        return service;
    }

    public int insertBoardService(HttpServletRequest request)throws Exception {
        request.setCharacterEncoding("utf-8");
        Board board = new Board();
        board.setTitle(request.getParameter("title"));
        board.setWriter(request.getParameter("writer"));
        board.setContents(request.getParameter("contents"));

        return dao.insertBoard(board);
    }

    public List<Board> listBoardService(HttpServletRequest request)throws Exception{
        List<Board> list = dao.listBoard();

        return list;
    }

    public Board detailBoard(int seq)throws Exception {

        return dao.detailBoard(seq);
    }
}

Controller.java

package kosta.controller;

import java.io.IOException;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import kosta.action.Action;
import kosta.action.ActionForward;
import kosta.action.DetailAction;
import kosta.action.InsertAction;
import kosta.action.InsertFormAction;
import kosta.action.ListAction;

@WebServlet("/board/*")
public class MyController extends HttpServlet {
    private static final long serialVersionUID = 1L;

    public MyController() {
        super();
    }

    public void doProcess(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException  {
        //url 식별
        String requestURI = request.getRequestURI();  // /MVC/board/list.do
        String contextPath = request.getContextPath();
        String command = requestURI.substring(contextPath.length()+7);
        System.out.println(command);

        Action action = null;
        ActionForward forward = null;

        if(command.equals("insertForm.do")) {
            action = new InsertFormAction();
            try {
                forward = action.execute(request, response);
            } catch (Exception e) {
                e.printStackTrace();
            }

        }else if(command.equals("insertAction.do")) {
            action = new InsertAction();
            try {
                forward = action.execute(request, response);
            } catch (Exception e) {
                e.printStackTrace();
            }

        }else if(command.equals("listAction.do")) {
            action = new ListAction();
            try {
                forward = action.execute(request, response);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }else if(command.equals("detailAction.do")) {
            action = new DetailAction();
            try {
                forward = action.execute(request, response);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        if(forward != null) {
            if(forward.isRedirect()) { //redirect
                response.sendRedirect(forward.getPath());
            }else { //Dispatcher
                RequestDispatcher dispatcher = request.getRequestDispatcher(forward.getPath());
                dispatcher.forward(request, response);
            }
        }
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doProcess(request, response);
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doProcess(request, response);
    }

}

BoardDao.java

public List<Board> listBoard() {
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        List<Board> list = null; //ResultSet => Board => List

        String sql = "select * from board order by seq desc";

        try {
            conn = getDBCPConnection();
            pstmt = conn.prepareStatement(sql);
            rs = pstmt.executeQuery();
            list = new ArrayList<Board>();

            while(rs.next()) {
                Board board = new Board(); //1객체 <= 1로우
                board.setSeq(rs.getInt("seq"));
                board.setTitle(rs.getString("title"));
                board.setWriter(rs.getString("writer"));
                board.setContents(rs.getString("contents"));
                board.setRegdate(rs.getString("regdate"));
                board.setHitcount(rs.getInt("hitcount"));

                list.add(board);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(pstmt != null) {
                try {

                } catch (Exception e2) {}
            }
        }

        return list;
    }

list.jsp

<%@page import="kosta.bean.Board"%>
<%@page import="java.util.List"%>
<%@page import="kosta.bean.BoardDao2"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<%
    BoardDao2 dao = BoardDao2.getInstance();
    List<Board> list = dao.listBoard();
%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    <a href="insert_form.jsp">글쓰기</a>
    <table border="1">
        <tr>
            <td>글번호</td>
            <td>제목</td>
            <td>작성자</td>
            <td>작성일자</td>
            <td>조회수</td>
        </tr>
        <% for(int i = 0; i < list.size(); i++) { 
                Board board = list.get(i);
        %>
        <tr>
            <td><%= board.getSeq() %></td>
            <td><a href="detail.jsp?seq=<%= board.getSeq() %>"><%= board.getTitle() %></a></td>
            <td><%= board.getWriter() %></td>
            <td><%= board.getRegdate() %></td>
            <td><%= board.getHitcount() %></td>
        </tr>
        <%} %>
    </table>
</body>
</html>

📃 각 게시글에 대한 상세 정보 가져오기

board.java

    public Board detailBoard(int seq) {
        Board board = new Board();
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        String sql = "select * from board where seq=?";

        try {
            conn = getDBCPConnection();
            pstmt = conn.prepareStatement(sql);
            pstmt.setInt(1, seq);
            rs = pstmt.executeQuery();

            if(rs.next()) {

                board.setSeq(rs.getInt("seq"));
                board.setTitle(rs.getString("title"));
                board.setWriter(rs.getString("writer"));
                board.setContents(rs.getString("contents"));
                board.setRegdate(rs.getString("regdate"));
                board.setHitcount(rs.getInt("hitcount"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {

        }

        return board;
    }

detail.jsp

<%@page import="kosta.bean.Board"%>
<%@page import="kosta.bean.BoardDao"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<!-- 글번호 받기 String -> int
    BoardDao 객체 구하기
    BoardDao detailBoard() 호출
    결과값을 화면에 적절히 출력 -->    

<%
    int seq = 1;
    if(request.getParameter("seq") != null){
        seq = Integer.parseInt(request.getParameter("seq"));
    }

    BoardDao dao = BoardDao.getInstance();
    Board board = dao.detailBoard(seq);

%>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<ul>
    <li><%= board.getSeq() %></li>
    <li><%= board.getTitle() %></li>
    <li><%= board.getWriter() %></li>
    <li><%= board.getContents() %></li>
    <li><%= board.getHitcount() %></li>

</ul>
<br>

<a href="updateForm.jsp?seq=<%=seq%>">글수정</a>

</body>
</html>

📃 글 내용 수정하기

BoardDao.java

public int update(Board board) {
        int re = -1;
        Connection conn = null;
        PreparedStatement pstmt = null;

        String sql = "update board set title=?,contents=? where seq=?";
        try {
            conn = getDBCPConnection();
            pstmt = conn.prepareStatement(sql);

            pstmt.setString(1, board.getTitle());
            pstmt.setString(2, board.getContents());
            pstmt.setInt(3, board.getSeq());

            re = pstmt.executeUpdate();

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(pstmt != null) {
                try {
                    pstmt.close();
                } catch (Exception e2) {}
            }
        }
        return re;
    }

updateForm.jsp

<%@page import="kosta.bean.Board"%>
<%@page import="kosta.bean.BoardDao"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

    <%
    int seq = 1;
    if(request.getParameter("seq") != null){
        seq = Integer.parseInt(request.getParameter("seq"));
    }

    BoardDao dao = BoardDao.getInstance();
    Board board = dao.detailBoard(seq);

%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    <h3>글 수정 폼</h3>
    <form action="updateProc.jsp" method="post">
        <input type="hidden" name="seq" value="<%= board.getSeq()%>">
        작성자 : <%= board.getWriter() %><br>
        제목 : <input type="text" name="title" value="<%= board.getTitle()%>"><br>
        내용 : <br>
        <textarea rows="6" cols="70" name="contents"><%= board.getContents()%></textarea>
        <input type="submit" value="수정완료">
    </form>
</body>
</html>

updateProc.jsp

<%@page import="kosta.bean.BoardDao"%>
<%@page import="java.sql.ResultSet"%>
<%@page import="java.sql.PreparedStatement"%>
<%@page import="java.sql.Connection"%>
<%@page import="kosta.bean.Board"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

<%
    request.setCharacterEncoding("utf-8");
%>
<jsp:useBean id="board" class="kosta.bean.Board"/>
<jsp:setProperty property="*" name="board"/>
<%
    BoardDao dao = BoardDao.getInstance();
    int re = dao.update(board);

    if(re > 0){
        response.sendRedirect("list.jsp");
    }

%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>

</body>
</html>

자바 어플리케이션에서도 직접 관계형 DBMS를 제어할 수 있다. 그러한 역할을 돕는 API가 JDBC(Java DataBase Connectivity) API이다.

Java 코드를 이용한 DBMS 제어

** 1. JDBC 드라이버 로딩**

Class.forName("JDBC드라이버 이름"); 으로 JDBC 드라이버를 로딩한다.

• Oracle : "jdbc:oracle:thin:@localhost:1521:XE"
• MySQL : "com.mysql.cj.jdbc.Driver"

** 2. Connection 객체 생성 **

로드한 JDBC 드라이버를 통해 관계형 DBMS와 연결하는 단계

• DriverManager : 관계형 DBMS와의 연결을 요청하는 getConncetion 메서드를 가짐
• JDBC URL : DBMS와의 연결을 위한 식별값
• Connection : 관계형 DBMS와 통신하는 메서드로 구성

** 3. Statement 객체 생성**

해당 객체는 쿼리를 생성 및 실행할 작업 영역을 제공

** 4. 쿼리수행**

JDBC 기본적인 사용

연결 테스트

package test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class ConnectionTest {
    public static void main(String[] args) {
        // java 표준인 java.sql.Connection 클래스를 import해야 한다.
        Connection conn = null;

        try{
            // 1. 드라이버 로딩
            // 드라이버 인터페이스를 구현한 클래스를 로딩
            // mysql, oracle 등 각 벤더사 마다 클래스 이름이 다르다.
            // mysql은 "com.mysql.jdbc.Driver"이며, 이는 외우는 것이 아니라 구글링하면 된다.
            // 참고로 이전에 연동했던 jar 파일을 보면 com.mysql.jdbc 패키지에 Driver 라는 클래스가 있다.
            Class.forName("com.mysql.jdbc.Driver");

            // 2. 연결하기
            // 드라이버 매니저에게 Connection 객체를 달라고 요청한다.
            // Connection을 얻기 위해 필요한 url 역시, 벤더사마다 다르다.
            // mysql은 "jdbc:mysql://localhost/사용할db이름" 이다.
            String url = "jdbc:mysql://localhost/dev";

            // @param  getConnection(url, userName, password);
            // @return Connection
            conn = DriverManager.getConnection(url, "dev", "dev");
            System.out.println("연결 성공");

        }
        catch(ClassNotFoundException e){
            System.out.println("드라이버 로딩 실패");
        }
        catch(SQLException e){
            System.out.println("에러: " + e);
        }
        finally{
            try{
                if( conn != null && !conn.isClosed()){
                    conn.close();
                }
            }
            catch( SQLException e){
                e.printStackTrace();
            }
        }
    }
}

SELECT 쿼리 실행

public class SelectTest {
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;

        try{
            // 1. 드라이버 로딩
            Class.forName("com.mysql.jdbc.Driver");

            // 2. 연결하기
            String url = "jdbc:mysql://localhost/dev";
            conn = DriverManager.getConnection(url, "dev", "dev");


            // 3. 쿼리 수행을 위한 Statement 객체 생성
            stmt = conn.createStatement();

            // 4. SQL 쿼리 작성
            // 주의사항
            // 1) JDBC에서 쿼리를 작성할 때는 세미콜론(;)을 빼고 작성한다.
            // 2) SELECT 할 때 * 으로 모든 칼럼을 가져오는 것보다
            //   가져와야 할 칼럼을 직접 명시해주는 것이 좋다.
            // 3) 원하는 결과는 쿼리로써 마무리 짓고, java 코드로 후작업 하는 것은 권하지 않음
            // 4) 쿼리를 한 줄로 쓰기 어려운 경우 들여쓰기를 사용해도 되지만 띄어쓰기에 유의 !!
            String sql = "SELECT name, owner, date_format(birth, '%Y년%m월%d일' date FROM pet";


            // 5. 쿼리 수행
            // 레코드들은 ResultSet 객체에 추가된다.
            rs = stmt.executeQuery(sql);

            // 6. 실행결과 출력하기
            while(rs.next()){
                // 레코드의 칼럼은 배열과 달리 0부터 시작하지 않고 1부터 시작한다.
                // 데이터베이스에서 가져오는 데이터의 타입에 맞게 getString 또는 getInt 등을 호출한다.
                String name = rs.getString(1);
                String owner = rs.getString(2);
                String date = rs.getString(3);

                System.out.println(name + " " + owner + " " + date);
            }
        }
        catch( ClassNotFoundException e){
            System.out.println("드라이버 로딩 실패");
        }
        catch( SQLException e){
            System.out.println("에러 " + e);
        }
        finally{
            try{
                if( conn != null && !conn.isClosed()){
                    conn.close();
                }
                if( stmt != null && !stmt.isClosed()){
                    stmt.close();
                }
                if( rs != null && !rs.isClosed()){
                    rs.close();
                }
            }
            catch( SQLException e){
                e.printStackTrace();
            }
        }
    }
}

INSERT 쿼리 실행

    public int insertBoard(Board board) {
        Connection conn = null;
        PreparedStatement pstmt = null;

        //url, user, password 
        String url = "jdbc:oracle:thin:@localhost:1521:XE";
        String user = "kosta236";
        String password = "1234";

        String sql = "insert into board values(board_seq.nextval,?,?,?,sysdate,0)";
        int re = -1;


        try {
            //1단계 : JDBC 드라이버 로딩 => 어떤 DB?
            Class.forName("oracle.jdbc.driver.OracleDriver");

            //2단계 : DB 연결 (Connenction 객체 생성)
            conn = DriverManager.getConnection(url, user, password);
            System.out.println("conn : " + conn);

            //3단계 : PrepareStatement 객체 생성(SQL 질의)
            pstmt = conn.prepareStatement(sql);
            pstmt.setString(1, board.getTitle());
            pstmt.setString(2, board.getWriter());
            pstmt.setString(3, board.getContents());

            //4단계 : SQL문 실행(re => 실행된 row 갯수)
            re = pstmt.executeUpdate(); //insert, update, delete

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(pstmt != null) {
                try {
                    pstmt.close();
                } catch (Exception e2) {}
            }
            if(conn != null) {
                try {
                    conn.close();
                } catch (Exception e2) {}
            }
        }//end finally

        return re;
    }//end insertBoard
}//end class

쿼리를 수행할 때 동적으로 할댕해야 하는 값이 있으면 PreparedStatement 객체를 사용하고, 동적으로 할당할 필요가 없으면 Statement 객체를 사용한다.

쿼리의 결과가 있으면 executeQuery() 메서드를 호출하여 ResultSet 객체에 담고, 쿼리의 결과가 없으면 executeUpdate() 메서드를 호출하여 int형 변수에 결과 값을 할당 한다.

login.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>ch06 : login.jsp</title>
</head>
<body>
<div align="center">
    <H2>로그인</H2>
    <form name="form1" method="POST" action="selProduct.jsp">
        <input type="text" name="username"/>
        <input type="submit" value="로그인"/>
    </form>
</div>
</body>
</html>

selProduct.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" import="java.util.*"%>
<%
    request.setCharacterEncoding("utf-8");
    String username = request.getParameter("username");
    session.setAttribute("username", username);
%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<HTML>
<HEAD>
<title>ch06 : selProduct.jsp</title>
</head>

<body>
<div align="center">
    <H2>상품선택</H2>
    <HR>
    ${username } 님 환영합니다!!!!
    <HR>
    <form name="form1" method="POST" action="add.jsp">
        <SELECT name="fruit">
            <option>사과</option>
            <option>귤</option>
            <option>파인애플</option>
            <option>자몽</option>
            <option>레몬</option>
        </SELECT>
        가격 : <input type="text" name="price"><br>
        수량 : <input type="text" name="amount"><br>
        <input type="submit" value="추가"/>
    </form>
    <a href="checkOut.jsp">계산</a>
</div>
</body>
</html>

add.jsp

<%@page import="kosta.bean.Product"%>
<%@page import="java.util.List"%>
<%@page import="java.util.ArrayList"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

    <%! List<Product> list = new ArrayList<Product>(); %>

    <%
        request.setCharacterEncoding("utf-8");
    %>

    <jsp:useBean id="product" class="kosta.bean.Product"/>
    <jsp:setProperty property="*" name="product"/>

    <% 

        list = (List)session.getAttribute("productlist");

        if(list == null){
            list = new ArrayList<Product>();
            session.setAttribute("productlist", list);
        }

        list.add(product);

    %>




<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    <a href="javascript:history.back()">뒤로가기</a>
    <%=product.getFruit() %>

</body>
</html>

checkOut.jsp

<%@page import="kosta.bean.Product"%>
<%@page import="java.util.List"%>
<%@page import="java.util.ArrayList"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
    <%
        request.setCharacterEncoding("utf-8");

        List<Product> list = (List)session.getAttribute("productlist");

    /*     if(list == null){
            out.println("상품없음");
        }else{
            for(String fruit : list){
                out.println(fruit + "<br>");
            }
        } */


    %>


<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    <%
        if(list == null){
    %>
        <b>선택한 상품이 없습니다.</b>
    <%    }else { %>
        <ul>
    <% 
            int total = 0;
            for(int i = 0; i < list.size(); i++) {
                Product product = list.get(i);
                total += (product.getPrice() * product.getAmount());
    %>
            <li><%= product.getFruit() %> : <%= product.getPrice() %> * <%= product.getAmount() %> = <%= (product.getPrice() * product.getAmount()) %></li>
        <%} %>
        </ul>
        <br>
        주문한 총 금액 : <%= total %> 원
    <%} %>
</body>
</html>

JSP는 기본적으로 HTML 문서 안에 자바 언어를 삽입해 사용할 수 있도록 해준다.

그래서 실제로 대부분의 변수 선언, 메서드 선언, 로직 등은 자바 언어로 짜게 된다.

하지만 자바 코드를 HTML 사이에 끼워 넣을 때 필요한 문법이 몇가지 있다.

1. 스크립트릿(Scriptlet)

<% %> 으로 시작하고 끝나는 태그

JSP 문법의 가장 기본이 되는 태그, 대부분의 JSP 문법 표현을 이 스크립트릿을 기본으로 한다.

<% %> 사이에 실행될 자바 코드를 입력하면 된다.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
         <!-- 1 ~ 100까지 합을 구하기 -->
    <%

        int sum = 0;

        for(int i = 1; i <= 100; i++){
            sum += i;
        }
    %>

</body>
</html>

2. 선언부(Declaration)

<%! %> 는 변수, 메서드 등을 선언할 때 이용하는 태그이다.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>

<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>

    <!-- 선언문(선언만 가능) -->
    <%! String name = "홍길동"; %>
    <%! public int plus(int a, int b){ return a+b; } %>

</body>
</html>

3. 표현부(Expession)

<%= %>는 변수, 메서드 등의 실행에 관한 부분을 맡아 그 결과를 표현한다.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    <%
        int sum = 0;

        for(int i = 1; i <= 100; i++){
            sum += i;
        }
    %>

    <!-- 구현부 (변수 선언, 변수 및 메서드에 대한 실행 가능) -->
    <h1>1~100 까지 합 결과 : <%= sum %></h1>
</body>
</html>

4. JSP 지시어

JSP 지시문은 서블릿 클래스의 전체 구조에 영향을 준다.

해당 JSP 파일을 어떻게 처리할지 정보 등을 기술한다.

5. JSP 액션 태그

JSP 문서 내에서 간단하게 다양한 구현을 할 수 있도록 만든 태그이다.

참고자료 https://sgcomputer.tistory.com/228 https://atoz-develop.tistory.com/entry/JSP-%EA%B8%B0%EB%B3%B8-%EB%AC%B8%EB%B2%95-%EC%B4%9D-%EC%A0%95%EB%A6%AC-%ED%85%9C%ED%94%8C%EB%A6%BF-%EB%8D%B0%EC%9D%B4%ED%84%B0-JSP-%EC%A0%84%EC%9A%A9-%ED%83%9C%EA%B7%B8-%EB%82%B4%EC%9E%A5-%EA%B0%9D%EC%B2%B4 https://chlee21.tistory.com/149

디스패처 서블릿의 dispatch는 "보내다"라는 뜻이다. 디서패처 서블릿은 HTTP 프로토콜로 들어오는 모든 요청을 가장 먼저 받아 적합한 컨트롤러에 위임해주는 프론트 컨트롤러(Front Controller) 이다.

Dispatcher-Servlet의 장점

과거에 모든 서블릿을 URL 매핑을 위해 web.xml에 모두 등록해주어야 했지만, Dispatcher-Servlet은 해당 어플리케이션으로 들어오는 모든 요청을 핸들링 해주고 공통 작업을 처리 하면서 편리하게 이용할 수 있게 되었다. 즉, 컨트롤러를 구현해두기만 하면 Dispatcher-Servlet가 알아서 적합한 컨트롤러로 위임 해주는 구조가 되었다.

Dispatcher-Servlet 동작 과정

1. 클라이언트의 요청을 디스패처 서블릿이 받음
2. 요청 정보를 통해 요청을 위임할 컨트롤러를 찾음
3. 요청을 컨트롤러로 위임할 핸들러 어댑터를 찾아서 전달
4. 핸들러 어댑터가 컨트롤러로 요청을 위임
5. 비지니스 로직 처리
6. 컨트롤러가 반환값을 리턴
7. 핸들러 어댑터가 반환값을 처리
8. 서버의 응답을 클라이언트로 반환

결론

디스패처 서블릿을 통해 요청을 처리할 컨트롤러를 찾아서 위임하고, 그 결과를 받아온다.

예제

@WebServlet("/CalServlet")
public class CalServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    public CalServlet() {
        super();
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //num1, num2 값을 받아서 합을 구하기
        int num1, num2 = 0;
        String name = "";

        request.setCharacterEncoding("utf-8"); // 한글 깨짐 방지를 위한 인코딩 작업
        num1 = Integer.parseInt(request.getParameter("num1")); 
        num2 = Integer.parseInt(request.getParameter("num2"));
        name = request.getParameter("userName");

        int result = num1 + num2;

        request.setAttribute("result", result); 
        request.setAttribute("userName", name);

        RequestDispatcher re = request.getRequestDispatcher("/basic/result.jsp");
        re.forward(request, response);
    }

}

참고자료 https://mangkyu.tistory.com/18 https://riimy.tistory.com/87 https://velog.io/@seculoper235/2.-DispatcherServlet-%EC%9D%B4%EB%9E%80 https://coder-in-war.tistory.com/entry/Spring-06-Spring-MVC-Framework%EC%99%80-Dispatcher-Servlet

Servlet

1. .java 인 파일
2. 자바의 일반적인 클래스와 동일한 개념
3. 웹을 다룰 수 있도록 해주는 HttpServlet 클래스를 상속받은 클래스를 의미

JSP

1. .jsp인 파일
2. Java Server Page
3. HTML 문서 안에 자바 언어를 삽입해 사용할 수 있도록 해줌

Servlet 과 JSP는 완전 다른 개념이 아니며, Servlet을 사용해 웹을 만들 경우 화면 인터페이스 구현이 워낙 까다로운 단점을 보완하기 위해 만든 스크립트 언어가 JSP라고 볼 수 있다.

웹 어플리케이션 구조

논리적 구조 : WEB, WAS, DB 물리적 구조 : 사용자수 & 서버스펙 & 보안 & 네트워크 구조 등에 따라 맞추어짐

• 사용자가 URL(또는 IP)를 통해 Web 서버를 호출하고 요청사항을 객체(request)에 담아 전송
• WEB 서버는 요청 객체(request)를 받아서 바로 처리하거나 WAS(어플리케이션 서버)로 객체 전달
• WAS 서버는 요청에 대한 내용과 요청 객체(request)를 받아 적절히 처리(필요시 DB작업)
• WAS 서버는 처리 후 결과를 응답 객체(response)에 담아 WEB서버로 회신
• WEB 서버는 응답 객체(response)를 다시 사용자에게 회신
• 사용자의 브라우저는 WEB서버가 보내준 코드를 해석해 화면을 구성하여 출력

Servler / JSP

1. JSP -> Servlet 파일(.java) 파일로 변환
2. Servlet 파일로 직접 작성하는 것과 같은 코드로 변환
3. 변환된 서블릿 파일을 다시 컴파일해 .class 파일로 만든 뒤 실행
4. 실행 결과는 자바 언어가 모두 사라진 HTML 코드가 되 최종적으로 HTML로 변환되어 사용자에게 전달

서비스 되고 있는 사이트 중 웹 표준을 지키지 않는 사이트를 선정해 리뉴얼

선정 사이트

선정 이유

1. 가운데 정렬이 되지 않아 왼쪽으로 컨텐츠가 쏠려 있음
2. 전체적인 디자인 old
3. 모바일 화면 최적화 X
4. 웹 표준 미준수

화면 구상도

리뉴얼

느낀점

프로젝트 진행 하면서 JavaScript 활용 능력이 많이 부족 하다는 것을 느꼈다. HTML로 구조를 만들고 CSS로 보기 좋게 배치하거나 꾸미는 과정은 수월하게 진행 하였으나 JavaScript로 동적 컨텐츠 만드는데 어려움이 있었고 jQuery 활용 또한 미흡했다. 이번 프로젝트로 인해서 나의 부족한점을 명확하게 찾은 것 같아 좀 더 공부를 해야할 필요성을 느꼈다. 비록 백엔드 개발자를 지망하지만 프론트엔드 영역을 아예 모른다면 메리트가 없다 생각 한다. JavaScript 등으로 구현한 기능에 대해서 어떤 원리로 동작하는지 파악 할 줄 안다면 보다 더 경쟁력을 갖출 수 있을 것 같다는 생각이 든다.

$(function(){
    $('#letter-a a').click(function(){
        $('#dictionary').hide().load('a.html', function(){
            $(this).fadeIn();
        });

        return false;
    })
});

📃 step2 - getJSON()

$(function(){
    $('#letter-b a').click(function(){
        $.getJSON('b.json', function(data){ //callback함수의 파라미터 변수에는 서버의 결과값이 온다.
            //결과값: [{},{}] -> 배열
            $('#dictionary').empty();
            $.each(data, function(index, item){
                var html = '<div class="entry">';
                html += '<h3 class="term">' + item.term + '</h3>';
                html += '<div class="part">' + item.part + '</div>';
                html += '<div class="definition">' + item.definition + '</div>';
                html += '</div>';

                $('#dictionary').append(html);
            });
        });

        return false;
    });
});

📃 step3 - getScript()

$(function(){
    $('#letter-c a').click(function(){
        $.getScript('c.js');        
        return false;
    })
});

📃 step4 - xml => HTML 변환, .get()

$(function(){
    $('#letter-d a').click(function(){
        //xml => HTML변환
        $.get('d.xml', function(data){
            $(data).find('entry').each(function(index){
                $entry = $(this);
                var html = '<div class="entry">';
                html += '<h3 class="term">' + $entry.attr('term') + '</h3>';
                html += '<div class="part">' + $entry.attr('part') + '</div>';
                html += '<div class="definition">' + $entry.find('definition').text() + '</div>';
                html += '</div>';

                $('#dictionary').append(html);
            })
        });

        return false;
    })
});

📃 step5 - $.ajax()

$(function(){
    $('#letter-f form').submit(function(){
        $.ajax({
            url : 'server3.jsp',
            type : 'post',
            data : $(this).serialize(),
            dataType : 'text',
            success : function(data){
                $('#dictionary').text(data);
            }
        })
        return false;
    });
});

Ajax란 Asynchronous JavaScript and XML의 약자이다. Ajax는 빠르게 동작하는 동적인 웹 페이지를 만들기 위한 개발 기법 중 하나이다.

Ajax는 웹 페이지 전체를 다시 로딩하지 않고도, 웹 페이지의 일부분만을 갱신할 수 있다. 즉 Ajax를 이용하면 백그라운드 영역에서 서버와 통신하여, 그 결과를 웹 페이지의 일부분에만 표시할 수 있다.

이때 JSON, XML, HTML, 텍스트 파일 등과 같은 형태의 데이터를 주고받을 수 있다.

Ajax의 장점

Ajax를 이용하면 여러 장점이 있다.

1. 웹 페이지 전체를 다시 로딩하지 않고도, 웹 페이지의 일부분만을 갱신할 수 있다.
2. 웹 페이지가 로드된 후에 서버로 데이터 요청을 보낼 수 있다.
3. 웹 페이지가 로드된 후에 서버로 부터 데이터를 받을 수 있다.
4. 백그라운드 영역에서 서버로 데이터를 보낼 수 있다.

Ajax의 한계

Ajax를 이용하면 여러 장점을 가지지만, Ajax로도 다음과 같은 일들은 처리할 수 없다.

1. Ajax는 클라이언트가 서버에 데이터를 요청하는 클라이언트 풀링 방식을 사용해, 서버 푸시 방식의 실시간 서비스는 만들 수 없다.
2. Ajax 스크립트가 포함된 서버가 아닌 다른 서버로 Ajax 요청을 보낼 수 없다.
3. 클라이언트의 PC로 Ajax 요청을 보낼 수 없다.

Ajax의 동작 원리

Ajax에 관련된 jQuery 커맨드

load(url, parmeters, callback)

URL과 매개변수로 Ajax요청을 전송, callback 함수는 요청 완료시 호출, 응답 텍스트는 일치하는 엘리먼트의 컨턴체를 대체하고 HTML 결과값일 경우 사용에 용이하다.

url : 요청이 전송되는 서버측 URL parameters : URL에 전달하고자 하는 data callback : 응답 결과 데이터가 일치하는 엘리먼트로 로드 된 이후 호출 되는 함수

예제

$(function(){
    $('#letter-a a').click(function(){ 
        $('#dictionary').hide().load('a.html', function(){
            $(this).fadeIn();
        });

        return false;
    })
});

get(url, parameters, callback), post(url, parameters, callback)

URL을 사용하여 서버에 대한 GET,POST 요청을 전송 매개변수는 쿼리 문자열로 전달

url : 요청이 전송되는 서버측 URL parameters : URL에 덧붙이는 쿼리 문자열을 구성하기 위한 이름과 값의 쌍으로 프로퍼티를 지닌 객체 callback : 응답 결과 데이터가 일치하는 엘리먼트로 로드 된 이후 호출 되는 함수

$.getJSON(url, parameters, callback)

URL을 사용하여 서버에 대한 GET 요청을 전송 매개변수는 쿼리 문자열로 전달 응답은 JSON 문자열로 해석되며 결과는 callback함수에 전달

url : 요청이 전송되는 서버측 URL parameters : URL에 덧붙이는 쿼리 문자열을 구성하기 위한 이름과 값의 쌍으로 프로퍼티를 지닌 객체 callback : 응답 결과 데이터가 일치하는 엘리먼트로 로드 된 이후 호출 되는 함수

** 예제 **

$(function(){
    $('#letter-b a').click(function(){
        $.getJSON('b.json', function(data){ //callback함수의 파라미터 변수에는 서버의 결과값이 온다.
            //결과값: [{},{}] -> 배열
            $('#dictionary').empty();
            $.each(data, function(index, item){
                var html = '<div class="entry">';
                html += '<h3 class="term">' + item.term + '</h3>';
                html += '<div class="part">' + item.part + '</div>';
                html += '<div class="definition">' + item.definition + '</div>';
                html += '</div>';

                $('#dictionary').append(html);
            });
        });

        return false;
    });
});

$.ajax(options)

options를 통해 Ajax 요청을 전송

options : 요청에 대한 매개변수를 정의 하는 프로퍼티 객체

$.ajax({
    url : 'b.json',
    type : 'get',
    dataType : 'json',
    success : function(data){
    }

    ...
})