• 애플리케이션에서 보안 기능을 구현하는데 사용되는 프레임워크(디자인패턴 + 라이브러리)
• 필터 기반으로 동작하므로 스프링 MVC와 분리되어 동작함

2. 주요 기능

• 인증(Authentication) : 사용자의 정당성 확인(로그인)
• 인가(Authorization) : 리소스나 처리에 대할 접근 제어(권한)

3. 제공 기능

• 세션 관리
• 로그인 처리
• 암호화 처리
• 자동 로그인
• SRF(Cross-site request forgery) 토큰 처리 : 웹 사이트 취약점 공격을 막아줌 : 사용자가 자신도 모르게 공격자가 의도한 행위(수정, 삭제 등록)을 웹 사이트에 요청하게 하는 공격

4. 웹 화면 접근 정책 1) 회원 게시판(board)

• 목록(list) : 모두 접근 가능
• 등록(register) : 로그인한 회원만 접근 가능

2) 공지사항 게시판(notice)

• 목록(list) : 모두 접근 가능
• 등록(register) : 로그인한 관리자만 접근

4. 설정

1) 라이브러리 설치 https://mvnrepository.com/ 에서

Spring-security-web » 5.0.7.RELEASE - 중간 코드 복사 후 pom.xml에 붙여넣기 Spring Security Config » 5.0.7.RELEASE - 중간 코드 복사 후 pom.xml에 붙여넣기 Spring Security Core » 5.0.7.RELEASE - 중간 코드 복사 후 pom.xml에 붙여넣기 Spring Security Taglibs » 5.0.7.RELEASE - 중간 코드 복사 후 pom.xml에 붙여넣기

프로젝트 우클릭 후 Run As - 4번 클릭 - build success 나오면 성공!

pom.xml

        <!-- 스프링 시큐리티 라이브러리 의존관계 정의 시작 -->
        <!-- https://mvnrepository.com/artifact/org.springframework.security/spring-security-web -->
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-web</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.security/spring-security-config -->
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-config</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.security/spring-security-core -->
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-core</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.security/spring-security-taglibs -->
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-taglibs</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>
        <!-- 스프링 시큐리티 라이브러리 의존관계 정의 끝 -->

2) web.xml에 아래 코드 추가하기

• contextConfigLocation에 스프링 시큐리티 설정 파일을 지정
• 스프링 시큐리티는 필터 기반으로 동작하기 때문에 필터 지정

    <!-- contextConfigLocation에 스프링 시큐리티 설정 파일을 지정함 -->
    <!-- The definition of the Root Spring Container shared by all Servlets and Filters -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/spring/root-context.xml
            /WEB-INF/spring/security-context.xml
        </param-value>
    </context-param>

3) security-context.xml 생성 상단에 아래 코드 추가하기

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:security="http://www.springframework.org/schema/security"
xsi:schemaLocation="http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-5.0.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">

security-context.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:security="http://www.springframework.org/schema/security"
    xsi:schemaLocation="http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <security:http>
    <!-- 
    URI 패턴으로 접근 제한을 설정함 
    pattern : url 요청 경로
    access : 접근 제한 정책
    -->
        <security:intercept-url pattern="/board/list" access="permitAll"/> <!-- 모든 사용자에게 접근권한 허용 시(정해진 약속 access) -->
        <security:intercept-url pattern="/board/register" access="hasRole('ROLE_MEMBER')" />
        <security:intercept-url pattern="/notice/list" access="permitAll" />
        <security:intercept-url pattern="/notice/register" access="hasRole('ROLE_ADMIN')" />
        <!-- 폼 기능 인증 기능 사용.
        접근 제한에 걸리면 스프링 시큐리티가 기본적으로 제공하는 로그인 페이지로 이동함 -->
        <security:form-login/>
    </security:http>

    <security:authentication-manager>
    <!-- 
    지정된 아이디와 패스워드로 로그인이 가능하도록 설정함
    authorities : 위의 <security:intercept-url의 "hasRole('ROLE_MEMBER')"을 말한다.
    member 사용자 : /board/list, /board/register, /notice/list 가능
    admin 사용자 : /board/list, /board/register, /notice/list, /notice/register 가능

    스프링 시큐리티 5버전부터는 패스워드 암호화 처리기를 반드시 이용하도록 변경이 되었음
    암호화 처리기를 사용하지 않도록 "{noop}" 문자열을 비밀번호 앞에 사용.

     -->
        <security:authentication-provider>
            <security:user-service>
                <security:user name="member" password="{noop}1234" authorities="ROLE_MEMBER" />
                <security:user name="admin" password="{noop}abcd" authorities="ROLE_MEMBER,ROLE_ADMIN" />
            </security:user-service>
        </security:authentication-provider>
    </security:authentication-manager>    

</beans>        

Controller 응답 정리

1.void

• 호출하는 URL과 동일한 뷰 이름을 나타냄
• 요청이 /notice/list이면, 뷰는 /notice/list.jsp를 가리킴

2.string

3.자바빈즈 클래스(VO)

4.컬렉션 List

5.컬렉션 Map

6.ModelAndView

1. 스프링 폼 태그란?

• HTML 폼을 표시하기 위한 태그 라이브러리
• 스프링 폼을 사용하면 HTML 폼과 자바 객체를 쉽게 바인딩(= 서로 공유) 할 수 있음

2. 선언은?

• <%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>

3. 태그 목록은?

• form:password : 패스워드 필드
• form:form : 폼
• <form:input path="test"> 테스트 필드. id="test" name="test"
• form:textarea : 텍스트 영역
• form:checkboxes : 여러 개 체크박스
• form:checkbox : 체크박스
• form:radiobuttons : 여러 개의 라디오 버튼
• form:radiobutton : 라디오 버튼
• form:select : 셀렉트 박스
• form:hidden : 숨겨진 필드
• form:label : 라벨
• form:button : 버튼
• form:errors : 입력값 검증 오류 표시(validate)

DAO 클래스 대신 Mapper 인터페이스 활용해서 처리

Mapper 인터페이스란?

• 매핑 파일에 기재된 SQL을 호출하기 위한 인터페이스이다.
• Mybatis 3.0부터 생겼다.
• 매핑 파일에 있는 SQL을 인터페이스로 호출한다.

Mapper 사용하지 않았을 시?

• sqlSessionTemplate.selectOne("namespace.id", 파라미터); 형식이었다.
• namespace.SQL id로 지정해야 한다.
• 문자열로 작성하기 때문에 버그가 생길 수 있다.
• IDE에서 제공하는 code assist를 사용할 수 없다.

Mapper 사용했을 때

• Mapper 인터페이스를 개발자가 직접 작성한다.
• 패키지 이름+"."+인터페이스 이름+"."+메서드 이름이 namespace.SQL의 id를 설정해야 한다.
• namespace 속성에는 패키지를 포함한 Mapper 인터페이스 이름 형식이다.
• SQL id에는 매핑하는 메서드 이름을 지정한다.

Mapper 인터페이스 작성

• 반드시 인터페이스로 선언해주어야 한다.
• namespace명은 패키지 포함 인터페이스 이름으로 작성한다.
• ex)<mapper namespace="myspring.user.dao.UserMapper">
• 메서드명은 SQL id와 동일하게 작성한다.

설정

1. pom.xml에 mybatis, springframework, ojdbc6 등 라이브러리가 있는지 확인
2. root-context.xml 추가

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="kr.or.ddit.*.mapper" />
    </bean>
   </beans>

• 개발자가 직접 DAO를 설정하지 않아도 자동으로 Mapper 인터페이스를 활용하는 객체를 생성함
• 소스마다 설정하지 않고 자동으로 경로를 설정해서 인식시킬 수 있음
• MapperScannerConfigurer : "kr.or.ddit.*.mapper"에 있는 매퍼클래스를 스캐닝할거다!

3. Mapper가 될 Interface 만들기
4. SQL.xml의 namespace 바꾸기
5. ServiceImpl에서 dao 걷어내고 Mapper로 연결
6. mybatisAlias.xml 수정

예시

Lprod 시리즈 정리하기

1. kr.or.ddit 폴더에 lprod 폴더 만들기
2. controller, dao, mapper, service, vo 폴더 각각 만들고, Mapper interface 만들어서 추가

   LprodMapper.java

   package kr.or.ddit.lprod.mapper;
   

import java.util.List; import java.util.Map;

import kr.or.ddit.BuyerVO; import kr.or.ddit.lprod.vo.LprodVO; import kr.or.ddit.member.vo.MemberVO;

public interface LprodMapper { //상품분류 별 거래처 목록 public List list(Map<String, Object> map);

//상품분류 별 거래처 목록 행의 수
public int listCount(Map<String, Object> map);

//거래처 상세 정보
public BuyerVO detail(String buyerId);

//거래처 수정
public int modify(BuyerVO buyerVO);

//로그인
public MemberVO login(MemberVO memberVO);

}

3. SQL.xml의 namespace 바꾸기
namespace="매퍼 클래스가 있는 패키지명.매퍼클래스명"

@Override
public List<LprodVO> list(Map<String, Object> map){
    return this.lprodMapper.list(map);
}

//상품분류 별 거래처 목록 행의 수
@Override
public int listCount(Map<String, Object> map) {
    return this.lprodMapper.listCount(map);
}

//거래처 상세 정보
@Override
public BuyerVO detail(String buyerId) {
    return this.lprodMapper.detail(buyerId);
}

//거래처 수정
@Override
public int modify(BuyerVO buyerVO) {
    return this.lprodMapper.modify(buyerVO);
}

//로그인
//메소드 재정의
@Override
public MemberVO login(MemberVO memberVO) {
    //this 생략 가능
    return lprodMapper.login(memberVO);
}

5. mybatisAlias.xml 수정

• 프로그램을 처리되는 동안 문제가 발생 시 처리를 중단하고 다른 처리를 하는 것
• 웹 컨테이너(tomcat)는 기본 오류 페이지를 표시해줌
• 화면에 서버의 내부 정보가 일반인에게 노출되어 보안이 취약해지고 공격을 받을 수 있으므로, 최대한 개발자가 직접 예외를 처리하여 정의한 오류 페이지를 표시하게 해줘야 한다.

2. 예외 종류?

• 시스템 예외
• 의존 라이브러리에서 발생한 예외
• 사용자 정의 예외
• 스프링 프레임워크 예외

3. 예외 발생 예시?

• 등록 시 필수여야 하는데 빈 값을 입력하는 유효값 검증 예외
• 수정화면 생성 시 뷰 파일에서의 예외
• 삭제 시 매핑 파일에서의 예외
• 없는 글에 접근 시 예외
• 없는 URL 요청 시 예외

예시

1. 예외처리 Handler Controller

CommonExceptionHandler.java

package kr.or.ddit;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

//스프링 컨트롤러에서 발생된 예외를 처리하는 핸들러 클래스 임을 명시함
@ControllerAdvice
public class CommonExceptionHandler {
    private static final Logger logger = LoggerFactory.getLogger(CommonExceptionHandler.class);

    //괄호 안에 설정한 예외타입을 해당 메서드가 처리한다는 것을 의미함
    // <exception-type>java.lang.Exception</exception-type>
    //없는 URL 요청 예외(X)
    //수정화면 생성 시 뷰 파일(jsp)에서 예외(X)
    @ExceptionHandler(Exception.class)
    public String handle(Exception e, Model model) {
        logger.info(e.toString());

        model.addAttribute("exception", e);

        //forwarding
        return "error/Exception";

    }

}

2. 에러페이지로 보내주는 Controller

ErrorController.java

package kr.or.ddit;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class ErrorController {
    @RequestMapping(value = "/error/400")
    public String error400() {
        return "error/400";
    }
    @RequestMapping(value = "/error/404")
    public String error404() {
        return "error/404";
    }
    @RequestMapping(value = "/error/500")
    public String error500() {
        return "error/500";
    }
}

3. JSP

Exception.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>    

<!-- 404 Error Text -->
<div class="text-center">
    <div class="error mx-auto" data-text="Exception">Exception</div>
    <p class="lead text-gray-800 mb-5">
    ${exception.getMessage()}
    </p>
    <ul>
        <c:forEach var="stack" items="${exception.getStackTrace()}">
            <li>${stack.toString()}</li>
        </c:forEach>
    </ul>
    <a href="/lprod/list">&larr;처음으로 이동</a>
</div>

400.jsp

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

<!-- 404 Error Text -->
<div class="text-center">
    <div class="error mx-auto" data-text="400">400</div>
    <p class="lead text-gray-800 mb-5">Bad Request</p>
    <a href="/lprod/list">&larr;처음으로 이동</a>
</div>

404.jsp

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

<!-- 404 Error Text -->
<div class="text-center">
    <div class="error mx-auto" data-text="404">404</div>
    <p class="lead text-gray-800 mb-5">Page Not Found</p>
    <a href="/lprod/list">&larr;처음으로 이동</a>
</div>

500.jsp

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

<!-- 404 Error Text -->
<div class="text-center">
    <div class="error mx-auto" data-text="500">500</div>
    <p class="lead text-gray-800 mb-5">Internal Server Error</p>
    <a href="/lprod/list">&larr;처음으로 이동</a>
</div>

Tiles 설정 방법

1. 라이브러리 다운로드 https://mvnrepository.com/ 에서 1) *tiles-extras *검색 - 3.0.8 클릭 - 중간 코드 복사 - pom.xml에 추가 2) *tiles-servlet *검색 - 3.0.8 클릭 - 중간 코드 복사 - pom.xml에 추가 3) *tiles-jsp *검색 - 3.0.8 클릭 - 중간 코드 복사 - pom.xml에 추가

pom.xml

        <!-- Tiles -->
        <!-- https://mvnrepository.com/artifact/org.apache.tiles/tiles-extras -->
        <dependency>
            <groupId>org.apache.tiles</groupId>
            <artifactId>tiles-extras</artifactId>
            <version>3.0.8</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.tiles/tiles-servlet -->
        <dependency>
            <groupId>org.apache.tiles</groupId>
            <artifactId>tiles-servlet</artifactId>
            <version>3.0.8</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.tiles/tiles-jsp -->
        <dependency>
            <groupId>org.apache.tiles</groupId>
            <artifactId>tiles-jsp</artifactId>
            <version>3.0.8</version>
        </dependency>

2. servlet-context 설정 tiles의 순서를 1로 설정한다.

-> <beans:property name="order" value="1" />

    <!-- Tiles -->
    <beans:bean id="tilesConfigurer" 
    class="org.springframework.web.servlet.view.tiles3.TilesConfigurer">
        <beans:property name="definitions">
            <beans:list>
                <beans:value>/WEB-INF/spring/tiles-config.xml</beans:value>
            </beans:list>
        </beans:property>
    </beans:bean>
    <beans:bean id="tilesViewResolver" 
        class="org.springframework.web.servlet.view.UrlBasedViewResolver">
        <beans:property name="viewClass"
            value="org.springframework.web.servlet.view.tiles3.TilesView" />
        <beans:property name="order" value="1" />
    </beans:bean>

    <context:component-scan base-package="kr.or.ddit" />

3.tiles_config.xml 파일 생성 및 내용 추가

tiles_confilg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE tiles-definitions PUBLIC  
"-//Apache Software Foundation//DTD Tiles Configuration 3.0//EN"  
"http://tiles.apache.org/dtds/tiles-config_3_0.dtd">

<!-- tiles 설정 -->
<tiles-definitions>
    <!-- main layout 설정 -->
    <definition name="tiles-layout" template="/WEB-INF/views/tiles/index.jsp">
        <put-attribute name="header" value="/WEB-INF/views/tiles/header.jsp" />
        <put-attribute name="aside" value="/WEB-INF/views/tiles/aside.jsp" />
        <put-attribute name="body" value="" />
        <put-attribute name="footer" value="/WEB-INF/views/tiles/footer.jsp" />
    </definition>

    <definition name="*/*" extends="tiles-layout">
        <put-attribute name="body" value="/WEB-INF/views/{1}/{2}.jsp" />
    </definition>
</tiles-definitions>

4. views 폴더에 tiles 폴더를 만들고 aside.jsp, footer.jsp, header.jsp, index.jsp를 추가한다.

https://mvnrepository.com/ 에서

1) commons-fileupload 검색 - 1.4 클릭 - 중간 코드 복사 - pom.xml에 붙여넣기 2) imgscalr-lib 검색 - Imgscalr A Java Image Scaling Library » 4.2 클릭 - 중간 코드 복사 - pom.xml에 붙여넣기 3) jackson-databind 검색 - 2.13.1 클릭 - 중간코드 복사 - pom.xml에 붙여넣기 4) thumbnailator 검색 0.4.16 -> 중간코드 복사 -> pom.xml에 붙여넣기

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>kr.or</groupId>
    <artifactId>ddit</artifactId>
    <name>springProj</name>
    <packaging>war</packaging>
    <version>1.0.0-BUILD-SNAPSHOT</version>
    <properties>
        <java-version>1.8</java-version>
        <org.springframework-version>5.2.5.RELEASE</org.springframework-version>
        <org.aspectj-version>1.6.10</org.aspectj-version>
        <org.slf4j-version>1.6.6</org.slf4j-version>
    </properties>
    <dependencies>
        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${org.springframework-version}</version>
            <exclusions>
                <!-- Exclude Commons Logging in favor of SLF4j -->
                <exclusion>
                    <groupId>commons-logging</groupId>
                    <artifactId>commons-logging</artifactId>
                 </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${org.springframework-version}</version>
        </dependency>

        <!-- AspectJ -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>${org.aspectj-version}</version>
        </dependency>    

        <!-- Logging -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${org.slf4j-version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>${org.slf4j-version}</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${org.slf4j-version}</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.15</version>
            <exclusions>
                <exclusion>
                    <groupId>javax.mail</groupId>
                    <artifactId>mail</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>javax.jms</groupId>
                    <artifactId>jms</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>com.sun.jdmk</groupId>
                    <artifactId>jmxtools</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>com.sun.jmx</groupId>
                    <artifactId>jmxri</artifactId>
                </exclusion>
            </exclusions>
            <scope>runtime</scope>
        </dependency>

        <!-- @Inject -->
        <dependency>
            <groupId>javax.inject</groupId>
            <artifactId>javax.inject</artifactId>
            <version>1</version>
        </dependency>

        <!-- Servlet -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <!-- Test -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.7</version>
            <scope>test</scope>
        </dependency>

        <!-- Database 라이브러리 시작 -->
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <!-- XML로 쿼리를 작성하게 해주는 라이브러리 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.9</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
        <!-- 스프링과 mybatis를 연동하게 해주는 라이브러리 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <!-- 스프링에서 JDBC 드라이버를 통해 DB 연결 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${org.springframework-version}</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-dbcp2 -->
        <!-- 
            데이터베이스 커넥션 풀. 커넥션을 미리 여려개 만들어 놓고, 빌려썼다가 사용이 끝나면 반납.
            최근에 hikaricp를 사용하는 경우도 있음
        -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
            <version>2.9.0</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.bgee.log4jdbc-log4j2/log4jdbc-log4j2-jdbc4 -->
        <!-- Logging을 위한 라이브러리. Query를 Console이나 파일 로그로 볼 수 있음 -->
        <dependency>
            <groupId>org.bgee.log4jdbc-log4j2</groupId>
            <artifactId>log4jdbc-log4j2-jdbc4</artifactId>
            <version>1.16</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.oracle.database.jdbc/ojdbc6 -->
        <!-- 오라클과 자바를 연결해주는 라이브러리 -->
        <dependency>
            <groupId>com.oracle.database.jdbc</groupId>
            <artifactId>ojdbc6</artifactId>
            <version>11.2.0.4</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <!-- 
            * 자바빈 클래스인 VO에서 Getter/Setter메서드, toString()메서드를 자동 생성
         -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
            <scope>provided</scope>
        </dependency>

        <!-- Database 라이브러리 끝 -->

        <!-- 입력값을 검증하기 위한 라이브러리 의존 관계 정의 -->
        <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-validator -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.4.2.Final</version>
        </dependency>

        <!-- 파일 업로드 라이브러리 시작 -->
        <!-- https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload -->
        <!-- 파일 업로드/다운로드 -->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.4</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.imgscalr/imgscalr-lib -->
        <!-- 썸네일 -->
        <dependency>
            <groupId>org.imgscalr</groupId>
            <artifactId>imgscalr-lib</artifactId>
            <version>4.2</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/net.coobird/thumbnailator -->
        <dependency>
            <groupId>net.coobird</groupId>
            <artifactId>thumbnailator</artifactId>
            <version>0.4.16</version>
        </dependency>
        <!-- 파일 업로드 라이브러리 끝 -->

        <!-- json 데이터 바인딩을 위한 의존 라이브러리 -->
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.13.1</version>
        </dependency>

    </dependencies>
    <build>
        <plugins>
            <plugin>
                <artifactId>maven-eclipse-plugin</artifactId>
                <version>2.9</version>
                <configuration>
                    <additionalProjectnatures>
                        <projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>
                    </additionalProjectnatures>
                    <additionalBuildcommands>
                        <buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>
                    </additionalBuildcommands>
                    <downloadSources>true</downloadSources>
                    <downloadJavadocs>true</downloadJavadocs>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.5.1</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                    <compilerArgument>-Xlint:all</compilerArgument>
                    <showWarnings>true</showWarnings>
                    <showDeprecation>true</showDeprecation>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>1.2.1</version>
                <configuration>
                    <mainClass>org.test.int1.Main</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2. web.xml에 servlet 버전 업그레이드

1) 구글에서 web.xml web-app 3.1검색 https://antop.tistory.com/entry/webxml-%EC%84%9C%EB%B8%94%EB%A6%BF-%EB%B2%84%EC%A0%84%EB%B3%84-DTD 에서 servlet 3.1 코드 복사

(1)web.xml에서 아래와 같이 바꾸기

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
    version="3.1">

2)<servlet> 안에 아래 코드 추가

        <!-- 파일업로드 설정 시작 -->
        <multipart-config>
            <location>C:\\upload</location> <!-- 업로드 되는 파일을 저장할 공간 -->
            <max-file-size>20971520</max-file-size><!-- 업로드 최대크기 1MB * 20 (= 20MB)으로 지정 -->
            <max-request-size>41943040</max-request-size><!-- 한번에 올릴 수 있는 최대 크기 1MB * 40 (= 40MB)으로 지정-->
            <file-size-threshold>20971520</file-size-threshold><!-- 메모리 사용 1MB * 20 (= 20MB)으로 지정  -->
        </multipart-config>
        <!-- 파일업로드 설정 끝 -->

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
    version="3.1">

    <!-- The definition of the Root Spring Container shared by all Servlets and Filters -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/spring/root-context.xml</param-value>
    </context-param>

    <!-- Creates the Spring Container shared by all Servlets and Filters -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- Processes application requests -->
    <servlet>
        <servlet-name>appServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
        <!-- web.xml 설정 : Tomcat 자체 설정 -->
        <!-- 파일업로드 설정 시작 -->
        <multipart-config>
            <location>C:\\upload</location> <!-- 업로드 되는 파일을 저장할 공간 -->
            <max-file-size>20971520</max-file-size><!-- 업로드 최대크기 1MB * 20 (= 20MB)으로 지정 -->
            <max-request-size>41943040</max-request-size><!-- 한번에 올릴 수 있는 최대 크기 1MB * 40 (= 40MB)으로 지정-->
            <file-size-threshold>20971520</file-size-threshold><!-- 메모리 사용 1MB * 20 (= 20MB)으로 지정  -->
        </multipart-config>
        <!-- 파일업로드 설정 끝 -->

    </servlet>

    <servlet-mapping>
        <servlet-name>appServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!-- 한글설정 -->
    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>
            org.springframework.web.filter.CharacterEncodingFilter
        </filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!-- 한글설정 END -->

</web-app>

3. sevlet-context.xml 수정

1) 아래 코드 추가하기

view단에서 multipart/form-data 방식으로 서버에 전송되는 데이터를 스프링 MVC의 multipartResolver로 처리할 수 있다.

    <!-- 첨부파일을 처리하는 빈 설정 -->
    <beans:bean id="multipartResolver" class="org.springframework.web.multipart.support.StandardServletMultipartResolver">

    </beans:bean>

servlet-context.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/mvc"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:beans="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- DispatcherServlet Context: defines this servlet's request-processing infrastructure -->

    <!-- Enables the Spring MVC @Controller programming model -->
    <annotation-driven />

    <!-- Handles HTTP GET requests for /resources/** by efficiently serving up static resources in the ${webappRoot}/resources directory -->
    <!-- 정적 폴더  -> images, js, css와 같은 폴더들이 resources 밑에 들어감-->
    <resources mapping="/resources/**" location="/resources/" />
    <!-- 컨트롤러에서 return되는 string값(파일명) 앞 뒤로 조립되는 값 -->
    <!-- Resolves views selected for rendering by @Controllers to .jsp resources in the /WEB-INF/views directory -->
    <!--  prefix는 앞, suffix는 뒤에 붙는다 (ViewResolver가 조립해준다)-->
    <beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <beans:property name="prefix" value="/WEB-INF/views/" />
        <beans:property name="suffix" value=".jsp" />
    </beans:bean>

    <context:component-scan base-package="kr.or.ddit" />

    <!-- 첨부파일을 처리하는 빈 설정 -->
    <beans:bean id="multipartResolver" class="org.springframework.web.multipart.support.StandardServletMultipartResolver">

    </beans:bean>

</beans:beans>

4. context.xml 수정

1) 아래 코드 추가하기

<Context allowCasualMultipartParsing="true" path="/">
    <Resources cashingAllowed="true" cacheMaxSize="100000" />

context.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--
  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements.  See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.
  The ASF licenses this file to You under the Apache License, Version 2.0
  (the "License"); you may not use this file except in compliance with
  the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
--><!-- The contents of this file will be loaded for each web application -->
<Context allowCasualMultipartParsing="true" path="/">
    <Resources cashingAllowed="true" cacheMaxSize="100000" />

    <!-- Default set of monitored resources. If one of these changes, the    -->
    <!-- web application will be reloaded.                                   -->
    <WatchedResource>WEB-INF/web.xml</WatchedResource>
    <WatchedResource>${catalina.base}/conf/web.xml</WatchedResource>

    <!-- Uncomment this to disable session persistence across Tomcat restarts -->
    <!--
    <Manager pathname="" />
    -->
</Context>

서버에 파일 저장 시 고려할 사항

1. 파일 업로드 방식 (Post? Ajax?)
2. 파일 이름 중복으로 인한 덮어쓰기 문제 -> UUID로 해결
3. 파일 저장 경로

-> 폴더 내 파일 개수가 너무 많아지면 속도가 저하되므로, 업로드 되는 시점별로 폴더를 생성하여 파일을 관리한다. 4. 이미지 파일인 경우 썸네일 생성하기 -> 이미지 파일은 저장된 파일을 다시 화면에 보여줄 때, 썸네일 파일을 보여주게 된다. 따라서 이미지 파일을 서버에 저장 시 추가적으로 그 이미지 파일의 썸네일 파일을 생성해주어야 한다. -> 처음에 추가했던 imgsclar-lib 라이브러리가 이미지 썸네일 생성을 해준다.

예제

1. Post 방식

1) uploadForm.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<title>파일 업로드 테스트</title>
</head>
<body>

<!-- 여러 파일 업로드 시 enctype="multipart-form-data" 필수! -->
<form action="/uploadTest/uploadFormAction" method="post" enctype="multipart/form-data">
    <input type="file" name="uploadFile" multiple />
    <button>Submit</button>
</form>

</body>
<html>

2) UploadController.java

package kr.or.ddit;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

import net.coobird.thumbnailator.Thumbnailator;

@RequestMapping("/uploadTest")
@Controller
public class UploadController {
    private static final Logger logger = LoggerFactory.getLogger(UploadController.class);

    //jsp의 <input name="uploadFile"과 MultipartFile[]의 uploadFile 이름이 같아야 함
    //MultipartFile[] --> 여러개의 파일을 올리기 위한 배열, jsp에 enctype="multipart/form-data" 필수
    @PostMapping("/uploadFormAction")
    public String uploadFormPost(MultipartFile[] uploadFile, Model model) {

        //파일 저장경로 설정
        String uploadFolder = "D:\\A_TeachingMaterial\\6.JspSpring\\workspace\\springProj\\src\\main\\webapp\\resources\\upload";

        //아직 db연동 안해서 list로 한다
        List<String> list = new ArrayList<String>();

        for(MultipartFile multipartFile : uploadFile) {
            logger.info("---------------");
            logger.info("파일명 : " + multipartFile.getOriginalFilename());
            logger.info("파일 크기 : " + multipartFile.getSize());

            //"c:\\upload\\비숑.jpg" 으로 조립
            //이렇게 업로드 하겠다 라고 설계
            File saveFile = new File(uploardFolder, multipartFile.getOriginalFilename());

            try{
                //transfer하기 전에 파일 실제 명을 list에 담음
                list.add(multipartFile.getOriginalFilename());
                //transferTo() : 물리적으로 파일 업로드가 되는 시점이 여기!
                multipartFile.transferTo(saveFile);
            }catch(Exception e){
                logger.info(e.getMessage());
            }//end catch
        }//end for

        //forwarding 하기 전 model에 list를 담는다.
        // 이 list에는 파일명들이 들어 있다.

        //forward
        return "uploadTest/uploadSuccess";
    }
}

3) uploadSuccess.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<title>업로드 성공</title>
</head>
<body>
업로드 성공! <br>
<c:forEach var="img" items="${list}">
    <img src="/resources/upload/${img}" />
</c:forEach>
</body>
</html>

2. Ajax 방식

1)uploadAjax.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<script type="text/javascript" src="/resources/js/jquery-3.6.0.js"></script>
<title>Upload with Ajax</title>
<script type="text/javascript">
//파일을 담아두는 변수
var sel_file = [];

$(function(){
    //------------ 이미지 미리보기 시작 ---------------
    $("input_img").on("change", handleImgFileSelect);

    function handleImgFileSelect(e){
        //e.target : 파일 객체
        //e.target.files : 파일 객체 안의 파일들
        var files = e.target.files;
        //파일을 잘라서 array로 만든다!
        var filesArr = Array.prototypes.slice.call(files);

        //f: 파일 객체
        filesArr.forEach(function(f){
            //미리보기는 이미지만 가능
            if(!f.type.match("image.*")){
                alert("이미지만 가능합니다.");
                return;
            }

            //파일 객체 복사
            sel_file.push(f);

            //파일을 읽어주는 객체를 생성한다.
            var reader = new FileReader();
            reader.onload = function(e) {
                //하나라면
                //$("#img").attr("src", e.target.result);

                //복수라면
                //forEach 반복하면서 img 객체 생성하기
                var img_html = "<img src=\"" + e.target.result + "\" />";
                $(".img_wrap").append(img_html);

            }
            //reader객체에 파일URL읽어서 넣는다. -> 읽어와지면 onload 실행
            reader.readAsDataURL(f);

        });
        //------------ 이미지 미리보기 끝 ---------------

        //모든 파일명.확장자(exe|sh|zip|alz)는 업로드를 못하도록 막는다.
        //첨부파일의 확장자가 exe, sh, zip, alz인 경우 업로드를 제한
        var regex = new RegExp("(.*?)\.(exe|sh|zip|alz)");

        //최대 5MB까지만 업로드 가능
        var maxSize = 5242880; //5MB
        //확장자, 크기 체크
        function checkExtension(fileName, fileSize){
            if(fileSize >= maxSize){
                alert("파일 사이즈 초과");
                return false;
            }

            if(regex.test(fileName)){
                alert("해당 종류의 파일은 업로드할 수 없습니다.");
                return false;
            }
            //체크 통과
            return true;
        }

        //Upload 클릭시 이벤트 발생시키기!
        $("upload").on("click", function(e){
            //잘 넘어오는지 확인
            //alert("왔네!");

            //FormData : 가상의 <form>태그
            //Ajax를 이용하는 파일 업로드는 FormData를 이용해서
            var formData = new FormData();

            //<input type="file" name="uploadFile" multiple /> 찾아가기
            var inputFile = $("input[name='uploadFile']");
            //<input type="file" 요소 내의 이미지들
            var files = inputFile[0].files;

            //console에 files안의 파일 이름 찍어보기
            for(var i=0; i<files.length; i++){
                console.log(files[i]);
                //확장자, 크기 체크
                //function checkExtension(fileName, fileSize){
                if(!checkExtension(files[i].name, files[i].size) {
                    return false; //!true -> 실패
                }
                formData.append("uploadFile", files[i]);
            }
            //없어? 카드가 또?
            //processData, contentType은 반드시 false여야 전송됨
            $.ajax({
                url : 'uploadTest/uploadAjaxAction',
                processData : false,
                contentType : false,
                data : formData,
                type : 'POST',
                success : function(result){
                    //JSON을 string으로 변환해서 console에 찍어본다
                    console.log("result : " + JSON.stringlyfy(result));
                }
            });
        });
});

</script>
</head>
<body>
<h1>Upload with Ajax</h1>

<div class="uploadDiv">
    <input type="file" id="input_img" name="uploadFile" multiple />
</div>

<button id="uploadBtn">Upload</button>
<div class="img_wrap">

</div>
</body>
</html>

2) UploadController.java

@ResponseBody : JSON 객체 타입의 데이터를 만들어서 반환하는 용도로 사용됨 : JSON? {"id":"a001", "name":"개똥이"}

//<form>태그를 이용하던 방식과 동일한 방식으로 처리됨
//Ajax 방식으로 결과 데이터를 전달하므로 Model을 사용하지 않는다.

@ResponseBody
@PostMapping("uploadAjaxAction")
public List<AttachFileVO> uploadAjaxAction(MultipartFile[] uploadFile) {

    String uploadFolder = "D:\\A_TeachingMaterial\\6.JspSpring\\workspace\\springProj\\src\\main\\webapp\\resources\\upload";

    //연/월/일 폴더 생성 시작 ---------
    File uploadPath = new File(uploadFolder, getFolder());
    logger.info("uploadPath : " + uploadPath);

    if(uploadPath.exists()==false) { //해당 경로가 없으면 생성해줘야 함
        uploadPath.mkdirs();
    }
    //연/월/일 폴더 생성 끝 ---------   

    //첨부된 파일의 이름을 담을 List
    List<AttachFileVO> list = new ArrayList<AttachFileVO>();

        for(MultipartFile multipartFile : uploadFile) {
            logger.info("-----------");
            logger.info("파일명 : " + multipartFile.getOriginalFilename());
            logger.info("파일크기 : " + multipartFile.getSize());

            AttachFileVO attachFileVO = new AttachFileVO();
            //1) fileName 세팅
            attachFileVO.setFileName(multipartFile.getOriginalFilename());

            //-------------------UUID 파일명 처리 시작 -----------------
            //UUID : 동일한 이름으로 업로드되면 기존 파일을 지우게 되므로 이를 방지하기 위함
            UUID uuid = UUID.randomUUID();

            String uploadFileName = uuid.toString() + "-" + multipartFile.getOriginalFilename();
            // c:\\upload\\gongu03.jpg으로 조립
            // 이렇게 업로드 하겠다라고 설계 uploadFolder -> uploadPath
            File saveFile = new File(uploadPath,uploadFileName);
            //-------------------UUID 파일명 처리 끝 -----------------
             try {
                //transferTo() : 물리적으로 파일 업로드가 됨
                multipartFile.transferTo(savaFile);

                //2) uploadPath
                attachFileVO.setUploadPath(uploadPath.getPath());
                //3) UUID
                attachFileVO.setUuid(uuid.toString());
                //--------------------썸네일 처리 시작 -------------------
                //이미지 파일인지 체킹
                if(checkImageType(saveFile)) {
                    logger.info("이미지 파일? true");
                //4) image여부
                attachFileVO.setImage(true);
                //uploadPath : 연/월/일이 포함된 경로
                //uploadFileName : UUID가 포함된 파일명
                FileOutPutStream thumbnail = new FileOutputStream(new File(uploadPath, "s_"+uploadFileName));
                Thumbnailator.createThumbnail(multipartFile.getInputStream(), thumbnail, 100, 100); //사이즈
                thumbnail.close();
                }else {
                    logger.info("이미지 파일? false");
                }
            //--------------------썸네일 처리 끝 -------------------

            //파일의 실제 명을 list에 담는다.
            list.add(attachFileVO);
             }catch(Exception e) {
                logger.info(e.getMessage());
            }//end catch
        }//end for

        return list;
}//end uploadAjaxAction

//첨부파일을 보관하는 폴더를 연/월/일 계층 형태로 생성
private String getFolder() {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    Date date = new Date();
    String str = sdf.format(date);
    return str.replace("-", File.separator);
}

//특정한 파일이 이미지 타입지 검사해주는 메소드
private boolean checkImageType(File file) {
    try {
         //file.toPath() : 파일의 전체 경로
        logger.info("file.toPath() : " + file.toPath());
        String contentType = Files.probeContentType(file.toPath());
        logger.info("contentType : " + contentType);
        //contentType이 image로 시작하면 이미지 타입이므로 true를 리턴함
        return contentType.startsWith("image");
    }catch(IOException e) {
        e.printStackTrace();
    }
    return false;

    }
}

• VO -> JSON {id":"a001", "name":"개똥이"}
• List<VO> -> JSON [{id":"a001", "name":"개똥이"}, {id":"b001", "name":"뿡뿡이"}]
• Map<String, Object> -> JSON {"key1":{id":"a001", "name":"개똥이"}, "key2":{id":"b001", "name":"뿡뿡이"}}
• String -> JSON a001, b001

• 서브쿼리 구분 : 위치에 따라 1) select : scalar 서브쿼리 2) where : nested(중첩된) 서브쿼리 3) from : inline 서브쿼리

MyBatis 동적 SQL 정리 MyBatis는 동적 SQL을 조립하는 구조를 지원해줌 SQL 조립 규칙을 매퍼 XML 파일에 정의할 수 있음

-<where> : where절 앞뒤에 내용을 더 추가하거나 삭제할 때 사용 -<if> : 조건 만족 시 SQL을 조립 -<choose> : 여러 선택 항목에서 조건 만족 시 SQL을 조립 -<foreach> : 컬렉션이나 배열에 대해 반복 처리 -<set> : UPDATE절의 SET절 앞 뒤에 내용을 더 추가하거나 삭제 시 사용

Hibernate-validator 설치

입력값 검증을 위한 라이브러리

1) https://mvnrepository.com/ 에서 hibernate-validator 검색 -> Home » org.hibernate » hibernate-validator 클릭

2) 5.4.2.Final 버전 클릭 -> 중간 코드 복사 -> pom.xml에 붙여넣기

3) 프로젝트 우클릭 - Run As - 4번 클릭 -> build Success 나오면 설치 성공

입력값 검증(validate)

스프링 MVC 프레임워크에서 Bean(자바빈 클래스, VO) 기능을 이용하여 요청 파라미터 값이 바인딩(=메모리에 올라감) 된 도메인 클래스(=메모리에 올라간 VO객체)의 입력값 검증을 함

입력값 검증 절차

• 메서드 매개변수에 도메인 클래스를 정의하고 @Validated를 지정함
• 입력값 검증 대상의 도메인 클래스 직후에 BindingResult를 정의
• BindingResult에는 요청 데이터의 바인딩 오류와 입력값 검증 오류 정보가 저장됨
• forwarding을 통해 뷰(jsp)와 오류 데이터를 공유 -> redirect 방식으로는 jsp에 오류정보를 보낼 수 없다!

입력값 검증 결과(BindingResult)

• hasErrors() : 오류가 발생한 경우 true를 반환
• getGlobalErrors() : 객체 레벨의 오류
• getFieldErrors() : 필드(멤버변수) 레벨의 오류

입력값 검증 규칙

• @NotBlank : 문자열이 null이 아니고 trim한 길이가 0보다 크다는 것을 검사
• @NotNull : 빈 값이 아닌지 검사
• @Email : 이메일 주소 형식인지 검사
• @Size : 글자수 검사
• @Past : 과거 날짜인지 검사(오늘 기준으로 과거 날짜만 가능)
• @Future : 미래 날짜인지 검사(오늘 기준으로 미래 날짜만 가능)

예시) detail.jsp에서 수정 시 입력값 검증하기

1.VO

buyerVO.java

package kr.or.ddit;

import java.util.List;
import org.hibernate.validator.constraints.Email;
import org.hibernate.validator.constraints.NotEmpty;

//자바빈 클래스
public class BuyerVO {
    //멤버변수
    private String buyerId;
    private String buyerName;
    private String buyerLgu;
    private String buyerBank;
    private String buyerBankno;
    private String buyerBankname;
    private String buyerZip;
    private String buyerAdd1;
    private String buyerAdd2;
    @NotEmpty
    private String buyerComtel;
    private String buyerFax;
    @NotEmpty
    @Email
    private String buyerMail;
    @NotEmpty
    private String buyerCharger;
    private String buyerTelext;
    //상품분류명
    private String lprodNm;


    //Buyer : ProdVO = 1: N 관계
    private List<ProdVO> ProdVO;

    //getter/setter 메소드
    public String getBuyerId() {
        return buyerId;
    }
    public void setBuyerId(String buyerId) {
        this.buyerId = buyerId;
    }
    public String getBuyerName() {
        return buyerName;
    }
    public void setBuyerName(String buyerName) {
        this.buyerName = buyerName;
    }
    public String getBuyerLgu() {
        return buyerLgu;
    }
    public void setBuyerLgu(String buyerLgu) {
        this.buyerLgu = buyerLgu;
    }
    public String getBuyerBank() {
        return buyerBank;
    }
    public void setBuyerBank(String buyerBank) {
        this.buyerBank = buyerBank;
    }
    public String getBuyerBankno() {
        return buyerBankno;
    }
    public void setBuyerBankno(String buyerBankno) {
        this.buyerBankno = buyerBankno;
    }
    public String getBuyerBankname() {
        return buyerBankname;
    }
    public void setBuyerBankname(String buyerBankname) {
        this.buyerBankname = buyerBankname;
    }
    public String getBuyerZip() {
        return buyerZip;
    }
    public void setBuyerZip(String buyerZip) {
        this.buyerZip = buyerZip;
    }
    public String getBuyerAdd1() {
        return buyerAdd1;
    }
    public void setBuyerAdd1(String buyerAdd1) {
        this.buyerAdd1 = buyerAdd1;
    }
    public String getBuyerAdd2() {
        return buyerAdd2;
    }
    public void setBuyerAdd2(String buyerAdd2) {
        this.buyerAdd2 = buyerAdd2;
    }
    public String getBuyerComtel() {
        return buyerComtel;
    }
    public void setBuyerComtel(String buyerComtel) {
        this.buyerComtel = buyerComtel;
    }
    public String getBuyerFax() {
        return buyerFax;
    }
    public void setBuyerFax(String buyerFax) {
        this.buyerFax = buyerFax;
    }
    public String getBuyerMail() {
        return buyerMail;
    }
    public void setBuyerMail(String buyerMail) {
        this.buyerMail = buyerMail;
    }
    public String getBuyerCharger() {
        return buyerCharger;
    }
    public void setBuyerCharger(String buyerCharger) {
        this.buyerCharger = buyerCharger;
    }
    public String getBuyerTelext() {
        return buyerTelext;
    }
    public void setBuyerTelext(String buyerTelext) {
        this.buyerTelext = buyerTelext;
    }

    public List<ProdVO> getProdVO() {
        return ProdVO;
    }
    public void setProdVO(List<ProdVO> prodVO) {
        ProdVO = prodVO;
    }
    public String getLprodNm() {
        return lprodNm;
    }
    public void setLprodNm(String lprodNm) {
        this.lprodNm = lprodNm;
    }
    @Override
    public String toString() {
        return "BuyerVO [buyerId=" + buyerId + ", buyerName=" + buyerName + ", buyerLgu=" + buyerLgu + ", buyerBank="
                + buyerBank + ", buyerBankno=" + buyerBankno + ", buyerBankname=" + buyerBankname + ", buyerZip="
                + buyerZip + ", buyerAdd1=" + buyerAdd1 + ", buyerAdd2=" + buyerAdd2 + ", buyerComtel=" + buyerComtel
                + ", buyerFax=" + buyerFax + ", buyerMail=" + buyerMail + ", buyerCharger=" + buyerCharger
                + ", buyerTelext=" + buyerTelext + ", lprodNm=" + lprodNm + ", ProdVO=" + ProdVO + "]";
    }


}

2.xml

lprod_SQL.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="lprod">
    <resultMap type="lprodVO" id="lprodMap">
        <id property="lprodGu" column="LPROD_GU" />
        <result property="rnum" column="RNUM" />
        <result property="lprodNm" column="LPROD_NM" />
        <collection property="buyerVO" resultMap="buyerMap">
        </collection>
    </resultMap>

    <resultMap type="buyerVO" id="buyerMap">
        <result property="buyerId" column="BUYER_ID"/>
        <result property="buyerName" column="BUYER_NAME"/>
        <result property="buyerLgu" column="BUYER_LGU"/>
    </resultMap>

<!-- 상품분류 별 거래처 목록 -->
<!-- 
parameter : 
    {keyWord=캐주,currentPage=1,size=10}
-->
    <select id="list" parameterType="hashMap" resultMap="lprodMap">
        SELECT ROWNUM RNUM, T.LPROD_GU, T.LPROD_NM
                         , T.BUYER_ID, T.BUYER_NAME, T.BUYER_LGU
          FROM
          (
               SELECT ROW_NUMBER() OVER(ORDER BY LPROD_NM, BUYER_ID) RNUM
                   , L.LPROD_GU
                   , L.LPROD_NM
                   , B.BUYER_ID
                   , B.BUYER_NAME
                   , B.BUYER_LGU
              FROM   LPROD L INNER JOIN BUYER B
              ON(L.LPROD_GU = B.BUYER_LGU)
             WHERE 1 = 1
             <if test="keyWord!=null and keyWord!=''">
                AND (L.LPROD_GU LIKE '%'||#{keyWord}||'%' 
                OR     L.LPROD_NM LIKE '%'||#{keyWord}||'%' 
                OR     B.BUYER_ID LIKE '%'||#{keyWord}||'%' 
                OR     B.BUYER_NAME LIKE '%'||#{keyWord}||'%')
              </if> 
          ) T
          WHERE T.RNUM BETWEEN #{currentPage}*7-6 AND #{currentPage}*7
    </select>

    <!-- 상품분류 별 거래처 목록의 totalCount -->
    <select id="listCount" parameterType="hashMap" resultType="int">
        SELECT COUNT(*)
        FROM LPROD L INNER JOIN BUYER B
        ON(L.LPROD_GU = B.BUYER_LGU)
        WHERE 1 = 1
        <if test="keyWord!=null and keyWord!=''">
           AND (L.LPROD_GU LIKE '%'||#{keyWord}||'%' 
           OR     L.LPROD_NM LIKE '%'||#{keyWord}||'%' 
           OR     B.BUYER_ID LIKE '%'||#{keyWord}||'%' 
           OR     B.BUYER_NAME LIKE '%'||#{keyWord}||'%')
        </if>         
    </select>

    <!-- 거래처 상세 정보 -->
    <select id="detail" parameterType="String" resultType="buyerVO">
    SELECT (SELECT L.LPROD_NM FROM LPROD L WHERE L.LPROD_GU = B.BUYER_LGU) LPROD_NM
           , B.BUYER_ID
           , B.BUYER_NAME
           , B.BUYER_LGU
           , BUYER_BANK     
           , BUYER_BANKNO
           , BUYER_BANKNAME
           , BUYER_ZIP
           , BUYER_ADD1
           , BUYER_ADD2
           , BUYER_COMTEL
           , BUYER_FAX
           , BUYER_MAIL
           , BUYER_CHARGER
           , BUYER_TELEXT
      FROM   BUYER B
      WHERE B.BUYER_ID = #{buyerId}
    </select>


</mapper>

3. Dao

LprodDao.java

package kr.or.ddit;

import java.util.List;
import java.util.Map;

import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository
public class LprodDao {

    @Autowired
    SqlSessionTemplate sqlSessionTemplate;

    public List<LprodVO> list(Map<String, Object> map){
        return this.sqlSessionTemplate.selectList("lprod.list", map);
    }
    //상품분류 별 거래처 목록 행의 수
    public int listCount(Map<String, Object> map) {
        return this.sqlSessionTemplate.selectOne("lprod.listCount", map);
    }
    //거래처 상세 정보
    public BuyerVO detail(String buyerId) {
        return this.sqlSessionTemplate.selectOne("lprod.detail", buyerId);
    }



}

4. Service

LprodService.java

package kr.or.ddit;

import java.util.List;
import java.util.Map;

public interface LprodService {

    //메소드 시그니처 처리
    //상품분류 별 거래처 목록
    public List<LprodVO> list(Map<String, Object> map);
    //상품분류 별 거래처 목록 행의 수
    public int listCount(Map<String, Object> map);
    //거래처 상세 정보
    BuyerVO detail(String buyerId);


}

LprodServiceImpl.java

package kr.or.ddit;

import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class LprodServiceImpl implements LprodService {
    @Autowired
    LprodDao lprodDao;

    @Override
    public List<LprodVO> list(Map<String, Object> map){
        return this.lprodDao.list(map);
    }

    //상품분류 별 거래처 목록 행의 수
    @Override
    public int listCount(Map<String, Object> map) {
        return this.lprodDao.listCount(map);
    }

    //거래처 상세 정보
    @Override
    public BuyerVO detail(String buyerId) {
        return this.lprodDao.detail(buyerId);
    }
}

@RequestMapping 정리

• 요청 경로는 필수!
• 속성이 하나일 때는 속성명 생략 가능
• ex) @RequestMapping(value="detail", method = RequestMethod.GET) -> @RequestMapping("/detail")
• 클래스 레벨과 메서드 레벨로 지정 가능
• 클래스 레벨로 요청 경로를 지정하면 메서드 레벨에서 지정한 경로의 기본 경로로 취급

5. Controller

LprodController.java

    ///lprod/detail?buyerId=P10101 요렇게 넘어온다
    //리턴 타입 : String => 뷰 파일의 경로와 파일 이름을 나타내기 위해 사용
    @RequestMapping(value = "detail", method = RequestMethod.GET)
    public String detail(Model model, @RequestParam String buyerId) {
    logger.info("buyerId : " + buyerId);

    BuyerVO buyerVO = this.lprodService.detail(buyerId);

    //buyerVO이 null이면 오류를 보자
    if(buyerVO! = null) {
        logger.info("buyerVO : " + buyerVO.toString());
    }

    model.addAttribute("buyerVO", buyerVO);

    //forward
    //반환값이 lprod/detail이므로 lprod폴더의 detail.jsp를 리턴
    return "/lprod/detail";

   }

    //detail.jsp에서 $("#buyerVO").submit();로 보내면 받는다!
    //수정 요청 매핑
    @RequestMapping(value = "/detail", method = RequestMethod.POST)
    public String detailPost(@Validated BuyerVO buyerVO, BindingResult result) {
    logger.info("buyerVO : " + buyerVO.toString());

    //validation 중에 문제가 발생된다면 true
    logger.info("result.hasErrors() : " + result.hasErrors());
    //validation 문제가 발생된다면
    //allErrors = globalErrors + fieldErrors
        if(result.hasErrors()) {
            List<ObjectError> allErrors = result.getAllErrors();
            List<ObjectError> globalErrors = result.getGlobalErrors();
            List<FieldError> fieldErrors = result.getFieldErrors();

            //validation 중에 어떤 오류가 나왔는지 확인..
            for(int i = 0; i<allErrors.size(); i++) {
                ObjectError objectError = allErrors.get(i);
                logger.info("objectError : " + objectError);
            }

            for(ObjectError objectError : globalErrors) {
                logger.info("objectError : " + objectError);
            }

            for(FieldError fieldError : fieldErrors) {
                logger.info("fieldError : " + fieldError.getDefaultMessage());
            }
            //문제가 발생되면 수정프로세스는 중단되고 되돌아감
            return "lprod/detail";
        }//end if

        //수정 비즈니스 로직 처리 후

        //상세 페이지로 되돌아감
        return "redirect:/lprod/detail?buyerId="+buyerVO.getBuyerId();

    }

}

6. JSP

detail.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>

<!DOCTYPE html>
<html>

<head>

    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
    <meta name="description" content="">
    <meta name="author" content="">

    <title>상품분류 별 거래처 목록</title>

    <!-- Custom fonts for this template-->
    <link href="/resources/sbadmin2/vendor/fontawesome-free/css/all.min.css" rel="stylesheet" type="text/css">
    <link
        href="https://fonts.googleapis.com/css?family=Nunito:200,200i,300,300i,400,400i,600,600i,700,700i,800,800i,900,900i"
        rel="stylesheet">

    <!-- Custom styles for this template-->
    <link href="/resources/sbadmin2/css/sb-admin-2.min.css" rel="stylesheet">
    <script type="text/javascript">
        function fn_submit() {
            var frm = document.searchForm;
            console.log("frm.size : " + frm.size.value);
            console.log("frm.keyWord : " + frm.keyWord.value);
            frm.submit();
        }
    </script>

</head>

<body id="page-top">

    <!-- Page Wrapper -->
    <div id="wrapper">

        <!-- Sidebar -->
        <jsp:include page="../includes/aside.jsp"></jsp:include>
        <!-- End of Sidebar -->

        <!-- Content Wrapper -->
        <div id="content-wrapper" class="d-flex flex-column">

            <!-- Main Content -->
            <div id="content">

                <!-- Topbar -->
                <jsp:include page="../includes/header.jsp"></jsp:include>
                <!-- End of Topbar -->

<!-- Begin Page Content 본문 시작 -->
<div class="container-fluid">
<div class="card o-hidden border-0 shadow-lg my-5">
       <div class="card-body p-0">
           <!-- Nested Row within Card Body -->
      <div class="row">
          <div class="col-lg-5 d-none d-lg-block bg-register-image"></div>
          <div class="col-lg-7">
              <div class="p-5">
                  <div class="text-center">
                      <h1 class="h4 text-gray-900 mb-4">${buyerVO.buyerName}</h1>
                    </div>
                    <form:form modelAttribute="buyerVO" class="user" method="post" action="/lprod/detail">
                        <div class="form-group row">
                            <div class="col-sm-6 mb-3 mb-sm-0">
                                <form:input path="buyerId" class="form-control form-control-user" id="buyerId" placeholder="" />
                            </div>
                            <div class="col-sm-6">
                                <form:input path="lprodNm" class="form-control form-control-user" id="lprodNm" placeholder="" />
                            </div>
                        </div>
                        <div class="form-group">
                            <form:input path="buyerMail" class="form-control form-control-user" id="buyerMail" placeholder="" />
                            <font color="red"><form:errors path="buyerMail" /></font>
                        </div>
                        <div class="form-group row">
                            <div class="col-sm-6 mb-3 mb-sm-0">
                                <form:input path="buyerComtel" class="form-control form-control-user" id="buyerComtel" />
                                <font color="red"><form:errors path="buyerComtel" /></font>
                            </div>
                            <div class="col-sm-6">
                                <form:input path="buyerCharger" class="form-control form-control-user" id="buyerCharger" />
                                <font color="red"><form:errors path="buyerCharger" /></font>
                            </div>
                        </div>
                        <a href="#" id="btnEdit" class="btn btn-primary btn-user btn-block">
                            수정
                        </a>
                        <a href="#" id="btnConfirm" style="display:none;" class="btn btn-success btn-icon-split btn-block">
                            <span class="icon text-white-50">
                                <i class="fas fa-check"></i>
                            </span>
                            <span class="text">확인</span>
                        </a>
                        <a href="#" id="btnCancel" style="display:none;" class="btn btn-danger btn-icon-split btn-block">
                             <span class="icon text-white-50">
                                 <i class="fas fa-trash"></i>
                             </span>
                             <span class="text">취소</span>
                        </a>            
                        <hr>
                        <a href="/lprod/list" class="btn btn-google btn-user btn-block">
                            <i class="fab fa-google fa-fw"></i> 목록보기
                        </a>
                    </form:form>
                    <hr>
                    <div class="text-center">
                        <a class="small" href="forgot-password.html">Forgot Password?</a>
                    </div>
                    <div class="text-center">
                        <a class="small" href="login.html">Already have an account? Login!</a>
                    </div>
                </div>
            </div>
        </div>
    </div>
</div>
        <!-- /.container-fluid 본문 끝-->

</div>
            <!-- End of Main Content -->

            <!-- Footer -->
            <jsp:include page="../includes/footer.jsp"></jsp:include>
            <!-- End of Footer -->

        </div>
        <!-- End of Content Wrapper -->

    </div>
    <!-- End of Page Wrapper -->

    <!-- Scroll to Top Button-->
    <a class="scroll-to-top rounded" href="#page-top">
        <i class="fas fa-angle-up"></i>
    </a>

    <!-- Logout Modal-->
    <div class="modal fade" id="logoutModal" tabindex="-1" role="dialog" aria-labelledby="exampleModalLabel"
        aria-hidden="true">
        <div class="modal-dialog" role="document">
            <div class="modal-content">
                <div class="modal-header">
                    <h5 class="modal-title" id="exampleModalLabel">수정 요청</h5>
                    <button class="close" type="button" data-dismiss="modal" aria-label="Close">
                        <span aria-hidden="true">×</span>
                    </button>
                </div>
                <div class="modal-body">Select "Logout" below if you are ready to end your current session.</div>
                <div class="modal-footer">
                    <button class="btn btn-secondary" type="button" data-dismiss="modal">취소</button>
                    <a class="btn btn-primary" id="modalConfirm" href="#">확인</a>
                </div>
            </div>
        </div>
    </div>

    <!-- Bootstrap core JavaScript-->
    <script src="/resources/sbadmin2/vendor/jquery/jquery.min.js"></script>
    <script src="/resources/sbadmin2/vendor/bootstrap/js/bootstrap.bundle.min.js"></script>

    <!-- Core plugin JavaScript-->
    <script src="/resources/sbadmin2/vendor/jquery-easing/jquery.easing.min.js"></script>

    <!-- Custom scripts for all pages-->
    <script src="/resources/sbadmin2/js/sb-admin-2.min.js"></script>

    <!-- Page level plugins -->
    <script src="/resources/sbadmin2/vendor/chart.js/Chart.min.js"></script>

    <!-- Page level custom scripts -->
    <script src="/resources/sbadmin2/js/demo/chart-area-demo.js"></script>
    <script src="/resources/sbadmin2/js/demo/chart-pie-demo.js"></script>

    <script type="text/javascript">
           $(function(){
               $(".form-control-user").prop("readonly",true);

               //수정버튼 클릭 시 수정버튼 사라지고, 확인/취소버튼 보임
               $("#btnEdit").on("click",function(){
                   $(".form-control-user").prop("readonly",false);
                   //수정 대상이 아닌 요소 처리
                   //단, disabled -> true(X, 요소가 비활성됨) => form으로 안넘어감..
                   //readonly를 쓰자!
                   $("#buyerId").prop("readonly",true);
                   $("#lprodNm").prop("readonly",true);

                   //수정버튼 사라지고
                   $("#btnEdit").css("display", "none");

                   //확인/취소버튼 보임
                   $("#btnConfirm").css("display", "block");
                   $("#btnCancel").css("display", "block");
               });
               //취소버튼 클릭  시 새로고침 처리
               $('#btnCancel').on("click",function(){
                   location.reload();
               });
               //확인버튼 클릭 시 수정 요청
               $("#btnConfirm").on("click",function(){
                   $(".modal-body").html("해당 글을 수정 하시겠습니까?");
                   $("#logoutModal").modal("show");
               });
               //모달 확인 버튼 클릭 시 수정 프로세스 진행
               $("#modalConfirm").on("click",function(){
                   $("#buyerVO").submit();
               });
           });
    </script>


</body>

</html>

1) 구글에 sb admin2 검색 https://startbootstrap.com/theme/sb-admin-2 들어가서 다운로드 클릭 압축풀고 webapp 폴더의 resources에 넣기

2) views 폴더에 aside.jsp, header.jsp, footer.jsp파일을 각각 만들어 처리하고, list.jsp의 <body>에 <jsp:include>의 page 속성을 사용하여 추가함

3) list.jsp의 경로 바꾸기 (1) src="vendor 검색 src="/resources/sbadmin2/vendor로 바꾸기 (2) src="js 검색 src="/resources/sbadmin2/js 로 바꾸기 (3) href="css 검색 href="/resources/sbadmin2/css로 바꾸기 (4) href="vendor 검색 href="/resources/sbadmin2/vendor로 바꾸기 (5) src="img 검색 href="/resources/sbadmin2/vendor/img로 바꾸기

Paging 처리용 클래스 생성

ArticlePage.java

package kr.or.ddit;

import java.util.List;

//페이징 처리를 위한 클래스
//게시글 데이터와 페이징 관련 정보를 담고 있음
public class ArticlePage {
    //페이징 관련 멤버변수
    //전체 글의 행의 수
    private int total;
    //현재 페이지 번호
    private int currentPage;
    //전체 페이지 개수
    private int totalPages;
    //시작 페이지 번호
    private int startPage;
    //종료 페이지 번호
    private int endPage;
    //페이징의 개수
    private int pagingCount;
    //게시글 데이터
    private List<LprodVO> content;

    //생성자
    //size : 한 화면에 보여질 행의 수
    public ArticlePage(int total, int currentPage, int size, int pagingCount, List<LprodVO> content) {
        super();
        this.total = total;
        this.currentPage = currentPage;
        this.content = content;
        this.pagingCount = pagingCount;
        //select 결과가 없다면..
        if(total == 0) {
            totalPages = 0;
            startPage = 0;
            endPage = 0;
        }else { //select 결과가 있을 때
            //전체 페이지 개수 구하기(전체 글의 수/한 화면에 보여질 행의 수)
            //정수와 정수의 나눗셈 결과는 정수! 13 / 7 => 1
            totalPages = total / size;
            //보정해줘야 할 경우는? 15 / 7 = 2 경우 처럼 나머지가 0보다 클 때
            if(total % size > 0){
                totalPages++;
            }

            //startPage : 이전 [1] [2] [3] [4] [5] 다음    일 때 1을 의미
            //startPage 공식 : 현재 페이지 / 페이징의 개수 * 페이징의 개수 + 1 
            startPage = currentPage / pagingCount * pagingCount + 1;
            //보정해줘야 할 경우는? 5 / 5 * 5 + 1 => 6 경우처럼
            //                현재페이지  % 5 == 0 일 때  (5, 10, 15처럼)
            if(currentPage%pagingCount==0) {
                //startPage = startPage - 5(페이징의 개수);
                startPage -= pagingCount;
            //endPage : 이전 [1] [2] [3] [4] [5] 다음    일 때 5를 의미
            endPage = startPage + (pagingCount-1);
            //보정해줘야 할 경우는? endPage > totalPages 일 때 (ex 5 > 3)
            //                    endPage를 totalPages로 바꿔줘야 함 (ex 5를 3으로 바꾸자!)
            if(endPage > totalPages) {
                endPage = totalPages;
            }
        }//end outer if

    }
    //전체 행의 수를 리턴
    //자바빈 클래스가 아니기 때문에 모든 멤버변수의 getter/setter메소드를 만들 필요는 없다.
    public int getTotal() {
        return this.total;
    }

    //select 결과가 없는가? true면 결과가 없다는 의미
    public boolean hasnoArticles() {
        return this.total == 0;
    }

    //select 결과가 있는가? true면 결과가 있다는 의미
    public boolean hasArticles() {
        return this.total > 0;
    }

    //현재 페이지 번호 리펀
    public int getCurrentPage() {
        return this.currentPage;
    }

    //전체 페이지의 개수 리턴
    public int getTotalPages() {
        return totalPages;
    }

    //데이터 VO List 리턴
    public List<LprodVO> getContent() {
        return this.content;
    }

    //목록 하단의 시작 번호를 리턴
    public int getStartPage() {
        return this.startPage;
    }

    //목록 하단의 종료 번호를 리턴
    public int getEndPage() {
        return this.endPage;
    }

}

컨트롤러에서 ArticlePage 객체 생성

LprodController.java

package kr.or.ddit;

import java.util.List;

@RequestMapping(value = "lprod")
@Controller
public class LprodController {
    private static final Logger logger = LoggerFactory.getLogger(LprodController.class);

    @Inject
    LprodService lprodService;

    //http://localhost:8090/lprod/list?currentPage=1 처럼 
    //@RequestParam으로 가져오는 파라미터는 String이 아닌 int, Map, VO로도 가능하다..
    //http://localhost:8090/lprod/list처럼 해당 요청 파라미터를 지정하지 않는 경우, defaultValue 속성에 지정한 문자열을 값으로 이용하게 됨(http://localhost:8090/lprod/list 처럼 currentPage의 값을 모를 때, null일 때)
    @RequestMapping(value = "/list")
    public String list(Model model, @RequestParam(defaultValue = "1") int currentPage) {
    //currentPage 출력
    logger.info("currentPage : " + currentPage);

    List<LprodVO> list = this.lprodService.list();

    //상품분류 별 거래처 목록 행의 수
    int total = this.lprodService.listCount();
    logger.info("total : " + total);

    //페이징 처리한 객체를 넣는다.
    model.addAttribute("list", new ArticlePage(total, currentPage, 7, 5, list));
    model.addAttribute("total", total);

    //forward
    return "lprod/list";
    }



}

JSP

list.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>

<head>

    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
    <meta name="description" content="">
    <meta name="author" content="">

    <title>상품분류 별 거래처 목록</title>

    <!-- Custom fonts for this template-->
    <link href="/resources/sbadmin2/vendor/fontawesome-free/css/all.min.css" rel="stylesheet" type="text/css">
    <link
        href="https://fonts.googleapis.com/css?family=Nunito:200,200i,300,300i,400,400i,600,600i,700,700i,800,800i,900,900i"
        rel="stylesheet">

    <!-- Custom styles for this template-->
    <link href="/resources/sbadmin2/css/sb-admin-2.min.css" rel="stylesheet">

</head>

<body id="page-top">

    <!-- Page Wrapper -->
    <div id="wrapper">

        <!-- Sidebar -->
        <jsp:include page="../includes/aside.jsp"></jsp:include>
        <!-- End of Sidebar -->

        <!-- Content Wrapper -->
        <div id="content-wrapper" class="d-flex flex-column">

            <!-- Main Content -->
            <div id="content">

                <!-- Topbar -->
                <jsp:include page="../includes/header.jsp"></jsp:include>
                <!-- End of Topbar -->

                <!-- Begin Page Content 본문 시작 -->
                <div class="container-fluid">

                    <!-- Page Heading -->
                    <h1 class="h3 mb-2 text-gray-800">상품분류 별 거래처 목록</h1>
                    <p class="mb-4">상품분류 별로 거래처의 목록을 화면에 보여줍니다.</p>

                    <!-- DataTales Example -->
                    <div class="card shadow mb-4">
                        <div class="card-header py-3">
                            <h6 class="m-0 font-weight-bold text-primary">DataTables Example</h6>
                        </div>
                        <div class="card-body">
                            <div class="table-responsive">
                                <div id="dataTable_wrapper" class="dataTables_wrapper dt-bootstrap4"><div class="row"><div class="col-sm-12 col-md-6"><div class="dataTables_length" id="dataTable_length"><label>Show <select name="dataTable_length" aria-controls="dataTable" class="custom-select custom-select-sm form-control form-control-sm"><option value="10">10</option><option value="25">25</option><option value="50">50</option><option value="100">100</option></select> entries</label></div></div><div class="col-sm-12 col-md-6"><div id="dataTable_filter" class="dataTables_filter"><label>Search:<input type="search" class="form-control form-control-sm" placeholder="" aria-controls="dataTable"></label></div></div></div><div class="row"><div class="col-sm-12"><table class="table table-bordered dataTable" id="dataTable" width="100%" cellspacing="0" role="grid" aria-describedby="dataTable_info" style="width: 100%;">
                                    <thead>
                                    <tr role="row">
                                        <th class="sorting sorting_asc" tabindex="0" aria-controls="dataTable" rowspan="1" colspan="1" aria-sort="ascending" aria-label="Name: activate to sort column descending" style="width: 50px;">번호</th>
                                        <th class="sorting" tabindex="0" aria-controls="dataTable" rowspan="1" colspan="1" aria-label="Position: activate to sort column ascending" style="width: 200px;">상품분류코드</th>
                                        <th class="sorting" tabindex="0" aria-controls="dataTable" rowspan="1" colspan="1" aria-label="Office: activate to sort column ascending">상품분류명</th>
                                        <th class="sorting" tabindex="0" aria-controls="dataTable" rowspan="1" colspan="1" aria-label="Age: activate to sort column ascending" style="width: 200px;">거래처코드</th>
                                        <th class="sorting" tabindex="0" aria-controls="dataTable" rowspan="1" colspan="1" aria-label="Start date: activate to sort column ascending">거래처명</th>
                                    </tr>
                                    </thead>
                                    <tfoot>
                                     <tr>
                                         <th rowspan="1" colspan="1">번호</th>
                                        <th rowspan="1" colspan="1">상품분류코드</th>
                                        <th rowspan="1" colspan="1">상품분류명</th>
                                        <th rowspan="1" colspan="1">거래처코드</th>
                                        <th rowspan="1" colspan="1">거래처명</th>
                                     </tr>
                                    </tfoot>
                                    <tbody>
                                    <c:set var="i" value="0"/>
                                    <c:forEach var="lprodVO" items="${list.content}">
                                    <c:forEach var="buyerVO" items="${lprodVO.buyerVO}">
                                    <c:set var="cnt" value="${i=i+1}" />
                                    <c:if test="${cnt%2==1}">
                                    <tr class="odd">
                                    </c:if>
                                    <c:if test="${cnt%2==0}">
                                    <tr class="even">
                                    </c:if>
                                            <td class="sorting_1">${cnt}</td>
                                            <td>${lprodVO.lprodGu}</td>
                                            <td>${lprodVO.lprodNm}</td>
                                            <td>${buyerVO.buyerId}</td>
                                            <td>${buyerVO.buyerName}</td>
                                     </tr>
                                     </c:forEach>
                                     </c:forEach>
                                     </tbody>
                                </table>
                                </div>
                                </div>
                                <div class="row">
                                <div class="col-sm-12 col-md-5">
                                <div class="dataTables_info" id="dataTable_info" role="status" aria-live="polite">
                                <!-- A*7-6 A*7 -->
                                Showing ${param.currentPage*7-6} to ${param.currentPage*7} of ${total} entries
                                </div>
                                </div>
                                <div class="col-sm-12 col-md-7">
                                <div class="dataTables_paginate paging_simple_numbers" id="dataTable_paginate">
                                <!-- 페이징 처리 시작 -->
                                <ul class="pagination">
                                <!-- Previous 시작 -->
                                    <li class="paginate_button page-item previous <c:if test='${list.startPage<6}'>disabled</c:if>" id="dataTable_previous"><a href="/lprod/list?currentPages=${list.startPage-5}" aria-controls="dataTable" data-dt-idx="0" tabindex="0" class="page-link">Previous</a></li>
                                <!-- Previous 끝 -->
                                <!-- Page번호 시작, 컨트롤러에서 list에 페이징 객체를 넣었으므로 list.변수명으로 불러옴 -->
                                <c:forEach var="pNo" begin="${list.startPage}" end="${list.endPage}" step="1">
                                    <li class="paginate_button page-item <c:if test='${param.currentPage eq pNo}'>active</c:if>"><a href="/lprod/list?currentPage=${pNo}" aria-controls="dataTable" data-dt-idx="1" tabindex="0" class="page-link">${pNo}</a></li>
                                </c:forEach>
                                <!-- Page번호 끝 -->
                                <!-- Next 시작 -->
                                    <li class="paginate_button page-item next<c:if test='${list.endPage>=list.totalPages}'>disabled</c:if>" id="dataTable_next"><a href="/lprod/list?currentPage=${list.startPage+5}" aria-controls="dataTable" data-dt-idx="7" tabindex="0" class="page-link">Next</a></li>
                                <!-- Next 끝 -->
                                <!-- 페이징 처리 끝 -->
                                </ul></div></div></div></div>
                            </div>
                        </div>
                    </div>

                </div>
                <!-- /.container-fluid 본문 끝-->

            </div>
            <!-- End of Main Content -->

            <!-- Footer -->
            <jsp:include page="../includes/footer.jsp"></jsp:include>
            <!-- End of Footer -->

        </div>
        <!-- End of Content Wrapper -->

    </div>
    <!-- End of Page Wrapper -->

    <!-- Scroll to Top Button-->
    <a class="scroll-to-top rounded" href="#page-top">
        <i class="fas fa-angle-up"></i>
    </a>

    <!-- Logout Modal-->
    <div class="modal fade" id="logoutModal" tabindex="-1" role="dialog" aria-labelledby="exampleModalLabel"
        aria-hidden="true">
        <div class="modal-dialog" role="document">
            <div class="modal-content">
                <div class="modal-header">
                    <h5 class="modal-title" id="exampleModalLabel">Ready to Leave?</h5>
                    <button class="close" type="button" data-dismiss="modal" aria-label="Close">
                        <span aria-hidden="true">×</span>
                    </button>
                </div>
                <div class="modal-body">Select "Logout" below if you are ready to end your current session.</div>
                <div class="modal-footer">
                    <button class="btn btn-secondary" type="button" data-dismiss="modal">Cancel</button>
                    <a class="btn btn-primary" href="login.html">Logout</a>
                </div>
            </div>
        </div>
    </div>

    <!-- Bootstrap core JavaScript-->
    <script src="/resources/sbadmin2/vendor/jquery/jquery.min.js"></script>
    <script src="/resources/sbadmin2/vendor/bootstrap/js/bootstrap.bundle.min.js"></script>

    <!-- Core plugin JavaScript-->
    <script src="/resources/sbadmin2/vendor/jquery-easing/jquery.easing.min.js"></script>

    <!-- Custom scripts for all pages-->
    <script src="/resources/sbadmin2/js/sb-admin-2.min.js"></script>

    <!-- Page level plugins -->
    <script src="/resources/sbadmin2/vendor/chart.js/Chart.min.js"></script>

    <!-- Page level custom scripts -->
    <script src="/resources/sbadmin2/js/demo/chart-area-demo.js"></script>
    <script src="/resources/sbadmin2/js/demo/chart-pie-demo.js"></script>

</body>

</html>

• 기본키는 id 아닌 컬럼은 result에
• property :vo의 멤버변수명
• column : select문의 컬럼명
• 1:1 관계는 <association>
• 1:N 관계는 <collection>

예시) LPROD(1)와 BUYER(N) 관계에서 buyerVO를 list로 반환하기

1. <select> 작성

<select id="아이디" resultMap="반환할 VO객체의 Map명">
    조회할 쿼리문 작성
</select>

2. resultMap 작성

    <resultMap type="<select>에서 작성한 VO객체명" id="<select>에서 작성한 resultMap명">
        <result property="VO객체의 멤버변수명" column="컬럼명" />
        <collection property="1:N 관계 중 N에 해당하는 VO객체명" resultMap="반환할 VO객체의 map명">
        </collection>
    </resultMap>

3. 1:N 관계 속성 중 N에 해당하는 resultMap 작성

    <resultMap type="1:N 관계 중 N에 해당하는 VO객체명" id="<collection>에서 작성한 resultMap명">
        <result property="VO객체의 멤버변수명" column="컬럼명"/>
    </resultMap>

1. VO

LprodVO.java

package kr.or.ddit;

import java.util.List;

public class LprodVO {
    private int lprodId;
    private String lprodGu;
    private String lprodNm;

    //Lprod : Buyer = 1 : N 관계
    private List<BuyerVO> BuyerVO;

    public int getLprodId() {
        return lprodId;
    }

    public void setLprodId(int lprodId) {
        this.lprodId = lprodId;
    }

    public String getLprodGu() {
        return lprodGu;
    }

    public void setLprodGu(String lprodGu) {
        this.lprodGu = lprodGu;
    }

    public String getLprodNm() {
        return lprodNm;
    }

    public void setLprodNm(String lprodNm) {
        this.lprodNm = lprodNm;
    }

    public List<BuyerVO> getBuyerVO() {
        return BuyerVO;
    }

    public void setBuyerVO(List<BuyerVO> buyerVO) {
        BuyerVO = buyerVO;
    }

    @Override
    public String toString() {
        return "LprodVO [lprodId=" + lprodId + ", lprodGu=" + lprodGu + ", lprodNm=" + lprodNm + ", BuyerVO=" + BuyerVO
                + "]";
    }


}

BuyerVO.java

package kr.or.ddit;

import java.util.List;

//자바빈 클래스
public class BuyerVO {
    //멤버변수
    private String buyerId;
    private String buyerName;
    private String buyerLgu;
    private String buyerBank;
    private String buyerBankno;
    private String buyerBankname;
    private String buyerZip;
    private String buyerAdd1;
    private String buyerAdd2;
    private String buyerComtel;
    private String buyerFax;
    private String buyerMail;
    private String buyerCharger;
    private String buyerTelext;


    //Buyer : ProdVO = 1: N 관계
    private List<ProdVO> ProdVO;

    //getter/setter 메소드
    public String getBuyerId() {
        return buyerId;
    }
    public void setBuyerId(String buyerId) {
        this.buyerId = buyerId;
    }
    public String getBuyerName() {
        return buyerName;
    }
    public void setBuyerName(String buyerName) {
        this.buyerName = buyerName;
    }
    public String getBuyerLgu() {
        return buyerLgu;
    }
    public void setBuyerLgu(String buyerLgu) {
        this.buyerLgu = buyerLgu;
    }
    public String getBuyerBank() {
        return buyerBank;
    }
    public void setBuyerBank(String buyerBank) {
        this.buyerBank = buyerBank;
    }
    public String getBuyerBankno() {
        return buyerBankno;
    }
    public void setBuyerBankno(String buyerBankno) {
        this.buyerBankno = buyerBankno;
    }
    public String getBuyerBankname() {
        return buyerBankname;
    }
    public void setBuyerBankname(String buyerBankname) {
        this.buyerBankname = buyerBankname;
    }
    public String getBuyerZip() {
        return buyerZip;
    }
    public void setBuyerZip(String buyerZip) {
        this.buyerZip = buyerZip;
    }
    public String getBuyerAdd1() {
        return buyerAdd1;
    }
    public void setBuyerAdd1(String buyerAdd1) {
        this.buyerAdd1 = buyerAdd1;
    }
    public String getBuyerAdd2() {
        return buyerAdd2;
    }
    public void setBuyerAdd2(String buyerAdd2) {
        this.buyerAdd2 = buyerAdd2;
    }
    public String getBuyerComtel() {
        return buyerComtel;
    }
    public void setBuyerComtel(String buyerComtel) {
        this.buyerComtel = buyerComtel;
    }
    public String getBuyerFax() {
        return buyerFax;
    }
    public void setBuyerFax(String buyerFax) {
        this.buyerFax = buyerFax;
    }
    public String getBuyerMail() {
        return buyerMail;
    }
    public void setBuyerMail(String buyerMail) {
        this.buyerMail = buyerMail;
    }
    public String getBuyerCharger() {
        return buyerCharger;
    }
    public void setBuyerCharger(String buyerCharger) {
        this.buyerCharger = buyerCharger;
    }
    public String getBuyerTelext() {
        return buyerTelext;
    }
    public void setBuyerTelext(String buyerTelext) {
        this.buyerTelext = buyerTelext;
    }

    public List<ProdVO> getProdVO() {
        return ProdVO;
    }
    public void setProdVO(List<ProdVO> prodVO) {
        ProdVO = prodVO;
    }

    @Override
    public String toString() {
        return "BuyerVO [buyerId=" + buyerId + ", buyerName=" + buyerName + ", buyerLgu=" + buyerLgu + ", buyerBank="
                + buyerBank + ", buyerBankno=" + buyerBankno + ", buyerBankname=" + buyerBankname + ", buyerZip="
                + buyerZip + ", buyerAdd1=" + buyerAdd1 + ", buyerAdd2=" + buyerAdd2 + ", buyerComtel=" + buyerComtel
                + ", buyerFax=" + buyerFax + ", buyerMail=" + buyerMail + ", buyerCharger=" + buyerCharger
                + ", buyerTelext=" + buyerTelext + ", ProdVO=" + ProdVO + "]";
    }




}

2. XML

lprod_SQL.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="lprod">
    <resultMap type="lprodVO" id="lprodMap">
        <result property="lprodGu" column="LPROD_GU" />
        <result property="lprodNm" column="LPROD_NM" />
        <collection property="buyerVO" resultMap="buyerMap">
        </collection>
    </resultMap>

    <resultMap type="buyerVO" id="buyerMap">
        <result property="buyerId" column="BUYER_ID"/>
        <result property="buyerName" column="BUYER_NAME"/>
    </resultMap>

    <select id="list" resultMap="lprodMap">
        SELECT L.LPROD_GU
            , L.LPROD_NM
            , B.BUYER_ID
            , B.BUYER_NAME
        FROM LPROD L, BUYER B
        WHERE L.LPROD_GU = B.BUYER_LGU
        ORDER BY LPROD_GU ASC
    </select>

</mapper>

3. Dao

LprodDao.java

package kr.or.ddit;

import java.util.List;

import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository
public class LprodDao {

    @Autowired
    SqlSessionTemplate sqlSessionTemplate;

    public List<LprodVO> list(){
        return this.sqlSessionTemplate.selectList("lprod.list");
    }


}

4. Service

LprodService.java

package kr.or.ddit;

import java.util.List;

import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository
public class LprodDao {

    @Autowired
    SqlSessionTemplate sqlSessionTemplate;

    public List<LprodVO> list(){
        return this.sqlSessionTemplate.selectList("lprod.list");
    }


}

LprodServiceImpl.java

package kr.or.ddit;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class LprodServiceImpl implements LprodService {
    @Autowired
    LprodDao lprodDao;

    @Override
    public List<LprodVO> list(){
        return this.lprodDao.list();
    }
}

5. Controller

LprodController.java

package kr.or.ddit;

import java.util.List;

import javax.inject.Inject;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@RequestMapping(value = "/lprod")
@Controller
public class LprodController {
    @Inject
    LprodService lprodService;

    @RequestMapping(value = "/list")
    public String list(Model model) {
        List<LprodVO> list = this.lprodService.list();
        model.addAttribute("list", list);
        return "lprod/list";
    }
}

6. JSP

list.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<title>분류번호 별 거래처 목록</title>
</head>
<body>
<table border="1">
    <tr>
        <th>번호</th>
        <th>분류번호</th>
        <th>분류명</th>
        <th>거래처번호</th>
        <th>거래처명</th>
    </tr>
    <c:forEach var="lprodVO" items="${list}">
        <c:forEach var="buyerVO" items="${lprodVO.buyerVO}">
        <c:set var="cnt" value="${i=i+1}" />
    <tr>
        <td>${cnt}</td>
        <td>${lprodVO.lprodGu}</td>
        <td>${lprodVO.lprodNm}</td>
        <td>${buyerVO.buyerId}</td>
        <td>${buyerVO.buyerName}</td>
    </tr>
        </c:forEach>
    </c:forEach>
</table>

</body>
</html>

VO

MemberVO.java

package kr.or.ddit;

import java.util.Date;
import java.util.List;

import org.springframework.format.annotation.DateTimeFormat;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

//자바빈 클래스 
//lombok사용해서 아래처럼 편하게 만들 수 있지만 POJO(초기의 순수한 자바)에 위배됨
//@Setter
//@Getter
//@ToString

public class MemberVO {
    private String memberid;
    private String password;
    private String name;
    private String email;
    private String introduction; //자기소개
    //pattern : date 넣을 때 요 형식으로 써주세요~
    //@DateTimeFormat(pattern="yyyy-MM-dd")꼭 써줘야 date형식으로 들어간다
    @DateTimeFormat(pattern="yyyy-MM-dd")
    private Date regdate;

    private String[] hobbyArray; //취미 방법 2
    private List<String> hobbyList; //취미 방법 1

    private String gender; //성별

    //MemberVO : CardVO = 1 : n 의 관계
    //한명의 회원이 여러 카드를 가질 수 있다.
    private List<CardVO> cardList;


    //기본 생성자
    public MemberVO() {
        super();
        // TODO Auto-generated constructor stub
    }

    //파라미터 던져주면 멤버변수에 자동으로 세팅된다
    public MemberVO(String memberid, String password, String name, String email, Date regdate) {
        super();
        this.memberid = memberid;
        this.password = password;
        this.name = name;
        this.email = email;
        this.regdate = regdate;
    }

    public String getMemberid() {
        return memberid;
    }
    public void setMemberid(String memberid) {
        this.memberid = memberid;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public Date getRegdate() {
        return regdate;
    }
    public void setRegdate(Date regdate) {
        this.regdate = regdate;
    }
    public String getIntroduction() {
        return introduction;
    }

    public void setIntroduction(String introduction) {
        this.introduction = introduction;
    }

    public List<String> getHobbyList() {
        return hobbyList;
    }

    public void setHobbyList(List<String> hobbyList) {
        this.hobbyList = hobbyList;
    }


    public String[] getHobbyArray() {
        return hobbyArray;
    }

    public void setHobbyArray(String[] hobbyArray) {
        this.hobbyArray = hobbyArray;
    }

    //비밀번호 변경 기능 구현 시 사용
    public boolean matchPassword(String pwd) {
        return password.contentEquals(pwd);
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public List<CardVO> getCardList() {
        return cardList;
    }

    public void setCardList(List<CardVO> cardList) {
        this.cardList = cardList;
    }

    @Override
    public String toString() {
        return "MemberVO [memberid=" + memberid + ", password=" + password + ", name=" + name + ", email=" + email
                + ", introduction=" + introduction + ", regdate=" + regdate + ", hobbyArray=" + hobbyArray
                + ", hobbyList=" + hobbyList + ", gender=" + gender + ", cardList=" + cardList + "]";
    }


}

CardVO.java

package kr.or.ddit;

import java.util.Date;

import org.springframework.format.annotation.DateTimeFormat;

//자바빈 클래스
public class CardVO {
    private String memberid;
    private String no;
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date vaildMonth;

    public String getMemberid() {
        return memberid;
    }
    public void setMemberid(String memberid) {
        this.memberid = memberid;
    }

    public String getNo() {
        return no;
    }
    public void setNo(String no) {
        this.no = no;
    }
    public Date getVaildMonth() {
        return vaildMonth;
    }
    public void setVaildMonth(Date vaildMonth) {
        this.vaildMonth = vaildMonth;
    }
    @Override
    public String toString() {
        return "CardVO [memberid=" + memberid + ", no=" + no + ", vaildMonth=" + vaildMonth + "]";
    }

}

Controller

MemberController.java

package kr.or.ddit;

import java.util.HashMap;

//spring 프레임워크가 자바 빈(=객체)으로 등록해서 관리할 수 있도록 어노테이션 달기
//클래스 단으로 빼면 메소드 위 @RequestMapping("/member/insert") -> @RequestMapping("/insert")로 사용 가능
@RequestMapping(value="/member")
@Controller
public class MemberController {
    //로거 만들기
    private static final Logger logger = LoggerFactory.getLogger(MemberController.class);

    //DI(Dependency Injection : 의존성 주입)하면 컨트롤러에서 MemberService를 사용할 수 있다
    @Autowired
    MemberService memberService;

    //컨트롤러의 insert메서드의 매개변수로 자바빈즈 객체가 전달이 되면 기본적으로 다시 화면(view(jsp))으로 전달함
    //컨트롤러와 뷰 사이에 자바빈즈 객체를 서로 공유한다.
    //방법
    //1) 폼 객체의 속성명을 직접 지정
    //2) 폼 객체의 속성명은 직접 저장하지 않으면 **폼 객체의 클래스명의 맨 처음 문자를 소문자로 변환하여 처리
    //    ex) MemberVO -> memberVO, 아래 매개변수명을 memberVO라고 적지 않아도 앞 클래스명을 변환하여 전달
    //3) ModelAttribute 애너테이션으로 폼 객체의 속성명을 dotori라고 지정했다면...
    //    스프링 폼의 modelAttribute 속성의 값도 똑같이 dotori라고 작성해줘야 함
    @RequestMapping("/insert")
    public String insert(Model model, @ModelAttribute("memberVO") MemberVO memberVO) {
      //폼 객체의 속성명과 폼 태그의 modelAttribute 속성값이 같아야 함
      //model.addAttribute("memberVO", new MemberVO()); 이렇게 적어주거나 파라미터에 넣기

      //폼 객체의 프로퍼티 값을 지정 -> 모델을 통해서 뷰(jsp)로 전달이 됨
      // --> <form:input의 path="memberid" /> 때문 (단, path값은 VO객체의 멤버변수명과 일치해야 함)
      memberVO.setMemberid("a001");
      memberVO.setName("도토리");
      //<form:password -> 값을 설정해서 뷰(jsp)에 전달하더라도 패스워드 필드에 반영되지 않음
      memberVO.setPassword("java");
      memberVO.setEmail("test@test.com");

      String introduction = "안녕하세요.\n반갑습니다.";
      memberVO.setIntroduction(introduction);

      //취미 세팅
      Map<String, String> hobbyMap = new HashMap<String,String>();
      hobbyMap.put("01", "배구");
      hobbyMap.put("02", "EDM Music");
      hobbyMap.put("03", "해리포터 시리즈");

      model.addAttribute("hobbyMap",hobbyMap);

      //성별 세팅
      Map<String, String> genderMap = new HashMap<String, String>();
      genderMap.put("Male","남성");
      genderMap.put("Female","여성");
      genderMap.put("other","기타");

      //session.setAttribute("gender","genderMap"); 처럼
      model.addAttribute("genderMap",genderMap);
      //model에는 memberVO객체와 hobbyMap, genderMap이 들어가 있음

      return "member/joinForm";
      //model은 jsp를, ModelAndView는 ModelAndView 객체를 리턴
    }

    //요청과 메소드를 매핑(연결)하는 어노테이션
    @RequestMapping(value="/insert", method=RequestMethod.POST)
    //기본이 GET이기 때문에, GET방식이라면 method=RequestMethod.GET 생략 가능
    //기존에는 ModelAndView로 model의 영역과 view의 영역을 같이 사용했음
    //public ModelAndView insertPost(@RequestParam Map<String, Object> map) {
//        ModelAndView mav = new ModelAndView(map);
//        mav.setViewName("member/result");
//        return mav;

    //이제는 model과 view를 분리한다!
    public String insertPost(@ModelAttribute MemberVO memberVO) { //@ModelAttribute를 사용해서 jsp안에 있는 VO로 받을 수 있다.

    //sysout 안쓰고 logger로 찍기
    logger.info(memberVO.getMemberid());
    logger.info(memberVO.getName());
    logger.info(memberVO.getPassword());
    logger.info(memberVO.getEmail());
    logger.info(memberVO.getIntroduction());
    List<String> hobbyList = memberVO.getHobbyList();
    for(String hobby : hobbyList){
        logger.info(hobby);    
    }
    String[] hobbyArray = memberVO.getHobbyArray();
    for(String str : hobbyArray) {
        logger.info(str);
    }
    //성별
    logger.info(memberVO.getGender());

    //뷰의 경로(mav.setViewName("member/result"))
    //forwarding 방식
    return "member/result";

   }

  // public ModelAndView list(ModelAndView mav) { 로 하거나 아래처럼
  // String은 뷰의 경로, list(Model model)는 모델 데이터
      // 속성이 하나이면 @RequestMapping(value="/member/list", method = RequestMethod.GET)으로 안쓰고 아래처럼 생략가능
    @RequestMapping("/list")
    public String list(Model model){
        List<MemberVO> memberVO = this.memberService.select();

        // 1) 데이터를 담아서
        model.addAttribute("list", memberVO);

        // 2) 뷰로 보낸다
        // 뷰의 경로, forwarding 방식(데이터를 끌어감)
        return "member/list";
    }

}

Dao

MemberDao.java

package kr.or.ddit;

import java.util.List;

import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

// spring 프레임워크가 자바 빈(=객체)으로 등록해서 관리할 수 있도록 어노테이션 달기
@Repository
public class MemberDao {

    //sqlSessionTemplate 타입 객체를 MemberDao 객체에 주입(사용가능하게) 함
    @Autowired
    SqlSessionTemplate sqlSessionTemplate; // root-context 객체에 있는 id와 같아야 함

    //회원가입
    public int insert(MemberVO memberVO) {
        //namespace.id
        //result가 0이면 입력실패, 1이면 입력 성공
        int result = this.sqlSessionTemplate.insert("member.insert", memberVO);

        return result;
    }
    //회원 정보 목록
    public List<MemberVO> select(){
        //namespace.id
        return this.sqlSessionTemplate.selectList("member.select");
    }

}

Service

MemberService.java

package kr.or.ddit;

import java.util.List;
/*
* 스프링은 직접 클래스를 생성하는 것을 지양(안함)하고,
* 인터페이스를 통해 접근하는 것을 권장하는 프레임워크.
*/

public interface MemberService {
    //메소드 시그니처 처리
    //회원가입
    public int insert(MemberVO memberVO);

    //회원정보 목록
    List<MemberVO> select();
}

MemberServiceImpl.java

package kr.or.ddit;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

//spring 프레임 워크가 자바 빈(=객체)으로 등록해서 관리할 수 있도록 어노테이션 달기
@Service
public class MemberServiceImpl implements MemberService {
    //DI(의존성 주입)
    //데이터베이스에 접근을 위해 MemberDao 인스턴스를 주입받음
    @Autowired
    MemberDao memberDao;

    //회원가입
    @Override
    public int insert(MemberVO memberVO) {
        return memberDao.insert(memberVO);
    }

    //회원정보 목록
    @Override
    public List<MemberVO> select(){
        return memberDao.select();
    }
}

View

joinForm.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<!DOCTYPE html>
<html>
<head>
<title>회원가입</title>
</head>
<body>
<!--
스프링 폼 태그 라이브러리 <form:>
    - 스프링 폼은 HTML 폼을 표시하기 위한 태그 라이브러리
    - 스프링 폼을 이용하면 HTML 폼과 자바 객체를 쉽게 바인딩할 수 있음

컨트롤러에서 사용하는 modelAttribute가 정의되어 있어야 아래 modelAttribute가 정의되어 있어야 아래 modelAtrribute="memberVO" 처럼 사용할 수 있음

여기서 path : 폼 팡목에 바인딩되는 폼 객체(Controller에 있음)의 프로퍼티를 지정
-->
<form:form modelAttribute="memberVO" method="post" action="/member/insert">
    <p>
        아이디 : <form:input path="memberid" />
        <font color="red">
            <form:errors path="memberid" />
        </font>
    </p>
    <p>
        이름 : <form:input path="name" />
        <font color="red">
            <form:errors path="name" />
        </font>
    </p>
    <p>
        비밀번호 : <form:password path="password" />
        <font color="red">
            <form:errors path="password" />
        </font>
    </p>
    <p>
        이메일 : <form:input path="email" />
        <font color="red">
            <form:errors path="email" />
        </font>
    </p>
    <p>
        자기소개 :
        <form:textarea path="introduction" rows="6" cols="30" />
    </p>
    <p>
        취미 :
        <form:checkboxes path="hobbyList" items="${hobbyMap}" />
        <!--
            items는 눈에 보여질 대상.
            컨트롤러에서 model.addAttribute("hobbyMap", hobbyMap);로 보낸 것을 el태그로 받음
        -->
    </p>
    <p>
        취미(hobbyArray) :
        <form:checkbox path="hobbyArray" value="안철수" label="안철수" /><br>
        <form:checkbox path="hobbyArray" value="이재명" label="이재명" /><br>
        <form:checkbox path="hobbyArray" value="윤석열" label="윤석열" /><br>
        <form:checkbox path="hobbyArray" value="심상정" label="심상정" /><br>
    </p>
    <p>
        성별 : 
<%--
        방법 두가지
        1)
        <form:radiobuttons path="gender" items="${genderMap}" /> 처럼 사용하거나
        2)
--%>
        <form:radiobutton path="gender" value="Male" label="Male" />
        <form:radiobutton path="gender" value="Female" label="Female" />
        <form:radiobutton path="gender" value="Other" label="Other" />
    </p>

    <form:button name="register">등록</form:button>
</form:form>
</body>
</html>

list.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<title>회원목록</title>
</head>
<body>
<!--
varStatus
*1) count : 1부터 순서적으로 1씩 증가
*2) index : 0부터 순서적으로 1씩 증가
3) current : 현재의 아이템
4) first : 처음 반복되는 것인지 반환
5) last : 마지막 반복인지 반환
6) begin : 시작값
7) end : 끝값
8) step :증가값  
-->
<table border="1">
    <tr>
        <th>번호</th>
        <th>이름</th>
        <th>이메일</th>
        <th>가입일</th>
        <th>보유 카드번호</th>
    </tr>
    <c:forEach var="memberVO" items="${list}" varStatus="stat"> <!-- items는 컨트롤러 model.addAttribute("list", memberVO)의 키값 -->
    <tr>
        <td>${stat.count}</td>
        <td>${memberVO.name}</td>
        <td>${memberVO.email}</td>
        <td>${memberVO.regdate}</td>
        <td>
            <c:forEach var="cardVO" items="${memberVO.cardList}">
                ${cardVO.no}&nbsp;
            </c:forEach>
        </td>
    </tr>
</table>

</body>
</html>

xml

member_SQL.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="member">
    <!--
    기본키는 id, 아닌 컬럼은 result에
    property : vo의 멤버변수명
    column : select문의 컬럼명

    <assciation>은 1:1, <collection>은 1:N
    -->

    <!-- 아래에서 만든 resultMap의 상세 속성 적기-->
    <resultMap type="memberVO" id="memberMap">
        <id property="memberid" column="MEMBERID" />
        <result property="password" column="PASSWORD"/>
        <result property="name" column="NAME"/>
        <result property="email" column="EMAIL"/>
        <result property="regdate" column="REGDATE"/>
        <result property="introduction" column="INTRODUCTION"/>
        <collection property="cardList" resultMap="cardMap">
        </collection>
    </resultMap>    

    <!-- 위 <collection>에서 선언한 resultMap의 상세 속성을 다시 적는다-->
    <!-- type="cardVO"은 mybatisAlias.xml에 추가한 이름과 같게 사용 -->
    <resultMap type="cardVO" id="cardMap">
        <result property="memberid" column="MEMBERID" />
        <result property="no" column="NO" />
        <result property="vaildMonth" column="VALID_MONTH" />
    </resultMap>


    <!-- 회원가입 -->
    <insert id="insert" parameterType="memberVO"> <!-- typeAlias에서 정한 거! -->
        INSERT INTO MEMBER(MEMBERID,PASSWORD,NAME,EMAIL,REGDATE)
        VALUES(#{memberid},#{password},#{name},#{email},SYSDATE)    
    </insert>

    <!-- 회원정보 목록 -->
    <select id="select" resultMap="memberMap">
        SELECT M.MEMBERID, M.PASSWORD, M.NAME, M.EMAIL, M.REGDATE, M.INTRODUCTION
                , C.NO, C.VALID_MONTH, C.MEMBERID
        FROM MEMBER M, CARD C
        WHERE M.MEMBERID = C.MEMBERID
        ORDER BY C.NO DESC
    </select>

</mapper>

mybatisAlias.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 
        [마이바티스]
           스프링에서 "_"를 사용한 컬럼명을 사용 시 테이블 컬럼명에 "_"가 있을 경우 카멜케이스로 읽어줌
        member 테이블 컬럼명이 mem_id일 경우 memId로 사용가능하도록 도와줌
        cart 테이블에 cart_prod -> cartProd
    -->
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true" />
    </settings>

    <!-- 자주 사용하는 타입의 별칭 -->
    <typeAliases>
        <typeAlias type="kr.or.ddit.BookVO" alias="bookVO"/>
        <typeAlias type="kr.or.ddit.MemberVO" alias="memberVO"/>
        <typeAlias type="kr.or.ddit.CardVO" alias="cardVO"/>
    </typeAliases>
</configuration>

MemberVO.java

package kr.or.ddit;

import java.util.Date;

import org.springframework.format.annotation.DateTimeFormat;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

//자바빈 클래스 
//lombok사용해서 아래처럼 편하게 만들 수 있지만 POJO(초기의 순수한 자바)에 위배됨
//@Setter
//@Getter
//@ToString

public class MemberVO {
    private String memberid;
    private String password;
    private String name;
    private String email;
    //pattern : date 넣을 때 요 형식으로 써주세요~
    //@DateTimeFormat(pattern="yyyy/MM/dd")꼭 써줘야 date형식으로 들어간다
    @DateTimeFormat(pattern="yyyy/MM/dd")
    private Date regdate;

    //기본 생성자
    public MemberVO() {
        super();
        // TODO Auto-generated constructor stub
    }

    //파라미터 던져주면 멤버변수에 자동으로 세팅된다
    public MemberVO(String memberid, String password, String name, String email, Date regdate) {
        super();
        this.memberid = memberid;
        this.password = password;
        this.name = name;
        this.email = email;
        this.regdate = regdate;
    }

    public String getMemberid() {
        return memberid;
    }
    public void setMemberid(String memberid) {
        this.memberid = memberid;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public Date getRegdate() {
        return regdate;
    }
    public void setRegdate(Date regdate) {
        this.regdate = regdate;
    }

    //비밀번호 변경 기능 구현 시 사용
    public boolean matchPassword(String pwd) {
        return password.contentEquals(pwd);
    }


    @Override
    public String toString() {
        return "MemberVO [memberid=" + memberid + ", password=" + password + ", name=" + name + ", email=" + email
                + ", regdate=" + regdate + "]";
    }

}

Controller

MemberController.java

package kr.or.ddit;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

//spring 프레임워크가 자바 빈(=객체)으로 등록해서 관리할 수 있도록 어노테이션 달기
@Controller
public class MemberController {

    @RequestMapping("/member/insert")
    public String insert(Model model) {

        model.addAttribute("memberVO", new MemberVO());

        return "member/joinForm";
        //model은 jsp를 return, ModelAndView는 ModelAndView 객체를 리턴 
    }
}

Dao

MemberDao.java

package kr.or.ddit;

import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

//spring 프레임워크가 자바 빈(=객체)으로 등록해서 관리할 수 있도록 어노테이션 달기
@Repository
public class MemberDao {

    //sqlSessionTemplate 타입 객체를 BookDao 객체에 주입(사용가능하게) 함
    @Autowired
    SqlSessionTemplate sqlSessionTemplate; //root-context 객체에 있는 id와 같아야 함

    //회원가입
    public int insert(MemberVO memberVO) {
        //namaspace.id
        //result가 0이면 입력 실패, 1이면 입력 성공
        int result = this.sqlSessionTemplate.insert("member.insert", memberVO);

        return result;
    }
}

Service

MemberService.java

package kr.or.ddit;

/*
* 스프링은 직접 클래스를 생성하는 것을 지양(안함)하고,
* 인터페이스를 통해 접근하는 것을 권장하는 프레임워크.
*/

public interface MemberService {
    //회원가입
    public int insert(MemberVO memberVO);

}

MemberServiceImpl.java

package kr.or.ddit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


//spring 프레임워크가 자바 빈(=객체)으로 등록해서 관리할 수 있도록 어노테이션 달기
@Service
public class MemberServiceImpl implements MemberService {
    //DI(의존성 주입)
    //데이터베이스에 접근을 위해  MemberDao 인스턴스를 주입받음
    @Autowired
    MemberDao memberDao;

    //회원가입
    @Override
    public int insert(MemberVO memberVO) {
        return memberDao.insert(memberVO);
    }

}

JSP

스프링 폼 태그 라이브러리

• 스프링 폼은 HTML 폼을 표시하기 위한 태그 라이브러리
• 스프링 폼을 이용하면 HTML 폼과 자바 객체를 쉽게 바인딩할 수 있음

  form 태그 라이브러리 추가하기 <%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>

joinForm.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<!DOCTYPE html>
<html>
<head>
<title>회원가입</title>
</head>
<body>
<!-- 
스프링 폼 태그 라이브러리
 - 스프링 폼은 HTML 폼을 표시하기 위한 태그 라이브러리
 - 스프링 폼을 이용하면 HTML 폼과 자바 객체를 쉽게 바인딩할 수 있음
-->
<form:form modelAttribute="memberVO" method="post" action="/member/insert">
    <p>
        아이디 : <form:input path="memberid" />
        <font color="red">
            <form:errors path="memberid" />
        </font>
    </p>
    <p>
        이름 : <form:input path="name" />
        <font color="red">
            <form:errors path="name" />
        </font>
    </p>
    <p>
        비밀번호 : <form:input path="password" />
        <font color="red">
            <form:errors path="password" />
        </font>
    </p>
    <p>
        이메일 : <form:input path="email" />
        <font color="red">
            <form:errors path="email" />
        </font>
    </p>
    <form:button name="register">등록</form:button>
</form:form>
</body>
</html>

xml

member_SQL.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="member">
    <!-- 회원가입 -->
    <insert id="insert" parameterType="memberVO"> <!-- typeAlias에서 정한거 -->
        INSERT INTO MEMBER(MEMBERID,PASSWORD,NAME,EMAIL,REGDATE)
        VALUES(#{memberid},#{password},#{name},#{email},SYSDATE)
    </insert>
</mapper>

서비스는 인터페이스. 스프링은 껍데기인 인터페이스를 Implement한 serviceImpl을 사용해서 현실화함

왜 인터페이스를 거쳐서 jsp->service->serviceImpl로 가야하는지? -> 컨트롤러에서 ServiceImpl을 쓸 때, Service interface를 @autowired함 -> 스프링은 interface를 거쳐서 요청을 세분화하기 때문(확장의 여지를 남겨놓는다)

VO

BookVO.java

package kr.or.ddit;

public class BookVO {
    private int bookId;
    private String title;
    private String category;
    private int price;
    private String insertDate;

    public int getBookId() {
        return bookId;
    }
    public void setBookId(int bookId) {
        this.bookId = bookId;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getCategory() {
        return category;
    }
    public void setCategory(String category) {
        this.category = category;
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    public String getInsertDate() {
        return insertDate;
    }
    public void setInsertDate(String insertDate) {
        this.insertDate = insertDate;
    }

    @Override
    public String toString() {
        return "BookVO [bookId=" + bookId + ", title=" + title + ", category=" + category + ", price=" + price
                + ", insertDate=" + insertDate + "]";
    }


}

Controller

BookController.java

package kr.or.ddit;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;

//컨트롤러 어노테이션(Annotation)
//어노테이션이 있는 클래스
//스프링프레임워크(디자인패턴 + 라이브러리 집합)가 웹 브라우저(크롬)의 요청(request)을 받아들이는 컨트롤러라고 인지해서
//자바 빈(java Bean)으로 등록해서 관리

@Controller
public class BookController {
    private static final Logger logger = LoggerFactory.getLogger(BookController.class);
    @Autowired
    BookService bookService;
    //Model : 컨트롤러가 반환할 데이터(VO객체, List, List<VO>, Map, List<Map>, JSON)를 담당
    //            반환? 1)forward(데이터 담기 O)    2) redirect(데이터 담기 X)

    //View : 화면 담당
    //localhost:5090/create

    //요청을 매핑한다
    @RequestMapping(value="/create", method=RequestMethod.GET)
    public ModelAndView create() {
        ModelAndView mav = new ModelAndView();
        //원래는 localhost:8090/WEB-INF/view/book/create.jsp

        //servlet-context.xml에서...
        //prefix : /WEB-INF/views/
        mav.setViewName("book/create");
        //suffix : .jsp
        return mav;
    }

    //HTTP파라미터 : 웹 브라우저(크롬)에서 서버(톰캣)로 전달하는 데이터
    //                제목, 분류, 가격.. 등이 파라미터로 넘어옴
    //?title=톰소여의모험&category=소설&price=10000
    //스프링은 HTTP파라미터를 자바 메소드의 파라미터로 변환해서 컨트롤러 메소드를 호출해줌
    //map으로 받을 때에는 RequestParam 어노테이션
    //{"title":"톰소여의 모험","category":"소설"...}
    //vo로 받을때에는 ModelAtrribute 어노테이션
    @RequestMapping(value="/create", method=RequestMethod.POST)
    public ModelAndView createPost(ModelAndView mav,
            @RequestParam Map<String, Object>map) { //@RequestParam 요청 파라미터를 받아주는 어노테이션
        logger.info("map : " + map.toString());

        BookVO bookVO = new BookVO();
        //result : insert된 book_id의 값(p.k)
        int result = bookService.insert(mapToVO(map));
        logger.info("result : " + result);

        if(result==0) { //insert가 안됨 -> 책 입력 화면으로 돌아가라
            //데이터를 담지 않고 단순히 되돌아감.. --> forward아닌 redirect!
            mav.setViewName("redirect:/create");
        }else { //insert 성공 -> 상세 페이지를 요청
            //?bookId=1 <-- 쿼리스트링 or 파라미터 목록
            mav.setViewName("redirect:/detail?bookId="+result);
        }

        return mav;
    }

    //20220127숙제
    //map -> BookVO로 변환(public BookVO mapToVo(map)..메서드로 처리)
    public BookVO mapToVO(Map<String, Object>map) {
        BookVO bookVO = new BookVO();
        //bookVO.setTitle(map.get("title")); map에서 title뽑아내면 Object형이기 때문에 에러(나머지도 마찬가지!)
        bookVO.setTitle((String)map.get("title"));//형변환
        bookVO.setCategory((String)map.get("category"));
        bookVO.setPrice(Integer.parseInt((String)map.get("price")));
        return bookVO;
    }

    //book 상세보기
    //파라미터 목록(쿼리스트링) : bookId=1
    //{bookId,1}
    @RequestMapping(value="detail", method=RequestMethod.GET)
    public ModelAndView detail(@RequestParam Map<String,Object> map) {
        logger.info("map : " + map);

        BookVO bookVO = new BookVO();
        bookVO.setBookId(Integer.parseInt((String)map.get("bookId")));
        //{bookID:1,나머지는 null}
        logger.info("bookVO(before) : " + bookVO.toString());

        //상세보기 데이터 가져오기
        bookVO = this.bookService.detail(bookVO);

        //{bookId:1,나머지도 있음}
        logger.info("bookVO(after) : " + bookVO.toString());

        ModelAndView mav = new ModelAndView();
        //book/detail : 뷰의 경로
        //forwarding
        mav.addObject("data", bookVO); //데이터를 담음
        mav.setViewName("book/detail");

        return mav;
    }
    // /update?bookId=3
    // 쿼리스트링 : bookId=3
    // map : {bookId:3}
    // 책 수정화면 = 책 입력화면(jsp) + 책 상세 서비스 로직
    @RequestMapping(value = "/update", method=RequestMethod.GET)
    public ModelAndView update(@RequestParam Map<String, String> map) {
        logger.info("map : " + map.get("bookId"));

        //책 상세 서비스 로직 사용
        BookVO bookVO = new BookVO();
        bookVO.setBookId(Integer.parseInt(map.get("bookId")));
        bookVO = this.bookService.detail(bookVO);

        ModelAndView mav = new ModelAndView();
        //request.setAttribute("data", bookVO);
        mav.addObject("data", bookVO);
        //forwarding : setViewName()로 페이지 이동값 세팅
        mav.setViewName("book/update");

        return mav;
    }

    //책 수정 post
    @RequestMapping(value="/update", method=RequestMethod.POST)
    public ModelAndView updatePost(@ModelAttribute BookVO bookVO, ModelAndView mav) {
        logger.info("bookVO : " + bookVO.toString());
        //true : update성공, false : update실패
        boolean isUpdateSuccess = this.bookService.update(bookVO);

        if(isUpdateSuccess) { //성공
            //상세페이지로 이동
            mav.setViewName("redirect:/detail?bookId="+bookVO.getBookId());
        }else {//실패
            //책 수정화면으로 돌아가기
            //방법1)
            //mav.setViewName("redirect:/update?bookId="+bookVO.getBookId());
            //방법2)
            Map<String,String> map = new HashMap<String, String>();
            map.put("bookID", "" + bookVO.getBookId());
            mav = this.update(map);
        }
        return mav;
    }
    //책 목록 리스트 + 검색 기능 추가
    //http://localhost:8090/list?keyword=야호
    //map : {"keyword":"야호"} 이렇게 들어간다~
    @RequestMapping(value="/list", method=RequestMethod.GET)
    //public ModelAndView allList(ModelAndView mav, @RequestParam String keyword) { //방법 1. 야호를  String 매개변수로 받음
    public ModelAndView allList(ModelAndView mav, @RequestParam Map<String, Object> map) {//방법2. value를 Object로 해서 모든 형태의 데이터를 받을 수 있게 함
    //ModelAndView mav = new ModelAndView로 객체 생성안해도 파라미터에 ModelAndView mav 넣으면 만들어짐
        List<BookVO> allList = this.bookService.allList(map);
        //데이터를 VIEW(jsp)에 전달할 수 있도록 mav 객체에 add함
        mav.addObject("data",allList);
        //forwarding
        mav.setViewName("book/list"); //조립하기, servlet-context의 prefix에 /WEB-INF/views/ 마지막에 /붙으므로 book앞에 /안넣어도 됨
        return mav;
    }
    // <form method="post" action="/delete">
    //<input type="hidden" name="bookId" value="${data.bookId}" />
    @RequestMapping(value = "/delete", method = RequestMethod.POST)
    public ModelAndView deletePost(@RequestParam Map<String,Object> map, ModelAndView mav) {
        //map : {bookId=3} 처럼 키와 값으로 구성되어 있음
        boolean isDeleteSuccess = this.bookService.delete(map);

        if(isDeleteSuccess) { //성공
            //목록 화면으로  redirect(요청흐름을 이동시킴. 단, 데이터는 이동 못함)
            mav.setViewName("redirect:/list");
        }else { //실패
            //상세 화면으로 redirect
            mav.setViewName("redirect:/detail?bookId="+map.get("bookId").toString());
        }
        return mav;
    }

    //주문하면 아래 메서드로 매핑
    @RequestMapping(value="/make", method=RequestMethod.GET)
    public ModelAndView make() {
        //라이더에 태워서 짬뽕 배송
        ModelAndView mav = new ModelAndView();
        //짬뽕 위치 알려주기
        mav.setViewName("book/make");
        //배송하기
        return mav;
    }
    //RequestMapping 어노테이션 : 웹 브라우저의 요청에 실행되는 자바 메소드를 지정해줌
    //method : 속성. http 요청 메소드를 의미함
    //            1) GET : 데이터를 변경하지 않는 경우 사용
    //            2) POST : 데이터가 변경될 경우 사용
    //웹 브라우저에 화면을 보여줄 뿐 데이터의 변경이 일어나지 않으므로 GET 메소드를 사용한 것임
    //jjajang() 메소드는 웹 브라우저에서 /jjajang 주소가 GET 방식으로 입력되었을 때 book/jjajang 경로의 뷰를 보여줌

    @RequestMapping(value="/jjajang", method=RequestMethod.GET)
    public ModelAndView jjajang(ModelAndView mav) { //라이더 생성
        // book/jjajang : 뷰의 경로
        mav.setViewName("book/jjajang");
        return mav;
    }
}

Dao

BookDao.java

package kr.or.ddit;

import java.util.List;
import java.util.Map;

import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

//매퍼 xml을 실행해주는 클래스.
//@Repository 어노테이션을 붙여서 이 클래스는 데이터에 접근하는 클래스라는 것을
//Spring에게 알려줌
//Spring이 데이터를 관리하는 클래스라고 인지해서 자바 빈(java bean)으로 등록해서 관리
@Repository
public class BookDao {
    //sqlSessionTemplate 사용
    /*
     * new 키워드를 통해 직접 생성 안함.
     * 의존성 주입(Dependency Injection - DI)을 통해 주입받음.
     * 스프링은 미리 만들어놓은 sqlSessionTemplate 타입 객체를 BookDao 객체에 주입
     * 이 과정은 자동으로 스프링에서 실행되며, 개발자가 직접 객체를 생성하지 않음(Inversion of Control - IoC) 
     */

    @Autowired
    SqlSessionTemplate sqlSessionTemplate;

    public int insert(BookVO bookVO) {
        //book_SQL.xml파일에서
        //namespace="book"
        //id="insert"
        //book.inert : 매퍼 쿼리 명
        //bookVO : 두번째 인수.. 쿼리에 전달할 데이터(String, int, VO, Map 등이 올 수 있음)
        return this.sqlSessionTemplate.insert("book.insert",bookVO);
    }

    //책 상세보기
    public BookVO detail(BookVO bookVO) {
        //.selectOne 메소드 : 1행을 가져올 때 사용
        //결과 행 수가 0이면 null반환
        //결과 행 수가 2 이상일 때 TooManyResultxException 예외 발생
        //(namespace.id, 파라미터0)
        return sqlSessionTemplate.selectOne("book.detail",bookVO);
    }

    //책 수정하기
    public boolean update(BookVO bookVO) {
        //(namespace.id, 파라미터)
        //update 후에 영향받은 행의 수를 받음
        int result = this.sqlSessionTemplate.update("book.update",bookVO);
        //0보다 크다는 것은 update가 성공했다는 의미
        return result > 0;
    }
    //책 목록
    //map : {"keyword":"야호"}
    public List<BookVO> allList(Map<String, Object> map){
        //.selectList() 메소드는 결과 집합의 목록을 반환
        // List 타입으로 읽어들일 수 있음
        return this.sqlSessionTemplate.selectList("book.allList", map); 
    }

    //책 삭제하기
    public boolean delete(Map<String,Object> map) {
        //RDBMS(Relational DataBase Manegement System)에서 (테이블을 relation이라고도 함!)
        //delete 구문은 update 구문처럼 where 조건에 일치하는
        //모든 행을 삭제하므로 영향을 받은 행의 수는 0 혹은 1 이상이 됨
        int result = this.sqlSessionTemplate.delete("book.delete", map);
        //result > 0는 삭제가 잘 되었다는 의미..
        return result > 0;
    }
}

Service

BookService.java

package kr.or.ddit;

import java.util.List;
import java.util.Map;

/*
 * 서비스 클래스는 비즈니스 클래스(기능)가 위치하는 곳임.
 * 스프링 MVC 구조에서 Controller - Service - DAO
 * 컨트롤러와 DAO를 연결하는 역할도 함
 * 
 * 스프링은 직접 클래스를 생성하는 것을 지양(안함)하고,
 * 인터페이스를 통해 접근하는 것을 권장하는 프레임워크.
 */
public interface BookService {
    //메소드 시그니쳐 처리
    //book 테이블로 insert
    public int insert(BookVO bookVO);
    //book 상세보기
    BookVO detail(BookVO bookVO);
    //book 수정하기
    boolean update(BookVO bookVO);
    //book 목록보기
    public List<BookVO> allList(Map<String, Object> map);
    //책 삭제하기
    boolean delete(Map<String, Object> map);
}

BookServiceImpl.java

package kr.or.ddit;

import java.util.List;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

//@Service : 어노테이션.. 스프링에게 이 클래스는 서비스 클래스임을 알려줌
//스프링이 자바 빈(java bean)으로 등록하여 관리
@Service
public class BookServiceImpl implements BookService {
    private static final Logger logger = LoggerFactory.getLogger(BookServiceImpl.class);
    //이미 자바빈으로 관리되고 있는 BookDao 객체를 @Autowired로 가져다 쓴다
    //IoC(제어의 역전) : 객체의 생성주기를 개발자가 하는 것이 아니라 스프링 프레임워크가 알아서 함
    //DI(의존성 주입)
    @Autowired
    BookDao bookDao;

    //부모 객체의 메소드를 재정의
    @Override
    public int insert(BookVO bookVO) {
        logger.info("bookVO : " + bookVO.toString());
        int affectRowcount = this.bookDao.insert(bookVO); //인서트된 행의 수를 int로 받음

        if(affectRowcount == 1) { //입력이 성공
            //xml에서 selectkey에서 세팅된 그 값(max(book_id)+1)
            return bookVO.getBookId();
        }
        //입력 실패
        return 0;
    }
    //책 상세보기
    @Override
    public BookVO detail(BookVO bookVO) {
        return this.bookDao.detail(bookVO);
    }

    //책 수정하기
    @Override
    public boolean update(BookVO bookVO) {
        return this.bookDao.update(bookVO);
    }

    //책 목록
    @Override
    public List<BookVO> allList(Map<String, Object> map) {
        return this.bookDao.allList(map);
    }

    //책 삭제하기
    @Override
    public boolean delete(Map<String,Object> map) {
        return this.bookDao.delete(map);
    }

}

JSP

create.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<title>책 생성하기</title>
</head>
<body>
    <h1>책 생성하기</h1>
    <form method="post" action="/create">
        <p>제목 : <input type="text" name="title"></p>
        <p>카테고리 : <input type="text" name="category"></p>
        <p>가격 : <input type="text" name="price"></p>
        <p><input type="submit" value="저장"></p>

    </form>
</body>
</html>

detail.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!-- 
BookController에서 mav 객체에 data라는 이름으로 select검색 결과를 넣었으므로
    mav.addObject("data",bookVO)
달러{data.title} 형식으로 사용하면 됨
 -->
<!DOCTYPE html>
<html>
<head>
<title>책 상세</title>
</head>
<body>
<h1>책 상세</h1>
<p>제목 : ${data.title}</p>
<p>카테고리 : ${data.category}</p>
<p>가격 : ${data.price}</p>
<p>입력일 : ${data.insertDate}</p>
<p><a href="/update?bookId=${data.bookId}">수정</a></p>
<p><a href="/list">목록으로</a></p>
<form method="post" action="/delete">
    <input type="hidden" name="bookId" value="${data.bookId}" />
    <input type="submit" value="삭제"/>
</form>
</body>
</html>

update.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!-- 
BookController에서 mav 객체에 data라는 이름으로 select검색 결과를 넣었으므로
    mav.addObject("data",bookVO)
달러{data.title} 형식으로 사용하면 됨
 -->
<!DOCTYPE html>
<html>
<head>
<title>책 수정하기</title>
</head>
<body>
<h1>책 수정</h1>
<!-- action이 없으면../update를 요청 단, method는 post -->
<form method="post">
    <input type="hidden" name="bookId" value="${data.bookId}" />
    <p>제목 : <input type="text" name="title" value="${data.title}" required /></p>
    <p>카테고리 : <input type="text" name="category" value="${data.category}" required /></p>
    <p>가격 : <input type="text" name="price" value="${data.price}" /></p>
    <p><input type="submit" value="저장" />&nbsp;
    <input type="button" value="취소" onclick="javascript:location.href='/detail?bookId=${data.bookId}'"/></p>
</form>
</body>
</html>

list.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 

<!DOCTYPE html>
<html>
<head>
<title>책 목록</title>
<script type="text/javascript">
function fn_create(){
    location.href="/create";
}

</script>
</head>
<body>
<h1>책 목록</h1>
<p>
    <!--
        form 태그의 기본 HTTP 메소드는 GET
        action 속성을 생략하면 현재 url(/list)을 요청 
     -->
     <!-- <form method="get" action="/list"> -->
    <form>
        <input type="text" name="keyword" value="${param.keyword}" />
        <input type="submit" value="검색" />
    </form>
</p>
<table border="1">
    <thead>
        <tr>
            <th>제목</th>
            <th>카테고리</th>
            <th>가격</th>
        </tr>
    </thead>
    <tbody>
    <!-- data 객체의 타입 : List<BookVO> -->
    <c:forEach var="list" items="${data}">
        <tr>
            <td><a href="/detail?bookId=${list.bookId}">${list.title}</a></td>
            <td>${list.category}</td>
            <td>${list.price}</td>
        </tr>    
</c:forEach>    
    </tbody>
</table>
<br>
<input type="button" value="책 입력" onclick="fn_create();" />
</body>
</html>

xml

book_SQL.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="book">
    <!-- * selectKey? 
    일련번호 처리시 많이 사용
    마이바티스는 쿼리 실행 시 파라미터를 치환해줌
    selectKey 전 : {"title":"검은태양","category":"드라마","price":10000}
    selectKey 후 : {"bookId":1, "title":"검은태양","category":"드라마","price":10000}

    -->
    <insert id="insert" parameterType="kr.or.ddit.BookVO">
        <!-- 중요!! -->
        <selectKey order="BEFORE" keyProperty="bookId" resultType="integer">
            SELECT NVL(MAX(BOOK_ID),0)+1 FROM BOOK
        </selectKey>
        INSERT INTO BOOK(BOOK_ID,TITLE,CATEGORY,PRICE,INSERT_DATE)
        VALUES(#{bookId},#{title},#{category},#{price},SYSDATE)
    </insert>

    <!-- 책 상세보기 -->
    <!-- 1:다 관계가 있다면  resultType을 사용하자-->
    <select id="detail" parameterType="bookVO" resultType="bookVO">
        SELECT BOOK_ID,TITLE,CATEGORY,PRICE,INSERT_DATE
        FROM BOOK
        WHERE BOOK_ID = #{bookId}
    </select>

    <!-- 책 수정하기, update태그는 UPDATE 쿼리를 실행하기 위한 마이바티스 태그 -->
    <update id="update" parameterType="bookVO">
        UPDATE  BOOK
        SET     TITLE = #{title}, CATEGORY = #{category}, PRICE = #{price}
        WHERE   BOOK_ID = #{bookId}
    </update>

    <!-- 책 목록보기 -->
    <!-- 
        map : {keyword=야호} 로 들어오면
        아래 쿼리의 keyword가 야호로 교체됨

        WHERE 1 = 1은 관습적인 구문. 1 = 1은 항상 TRUE이고 
        - 조건이 2개 이상일 경우 처음 시작하는 조건은 WHERE로 시작하고 두번째로 시작하는 조건은 AND 여야 함
        - 매번 첫번째 조건인지 검사하는 것은 번거롭기 때문에 무조건 WHERE 1 = 1을 써둔 후 나머지 조건을 AND로 이어붙임
        - 동적쿼리(<if test~~~) : 쿼리의 내용이 파라미터가 아니라 마이바티스의 규칙에 의해 변경되는 것
     -->
    <select id="allList" parameterType="hashMap" resultType="bookVO">
        SELECT BOOK_ID,TITLE,CATEGORY,PRICE,INSERT_DATE
        FROM BOOK
        WHERE 1 = 1
        <if test="keyword!=null and keyword!=''">
            AND (TITLE      LIKE '%' || #{keyword} || '%' OR
                 CATEGORY LIKE '%' || #{keyword} || '%')
        </if>
        ORDER BY BOOK_ID DESC
    </select>

    <!-- 책 삭제, detail.jsp에서 작성한 name="bookId" -->
    <delete id="delete" parameterType="hashMap">
            DELETE FROM BOOK
            WHERE BOOK_ID = #{bookId}
    </delete>
</mapper>

DI -> 이미 써봣음! (서비스에서 Dao가져다쓸때, 컨트롤러에서 service가져다 쓸 때) 서비스에서 Dao dao = Dao.getInstance(); 만들어서 Dao 객체 썼었음(상속 안받고도!)

스프링에서는 Dao 위에 @Autowired쓰면 끝

Controller 어노테이션(Annotation)

• 어노테이션이 있는 클래스
• 스프링 프레임워크(디자인패턴 + 라이브러리 집합)가 웹 브라우저(크롬)의 요청(request)을 받아들이는 컨트롤러라고 인지해서 자바 빈(java Bean)으로 등록해서 관리

Model : 컨트롤러가 반환할 데이터(VO객체, List, List<VO>, Map, List<Map>, JSON)를 담당

반환?

1) forward(데이터 담기 O) 2) redirect(데이터 담기 X)

View : 화면 담당 ex) localhost:8090/create

RequestMapping 어노테이션

• 웹 브라우저의 요청에 의해 실행되는 자바 메소드를 지정해 줌
• method* : 속성. http 요청 메소드를 의미함 1) GET : 데이터를 변경하지 않는 경우 사용 2) POST : 데이터가 변경될 경우 사용
• 웹 브라우저에 화면을 보여줄 뿐 데이터의 변경이 일어나지 않으므로 GET 메소드를 사용한 것

BookController.java

package kr.or.ddit;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

//컨트롤러 어노테이션(Annotation)
//어노테이션이 있는 클래스
//스프링프레임워크(디자인패턴 + 라이브러리 집합)가 웹 브라우저(크롬)의 요청(request)을 받아들이는 컨트롤러라고 인지해서
//자바 빈(java Bean)으로 등록해서 관리

@Controller
public class BookController {
    //Model : 컨트롤러가 반환할 데이터(VO객체, List, List<VO>, Map, List<Map>, JSON)를 담당
    //            반환? 1)forward(데이터 담기 O)    2) redirect(데이터 담기 X)

    //View : 화면 담당
    //localhost:8090/create

    //요청을 매핑한다
    @RequestMapping(value="/create", method=RequestMethod.GET)
    public ModelAndView create() {
        ModelAndView mav = new ModelAndView();
        //원래는 localhost:8090/WEB-INF/view/book/create.jsp

        //servlet-context.xml에서...
        //prefix : /WEB-INF/views/
        mav.setViewName("/book/create");
        //suffix : .jsp
        return mav;
    }
    //주문하면 아래 메서드로 매핑
    @RequestMapping(value="/make", method=RequestMethod.GET)
    public ModelAndView make() {
        //라이더에 태워서 짬뽕 배송
        ModelAndView mav = new ModelAndView();
        //짬뽕 위치 알려주기
        mav.setViewName("book/make");
        //배송하기
        return mav;
    }
    //RequestMapping 어노테이션 : 웹 브라우저의 요청에 실행되는 자바 메소드를 지정해줌
    //method : 속성. http 요청 메소드를 의미함
    //            1) GET : 데이터를 변경하지 않는 경우 사용
    //            2) POST : 데이터가 변경될 경우 사용
    //웹 브라우저에 화면을 보여줄 뿐 데이터의 변경이 일어나지 않으므로 GET 메소드를 사용한 것임
    //jjajang() 메소드는 웹 브라우저에서 /jjajang 주소가 GET 방식으로 입력되었을 때 book/jjajang 경로의 뷰를 보여줌

    @RequestMapping(value="/jjajang", method=RequestMethod.GET)
    public ModelAndView jjajang(ModelAndView mav) { //라이더 생성
        // book/jjajang : 뷰의 경로
        mav.setViewName("book/jjajang");
        return mav;
    }
}

MyBatis란?

xml로 쿼리를 작성하게 해주는 라이브러리

설정 순서

1. https://mvnrepository.com/ -> mybatis 검색 -> 클릭 -> org.mybatis » mybatis » 3.5.9 -> 중간에 있는 코드 복사 -> pom.xml에 붙여넣으면 C:\Users\PC-12.m2\repository\org\mybatis\mybatis\3.5.9 로 조립된다

2. mybatis-spring(둘을 연결해주는 라이브러리) 검색 -> 2.0.6 클릭 -> 중간에 있는 코드 복사

-> pom.xml에 붙여넣으면 C:\Users\PC-12.m2\repository\org\mybatis\mybatis-spring\2.0.6로 조립된다

스프링에서 jdbc를 사용하려면? spring-jdbc 검색 - spring과 같은 버전인 5.2.5 클릭 - 중간 코드 복사 - pom.xml 붙여넣기 후 <version>${org.springframework-version}</version> 으로 수정하기

DBCP 다운 commons-dbcp2 검색 - 2.9.0 클릭 - 중간 코드 복사 - pom.xml 붙여넣기

log4j 다운 log4jdbc-log4j2-jdbc4 검색 - 1.16 클릭 - 중간 코드 복사 - pom.xml 붙여넣기

ojdbc6 다운 ojdbc6 검색 - 11.2.04 클릭 - 중간 코드 복사 - pom.xml 붙여넣기

lombok 다운 lombok 검색 - 1.18.22 클릭 - 중간 코드 복사 - pom.xml 붙여넣기

서버 중지 console 클리어 후 프로젝트 우클릭 run as -> 4번 maven 클릭 -> 창 안뜨고 BUILD SUCCESS 나오면 성공!

3. root-context.xml 수정

• root-context.xml : 스프링 설정 파일
• view와 관련되지 않은 객체를 정의(찐 스프링 설정)
• Service(기능, 비즈니스 로직), DAO(Repository), DB등 비즈니스 로직과 관련된 설정

root-context.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- Root Context: defines shared resources visible to all other web components -->

    <!-- 
        root-context.xml : 스프링 설정 파일

        view와 관련되지 않은 객체를 정의(찐 스프링 설정)
        Service(기능, 비즈니스 로직), DAO(Repository), DB등 비즈니스 로직과 관련된 설정
    -->
    <!-- dataSource? 데이터베이스와 관련된 정보를 세팅 -->
    <bean id="dataSource"
        class="org.apache.commons.dbcp2.BasicDataSource"
        destroy-method="close">
        <property name="driverClassName" 
        value="oracle.jdbc.driver.OracleDriver" />
        <property name="url" 
        value="jdbc:oracle:thin:@localhost:1521:xe" />
        <property name="username" value="jspexam" />
        <property name="password" value="java" />
    </bean>
    <!-- 
    sqlSessionFactory는 데이터베이스와 연결을 맺고 끊어질 때까지의 
    라이프 사이클을 관리하는 sqlSession 객체를 만듦
     -->
    <bean id="sqlSessionFactory"
    class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 데이터소스를 설정 -->
        <property name="dataSource" ref="dataSource" />
        <!-- 매퍼 xml 파일의 위치.  -->
        <property name="mapperLocations"
        value="classpath:/sqlmap/**/*_SQL.xml" />
        <property name="configLocation"
        value="/WEB-INF/mybatisAlias/mybatisAlias.xml" />
    </bean>
    <!--
    데이터베이스에 개별적으로 쿼리를 실행시키는 객체. 우리는 소스코드에서 이 객체를 사용하여 Query를 실행시킴*** 
    -->
    <bean id="sqlSessionTemplate"
    class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory" />
    </bean>
</beans>

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>kr.or</groupId>
    <artifactId>ddit</artifactId>
    <name>springProj</name>
    <packaging>war</packaging>
    <version>1.0.0-BUILD-SNAPSHOT</version>
    <properties>
        <java-version>1.8</java-version>
        <org.springframework-version>5.2.5.RELEASE</org.springframework-version>
        <org.aspectj-version>1.6.10</org.aspectj-version>
        <org.slf4j-version>1.6.6</org.slf4j-version>
    </properties>
    <dependencies>
        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${org.springframework-version}</version>
            <exclusions>
                <!-- Exclude Commons Logging in favor of SLF4j -->
                <exclusion>
                    <groupId>commons-logging</groupId>
                    <artifactId>commons-logging</artifactId>
                 </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${org.springframework-version}</version>
        </dependency>

        <!-- AspectJ -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>${org.aspectj-version}</version>
        </dependency>    

        <!-- Logging -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${org.slf4j-version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>${org.slf4j-version}</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${org.slf4j-version}</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.15</version>
            <exclusions>
                <exclusion>
                    <groupId>javax.mail</groupId>
                    <artifactId>mail</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>javax.jms</groupId>
                    <artifactId>jms</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>com.sun.jdmk</groupId>
                    <artifactId>jmxtools</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>com.sun.jmx</groupId>
                    <artifactId>jmxri</artifactId>
                </exclusion>
            </exclusions>
            <scope>runtime</scope>
        </dependency>

        <!-- @Inject -->
        <dependency>
            <groupId>javax.inject</groupId>
            <artifactId>javax.inject</artifactId>
            <version>1</version>
        </dependency>

        <!-- Servlet -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <!-- Test -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.7</version>
            <scope>test</scope>
        </dependency>

        <!-- Database 라이브러리 시작 -->
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <!-- XML로 쿼리를 작성하게 해주는 라이브러리 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.9</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
        <!-- 스프링과 mybatis를 연동하게 해주는 라이브러리 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${org.springframework-version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-dbcp2 -->
        <!-- 데이터베이스 커넥션 풀. 커넥션을 미리 여러개 만들어 놓고, 빌려썼다가 사용이 끝나면 반납. -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
            <version>2.9.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.bgee.log4jdbc-log4j2/log4jdbc-log4j2-jdbc4 -->
        <!-- Logging을 위한 라이브러리. Query를 console이나 파일 로그로 볼 수 있음 -->
        <dependency>
            <groupId>org.bgee.log4jdbc-log4j2</groupId>
            <artifactId>log4jdbc-log4j2-jdbc4</artifactId>
            <version>1.16</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.oracle.database.jdbc/ojdbc6 -->
        <dependency>
            <groupId>com.oracle.database.jdbc</groupId>
            <artifactId>ojdbc6</artifactId>
            <version>11.2.0.4</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <!-- 
            * 자바빈 클래스인 VO에서 Getter/Setter메서드, toString()메서드를 자동 생성
            LoggerFactory 사용 가능
         -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
            <scope>provided</scope>
        </dependency>
        <!-- Database 라이브러리 끝 -->
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <artifactId>maven-eclipse-plugin</artifactId>
                <version>2.9</version>
                <configuration>
                    <additionalProjectnatures>
                        <projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>
                    </additionalProjectnatures>
                    <additionalBuildcommands>
                        <buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>
                    </additionalBuildcommands>
                    <downloadSources>true</downloadSources>
                    <downloadJavadocs>true</downloadJavadocs>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.5.1</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                    <compilerArgument>-Xlint:all</compilerArgument>
                    <showWarnings>true</showWarnings>
                    <showDeprecation>true</showDeprecation>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>1.2.1</version>
                <configuration>
                    <mainClass>org.test.int1.Main</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

sevlet-context.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/mvc"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:beans="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- DispatcherServlet Context: defines this servlet's request-processing infrastructure -->

    <!-- Enables the Spring MVC @Controller programming model -->
    <annotation-driven />

    <!-- Handles HTTP GET requests for /resources/** by efficiently serving up static resources in the ${webappRoot}/resources directory -->
    <!-- 정적 폴더  -> images, js, css와 같은 폴더들이 resources 밑에 들어감-->
    <resources mapping="/resources/**" location="/resources/" />
    <!-- 컨트롤러에서 return되는 string값(파일명) 앞 뒤로 조립되는 값 -->
    <!-- Resolves views selected for rendering by @Controllers to .jsp resources in the /WEB-INF/views directory -->
    <!--  prefix는 앞, suffix는 뒤에 붙는다 (ViewResolver가 조립해준다)-->
    <beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <beans:property name="prefix" value="/WEB-INF/views/" />
        <beans:property name="suffix" value=".jsp" />
    </beans:bean>

    <context:component-scan base-package="kr.or.ddit" />



</beans:beans>

1. 이클립스 STS 플러그인

• 현재 자바 버전은 15까지 나온 상태이지만, 주로 8버전(jdk 1.8)이 일반적임
• 이클립스 2020-09 버전부터는 자바 버전 11 이상을 필요로 하므로 자바 버전 8버전용으로 마지막 버전인 2020-06 버전을 많이 사용함
• STS : Spring Tools Suite 플러그인을 이클립스에 설치
• 스프링 개발시에 필요한 기능들을 support하는 역할

2. Spring -> Spring Legacy Project -> spring MVC Project

• 일반적인 MVC 프로젝트

3. Maven 메이븐

• 프로젝트를 생성하고 library를 관리하고 build하는 것까지 프로젝트의 라이프 사이클(생성-활용-제거)을 관리하는 소프트웨어
• 자동으로 라이브러리를 쓸 수 있게 해 줌

4. Spring 초스피드 엑기스 간단 정리

• pom.xml : 메이븐 프로젝트 빌드 파일
• 자바 소스 경로는 : src/main/java
• 정적 리소스 파일 경로는 : src/main/resources
• web.wml : 웹 컨테이너(톰캣) 설정 파일
• servlet-context.xml : 스프링 웹 설정 파일
• root-context.xml : 스프링 설정 파일
• views 폴더 : 뷰 파일(jsp) 경로

5. 로그 레벨 설정

• FATAL : 아주 심각한 오류 발생
• ERROR : 요청 처리 중 문제 발생
• WARN : 실행에는 문제 없음. but, 향후 오류의 원인이 될 수 있을 때 경고
• INFO : 어떠한 상태변경과 같은 정보성 메시지
• DEBUG : 개발 시 디버그 용도
• TRACE : 상세 이벤트 발생 시 알려줌

ex) <level value="info" />면 Fatal부터 info까지 나옴

** <STS 플러그인 설치 방법>**

1. Help - 이클립스 마켓플레이스 - spring tools 3 검색 Standalone Edition 설치 - Confirm - finish

2. Spring Legacy Project - Spring MVC Project 생성 후 properties - java build path - java system library - edit -
   메인 environment 클릭 - JavaSE-1.8 클릭 - apply

3. alternative도 JavaSE-1.8 맞는지 확인 후 apply

4. project facets - Dynamic web module 3.1로, java 1.8로 변경

5. developmet assembly add 아무것도 없는거 확인하고 apply

6. 상단 window - preference - encoding 검색해서 UTF-8확인

7. pom.xml (Maven 프로젝트 설정하는 파일) <org.springframework-version>5.2.5.RELEASE</org.springframework-version> 로 바꾸기 <java-version>1.8</java-version>로 바꾸기

8. 프로젝트 우클릭 RunAs - 4번 클릭 Goals 에 compile 입력 - apply - run [INFO] BUILD SUCCESS 뜨면 성공!

   9. 하단 server 에서 JSPBOOK remove
   10. Tomcat 우클릭 Add and Remove - 방금 만든 프로젝트 add하고 finish
   11. 서버 더블클릭 modules - root path 바꾸기 edit 눌러서 /만 남기고 저장 (스프링에서 /는 WEB-INF의 views 폴더를 말한다)

9. sevlet-context.xml 확인 여기서 path를 설정할 수 있음 @controller설정 시 controller가 됨 prefix가 앞, suffix가 뒤로 합쳐진다.

->ViewResolver (controller에서 리턴되는 파일명 앞 뒤로 합쳐지는 값) -> resources(img,js파일 등을 저장하는 장소)는 직접 접근이 가능하지만 views는 보안때문에 접근불가!

13. 자동으로 UTF-8 설정해서 인코딩하는 번거로움 없애기 web.xml 수정(https://homesi.tistory.com/entry/Spring%EC%97%90%EC%84%9C-%ED%95%9C%EA%B8%80%EA%B9%A8%EC%A7%90-%EB%B0%A9%EC%A7%80%EB%A5%BC-%EC%9C%84%ED%95%B4-webxml%EC%97%90%EC%84%9C-%ED%95%9C%EA%B8%80-%EC%84%A4%EC%A0%95) 아래와 같이 한글 설정 추가 후 톰캣 재기동하기

14. log4j.xml 수정

숙제! 스프링 삼각형에 대한 이해 후 개념 발표

POJO (Plain Old Java Object) 순수한 자바로 작성된 객체 과거에는 자바로 웹 어플리케이션을 개발하기 위해 Servlet 클래스를 상속받아서 사용했음 스프링은 Servlet 클래스를 작성하지 않고 POJO만으로 웹 어플리케이션을 개발할 수 있다.

스프링 삼각형 = 스프링의 3대 프로그래밍 모델 1. IoC/DI 제어의 역전/ 의존성 주입

프로그래밍에서 의존성이란? 운전자는 자동차를 생산한다. = new Car() 자동차는 내부적으로 타이어를 생산한다. = Car 객체 생성자에서 new Tire();

Car 객체 생성자에서 new를 실행함으로 Car가 Tire에 의존한다. ->여기서 new 라는 키워드는 의존성이라고 할 수 있다.

의존 관계를 어떻게 맺냐에 따라 강한 결합인지, 느슨한 결합인지 구분됨

1) 강한 결합 : 객체 내부에서 다른 객체를 생성하는 것 ex) A라는 클래스 내부에서 B라는 객체를 직접 생성하고 있을 때 B객체를 C객체로 바꾸고 싶은 경우 A 클래스도 수정해야 한다. 위에서 설명한 new 키워드처럼!

2) 느슨한 결합 : 외부에서 생성된 객체를 인터페이스를 통해서 넘겨받는 것 의존성 주입으로 결합도를 낮추어 유연성과 확장성을 향상시킨다

의존성 주입(Dependancy Injection) 스프링에서 어떻게 의존성을 주입하는지?

여기서 빈(Bean) : Spring IoC 컨테이너가 관리하는 자바 객체

스프링에서는 XML 설정 파일들이 존재할 뿐만 아니라 Bean을 관리하게 되는데, 개발자가 코드에서 생성할 Bean을 XML 파일에 등록하여 의존성을 주입할 수 있다.

의존성 주입 3가지 방법

1) Field 주입 스프링 초창기부터 현재까지 사용되는 방법으로, 멤버 객체에 @Autowired를 붙여주면 스프링 프레임워크에서 알맞은 클래스를 기반으로 만든 Bean을 주입받는다

2) Setter 주입 setter 메소드 위에 @Autowired를 선언하게 되면, setter 메소드의 파라미터에 해당하는 객체에 Bean을 주입받는다

3) Constructor 주입 스프링 프레임워크에서 추천하는 방법 클래스 생성자에 Bean들을 파라미터로 주입받는 방법 Field 주입과 Setter 주입에서 사용하지 못하는 final 키워드를 붙일 수 있다.

3가지 방법 모두 개발자가 new를 사용하여 객체를 주입하는 것이 아니라 툴이 제어권을 가져 객체를 주입받아 사용한다 -> 제어권이 외부로 역전되었다.(IoC, Inversion of Control)

2. AOP Aspect-Oriented Programming 관점 지향 프로그래밍

여러 개의 핵심 비즈니스 로직 외에 공통으로 처리되어야 하는 로그 출력, 보안처리, 예외처리와 같은 코드를 모아서 처리를 편리하게 해준다. ex @Transactional 로 트랜잭션 처리를 공통으로 넣어줄 수 있다.

여기서 공통된 코드 = AOP에서 말하는 aspect

Spring AOP는 프록시 패턴이라는 디자인 패턴을 사용하여 AOP를 지원한다.

프록시를 통해 핵심 로직을 구현한 객체에 접근하게 되면 핵심 로직을 실행하기 전, 후에 공통된 기능을 적용하는 방식으로 AOP를 구현한다.

3. PSA Portable Service Abstraction 일관성 있는 서비스 추상화 어댑터 패턴을 적용해 같은 일을 하는 다수의 기술이 어떠한 데이터 베이스를 사용하더라도 일관성 있는 방식으로 제어할 수 있도록 공통의 인터페이스를 제공하는 것

ex) JDBC는 오라클, MySQL, MS-SQL 중 무엇을 사용하든 Connection, Statement, ResultSet을 이용해 공통된 방식으로 코드 작성이 가능하다.

jquery 다운로드 https://jquery.com/ 접속 download 클릭 upcompressed 클릭 -> 내용 복사 js폴더에 파일 만들고, 복사한 내용 붙여넣기 ---> 이제 script src에 해당 위치 적어서 사용 가능!

<방명록 게시판 만드는 순서> 1.GuestbookMessage 객체 생성 2.Dao 객체 생성 3.Service 객체 생성 및 예외처리 4.jsp파일로 View 작성

1.GuestbookMessage 객체 생성

GuestbookMessage.java

package dto;

//자바빈 클래스
public class GuestbookMessage {
    private int messageId;
    private String guestName;
    private String password;
    private String message;

    //기본생성자(Constructor)
    public GuestbookMessage() {
        super();
        // TODO Auto-generated constructor stub
    }

    //생성자
    public GuestbookMessage(int messageId, String guestName, String password, String message) {
        super();
        this.messageId = messageId;
        this.guestName = guestName;
        this.password = password;
        this.message = message;
    }


    public int getMessageId() {
        return messageId;
    }

    public void setMessageId(int messageId) {
        this.messageId = messageId;
    }


    public String getGuestName() {
        return guestName;
    }


    public void setGuestName(String guestName) {
        this.guestName = guestName;
    }


    public String getPassword() {
        return password;
    }


    public void setPassword(String password) {
        this.password = password;
    }


    public String getMessage() {
        return message;
    }


    public void setMessage(String message) {
        this.message = message;
    }


    @Override
    public String toString() {
        return "GuestbookMessage [messageId=" + messageId + ", guestName=" + guestName + ", password=" + password
                + ", message=" + message + "]";
    }


}

2.Dao 객체 생성

MessageDao.java

package guestbook.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import dto.GuestbookMessage;
import jdbc.JdbcUtil;

//Data Access Object
public class MessageDao {
    //싱글톤 패턴
    private static MessageDao instance = new MessageDao();
    public static MessageDao getInstance() {
        return instance;
    }
    private MessageDao() {}

    /**guestbook_message 테이블로 insert
     * insert, update, delete 기본 return type은 int
     * params : 커넥션 객체, 무엇을 입력할 것인지!(대상)
     */
    public int insert(Connection conn, GuestbookMessage message) {
        //선언
        PreparedStatement pstmt = null;
        int result = 0;
        try {
            pstmt = conn.prepareStatement(
                "INSERT INTO GUESTBOOK_MESSAGE(MESSAGE_ID,GUEST_NAME,PASSWORD,MESSAGE)" + 
                " VALUES(" + 
                "    (SELECT NVL(MAX(MESSAGE_ID),0)+1 FROM GUESTBOOK_MESSAGE)" + 
                "    ,?,?,?" + 
                ")"
            );
            pstmt.setString(1, message.getGuestName());
            pstmt.setString(2, message.getPassword());
            pstmt.setString(3, message.getMessage());
            return pstmt.executeUpdate();
        }catch(SQLException ex){
            ex.printStackTrace();
            return 0;
        }finally {
            //주의! 커넥션 객체는 비즈니스로직에서 닫음(Service)
            JdbcUtil.close(pstmt);
        }
    }//end insert

    //list.jsp의 메시지 목록
    public List<GuestbookMessage> selectList(Connection conn) throws SQLException {
        Statement stmt = null;
        ResultSet rs = null;

        try {
            //SELECT구문..
            String query = "SELECT MESSAGE_ID" + 
            "     , GUEST_NAME" + 
            "     , PASSWORD" + 
            "     , MESSAGE " + 
            " FROM   GUESTBOOK_MESSAGE" + 
            " ORDER BY MESSAGE_ID DESC";

            stmt = conn.createStatement();
            rs = stmt.executeQuery(query);
            //커서가 다음행으로 바라봤을 때 데이터가 있다면 실행
            if(rs.next()) {
                List<GuestbookMessage> messageList = new ArrayList<GuestbookMessage>();

                do {
                    GuestbookMessage vo = new GuestbookMessage();
                    vo.setMessageId(rs.getInt("MESSAGE_ID"));
                    vo.setGuestName(rs.getString("GUEST_NAME"));
                    vo.setPassword(rs.getString("PASSWORD"));
                    vo.setMessage(rs.getString("MESSAGE"));
                    //message_id는 자료형이 int이므로 getInt()로 받는다

                    messageList.add(vo);
                }while(rs.next());
                return messageList;
            }else { //select 결과 없을 때
                return Collections.emptyList();
            }//end if
        }finally {
            JdbcUtil.close(rs);
            JdbcUtil.close(stmt);
        }
    }

    //메시지 수정(커넥션, 무엇을)
    public int update(Connection conn, GuestbookMessage message) {
        PreparedStatement pstmt = null;

        try {
            pstmt = conn.prepareStatement("UPDATE GUESTBOOK_MESSAGE" +
                    " SET GUEST_NAME = ?, MESSAGE = ?" +
                    " WHERE MESSAGE_ID = ? AND PASSWORD = ?");
            pstmt.setString(1, message.getGuestName());
            pstmt.setString(2, message.getMessage());
            pstmt.setInt(3, message.getMessageId());
            pstmt.setString(4, message.getPassword());

            return pstmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        }finally {
            JdbcUtil.close(pstmt);
            //커넥션 객체는 서비스단에서 close해준다.
        }//end try
    }

    //삭제 : conn은 db연결, message는 삭제할 대상 지정
    public int delete(Connection conn, GuestbookMessage message) {
        PreparedStatement pstmt = null;

        try {
            pstmt = conn.prepareStatement("DELETE FROM GUESTBOOK_MESSAGE" +
                    " WHERE MESSAGE_ID = ?");
            pstmt.setInt(1, message.getMessageId());

            return pstmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        }finally {
            JdbcUtil.close(pstmt);
        }
    }
}

3.Service 객체 생성 및 예외처리

WriteMessageService.java

package guestbook.service;

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

import dto.GuestbookMessage;
import guestbook.dao.MessageDao;
import jdbc.ConnectionProvider;
import jdbc.JdbcUtil;
//***Service.java => 비즈니스(기능) 로직
public class WriteMessageService {
    //싱글톤 패턴 적용
    private static WriteMessageService instance = new WriteMessageService();
    public static WriteMessageService getInstance() {
        return instance;
    }
    private WriteMessageService() {}

    //방명록 insert
    public void write(GuestbookMessage message) {
        //커넥션 객체를 선언(DBCP에서 가져온 커넥션)
        Connection conn = null;
        try {
            //DBCP 커넥션 객체를 생성
            conn = ConnectionProvider.getConnection();
            //guestbook_message테이블로 insert => Data Access Object 영역
            MessageDao messageDao = MessageDao.getInstance();
            int result = messageDao.insert(conn, message);
        }catch(SQLException ex) {
            throw new ServiceException("메시지 등록 실패 : " + ex.getMessage(), ex);
        }finally {
            JdbcUtil.close(conn);
        }
    }

}

GetMessageListService.java

package guestbook.service;

public class ServiceException extends RuntimeException {

    //생성자
    public ServiceException(String message, Exception cause) {
        super(message, cause);
    }
    //생성자
    public ServiceException(String message) {
        super(message);
    }
}

UpdateMessageService.java

package guestbook.service;

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

import dto.GuestbookMessage;
import guestbook.dao.MessageDao;
import jdbc.ConnectionProvider;
import jdbc.JdbcUtil;

public class UpdateMessageService {
    //싱글톤 패턴
    private static UpdateMessageService instance = new UpdateMessageService(); 
    public static UpdateMessageService getInstance() {
        return instance;
    }
    private UpdateMessageService() {}

    //메시지를 update하는 비즈니스 로직
    public int update(GuestbookMessage message) {
        Connection conn = null;
        int result = 0;
        try {
            conn = ConnectionProvider.getConnection();
            //DAO 객체 생성
            MessageDao messageDao = MessageDao.getInstance();
            result = messageDao.update(conn, message);

        }catch(SQLException ex) {
            throw new ServiceException("메시지 수정 실패 : " + ex.getMessage(), ex);
        }finally {
            JdbcUtil.close(conn);
        }
        return result;
    }
}

DeleteMessageService.java

package guestbook.service;

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

import dto.GuestbookMessage;
import guestbook.dao.MessageDao;
import jdbc.ConnectionProvider;
import jdbc.JdbcUtil;

public class DeleteMessageService {
    //new를 사용하면 요청할 때마다 객체가 생성되어 과부하가 되므로 싱글톤을 사용한다.

    private static DeleteMessageService instance = new DeleteMessageService();
    public static DeleteMessageService getInstance() {
        return instance;
    }
    private DeleteMessageService() {}
    //데이터 삭제
    public int delete(GuestbookMessage message) {
        Connection conn = null;

        try {
            conn = ConnectionProvider.getConnection();

            MessageDao messageDao = MessageDao.getInstance();

            int result = messageDao.delete(conn, message);
            return result;

        } catch (SQLException ex) {
            //삭제 시 문제가 발생되면 롤백 처리
            //DC(control)L : commit, rollback(마지막 커밋 시점으로 돌아감)
            // -> 트랜잭션이 종료가 되는 동시에 새로운 트랜잭션이 시작
            // -> 트랜잭션? DB를 변경하기 위해 수행되어야 할 논리적 단위(여러개의 sql로 구성)
            JdbcUtil.rollback(conn);
            throw new ServiceException("삭제 실패", ex);
        }finally {
            JdbcUtil.close(conn);
        }
    }
}

ServiceException.java

package guestbook.service;

public class ServiceException extends RuntimeException {

    //생성자
    public ServiceException(String message, Exception cause) {
        super(message, cause);
    }
    //생성자
    public ServiceException(String message) {
        super(message);
    }
}

4.jsp파일로 View 작성

list.jsp

<%@page import="guestbook.service.GetMessageListService"%>
<%@ page import="dto.GuestbookMessage"%>
<%@ page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%
//list.jsp에서  사용할
//메시지 목록(List<GuestbookMessage>)을 가져와주는 서비스 로직
GetMessageListService messageListService = GetMessageListService.getInstance();
List<GuestbookMessage> list = messageListService.getMessageList();
%>
<c:set var="list" value="<%=list%>" />
<!DOCTYPE html>
<html>
<head>
<script type="text/javascript" src="/js/jquery-3.6.0.js"></script>
<title>방명록 메시지 목록</title>
<script type="text/javascript">
$(function(){
//    alert("왔다!");
});

//fn_updt(기본키, 작성자 , 메시지)
function fn_updt(vara, varb, varc){
    //alert(vara);
    //기본키 데이터를 vara 매개변수로 받아서 frmUpdate 폼의 기본키 데이터로 사용
    $("#messageId").val(vara);
    //작성자 매개변수를 frmUpdate 폼의 이름 데이터로 사용
    $("#guestName").val(varb);
    //메시지 매개변수를 frmUpdate 폼의 내용 데이터로 사용
    $("#message").val(varc);
    $("#frmWrite").css("display","none");
    $("#frmUpdate").css("display","block");
}
</script>
</head>
<body>
<form id="frmWrite" method="post" action="writeMessage.jsp" style="display:block;">
    이름 : <input type="text" name="guestName"/><br>
    비밀번호 : <input type="password" name="password"/><br>
    내용 : <textarea rows="3" cols="30" name="message"></textarea><br>
    <input type="submit" value="메시지 남기기" />
</form>
<form id="frmUpdate" method="post" action="updateMessage.jsp" style="display:none;">
    <input type="hidden" name="messageId" id="messageId" />
    이름 : <input type="text" name="guestName" id="guestName"/><br>
    비밀번호 : <input type="password" name="password"/><br>
    내용 : <textarea rows="3" cols="30" name="message" id="message"></textarea><br>
    <input type="submit" value="확인" />&nbsp;
    <input type="button" value="취소" onclick="javascript:location.href='list.jsp';"/>
</form>
<hr>

<!-- 
[수정]
1. 클릭 시 상단의 폼에 정보가 입력되고(비밀번호 제외)
    "메시지 남기기" 버튼이 hidden, "확인" 및 "취소" 버튼이 block
2. "확인" 클릭 시 해당 정보가 업데이트가 되는데, 이때 비밀번호가 일치해야 함
3. "취소" 클릭 시 현재 페이지의 목록으로 되돌아감
    "메시지 남기기" 버튼이 block, "확인" 및 "취소" 버튼이 hidden    

 -->
<c:if test="${param.result eq 1}">
    <div style="color:red;">변경 성공했습니다.</div>
</c:if>
<c:if test="${param.result < 1}">
    <div style="color:red;">비밀번호를 확인해주세요.</div>
</c:if>
<table border="1">
<c:forEach var="message" items="${list}">
    <tr>
        <td>
            메시지   번호 : <span>${message.messageId}</span><br>
            손  님  이  름 : <span>${message.guestName}</span><br>
            메     시    지 : <span>${message.message}</span><br>
            <a href="#" id="updt" onclick="fn_updt('${message.messageId}','${message.guestName}','${message.message}')">[수정]</a>&nbsp;
            <a href="deleteMessage.jsp?messageId=${message.messageId}">[삭제]</a>
        </td>
    </tr>
</c:forEach>
</table>
</body>
</html>

writeMessage.jsp

<%@page import="guestbook.service.WriteMessageService"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%
    request.setCharacterEncoding("UTF-8");
%>
<!DOCTYPE html>
<html>
<head>
<title>방명록 메시지 남김</title>
</head>
<body>
<jsp:useBean id="guestbookMessage" class="dto.GuestbookMessage">
    <jsp:setProperty name="guestbookMessage" property="*" />
    <!-- request로 넘어온 모든 데이터를  guestbookMessage 이름으로 매핑한다-->
</jsp:useBean>
${guestbookMessage.messageId}<br>
${guestbookMessage.guestName}<br>
${guestbookMessage.password}<br>
${guestbookMessage.message}<br>
<%
    //싱글톤 패턴
    WriteMessageService writeMessageService = WriteMessageService.getInstance();
    writeMessageService.write(guestbookMessage);
%>
방명록에 메시지를 남겼습니다.
<a href="list.jsp">[목록보기]</a>
</body>
</html>

updateMessage.jsp

<%@page import="dto.GuestbookMessage"%>
<%@page import="guestbook.service.UpdateMessageService"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%
request.setCharacterEncoding("UTF-8");

String messageId = request.getParameter("messageId");
String guestName = request.getParameter("guestName");
String password = request.getParameter("password");
String message = request.getParameter("message");


out.print("messageId : " + messageId + "<br>");
out.print("guestName : " + guestName + "<br>");
out.print("password : " + password + "<br>");
out.print("message : " + message + "<br>");

//getter 안쓰는 대신 생성자 파라미터에 이렇게 넣는다!
GuestbookMessage guestbookmessage = new GuestbookMessage(Integer.parseInt(messageId), guestName, password, message);

//여기서 사용할 UpdateMessageService의 객체를 생성
UpdateMessageService service = UpdateMessageService.getInstance();
int result = service.update(guestbookmessage);
if(result>0){ //변경 성공
    out.print("<script type='text/javascript'>location.href='list.jsp?result=1'</script>");
}else{ //변경 실패
    out.print("<script type='text/javascript'>location.href='list.jsp?result=0'</script>");
}

%>

deleteMessage.jsp

<%@page import="guestbook.service.ServiceException"%>
<%@page import="dto.GuestbookMessage"%>
<%@page import="guestbook.service.DeleteMessageService"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%
    request.setCharacterEncoding("UTF-8");

    //list.jsp에서 보낸 파라미터 받기 -> request.getParameter로 받으면 무조건 String형
    String messageId = request.getParameter("messageId");

    GuestbookMessage message = new GuestbookMessage();
    //int messageId 멤버변수(String messageId)로 형변환
    message.setMessageId(Integer.parseInt(messageId));
    //삭제 성공 여부(성공으로 세팅)
    boolean result = true;

    //삭제된 건수
    int cnt = 0;

    try{
        DeleteMessageService service = DeleteMessageService.getInstance();
        cnt = service.delete(message);
    }catch(ServiceException ex){ //서비스에서 throw new ServiceException으로 던진거 받기
        //실패 처리
        result = false;
    }

%>
<!DOCTYPE html>
<html>
<head>
<title>방명록 메시지 삭제</title>
</head>
<body>
<%
if(result){ //result : true일 때 
    if(cnt>0){ //삭제가 잘 된 경우
        out.print("메시지를 삭제하였습니다.");
    }else{ //기본키에 해당되는 데이터가 없을 경우
        out.print("해당 데이터가 없습니다.");
    }
}else{ //result : false
    out.print("삭제가 되지 않았습니다.");
}
%>
<br>
<a href="list.jsp">[목록 보기]</a>
</body>
</html>

JSP - Service - Dao - Oracle l          l          l          l view            Model 사용자      비즈니스 로직 영역

Controller는 View의 요청과 Model의 응답을 처리한다

Spring -> Spring Boot(스프링을 더 쉽게 이용하기 위한 도구)

프레임워크 : 디자인패턴(view, model) + 라이브러리(jar)

카멜 표기 변환

create or replace FUNCTION FN_GETCAMEL(COLUMN_NAME IN VARCHAR2)
RETURN VARCHAR2
IS
RSLT VARCHAR2(30);
BEGIN
--카멜표기로 변환(SITE_NUM -> siteNum)
SELECT LOWER(SUBSTR(REPLACE(INITCAP(COLUMN_NAME),'_'),1,1))
|| SUBSTR(REPLACE(INITCAP(COLUMN_NAME),'_'),2) INTO RSLT
FROM DUAL;
--리턴
RETURN RSLT;
END;
/

--구글 카멜변환(https://heavenly-appear.tistory.com/270)
SELECT COLUMN_NAME
, DATA_TYPE
, CASE WHEN DATA_TYPE='NUMBER' THEN 'private int ' || FN_GETCAMEL(COLUMN_NAME) || ';'
WHEN DATA_TYPE IN('VARCHAR2','CHAR') THEN 'private String ' || FN_GETCAMEL(COLUMN_NAME) || ';'
WHEN DATA_TYPE='DATE' THEN 'private Date ' || FN_GETCAMEL(COLUMN_NAME) || ';'
ELSE 'private String ' || FN_GETCAMEL(COLUMN_NAME) || ';'
END AS CAMEL_CASE
, '' RESULTMAP
FROM ALL_TAB_COLUMNS
WHERE TABLE_NAME = 'CUS';

1. 연결 : 데이터베이스를 사용하기 위해 먼저 데이터베이스에 연결해야 함
2. 데이터베이터에 데이터를 삽입/변경/삭제하는 등의 작업을 수행
3. 2~3번 과정을 작업을 완료할 때까지 반복해서 수행
4. 원하는 작업 수행 후 연결 종료

DB는 개념이다! <조건>

1. 공유
2. 통행
3. 저장
4. 운영

JDBC(Java Database Connectivity)

• 자바에서 DB 프로그래밍을 하기 위해 사용되는 API

• JDBC API 사용 어플리케이션의 기본 구성

• 자바는 DBMS 종류에 상관없이 하나의 JDBC API를 사용해서 데이터베이스 작업을 처리할 수 있다.

JDBC 드라이버

• DBMS와 통신을 담당하는 자바 클래스

• DBMS별로 알맞은 JDBC 드라이버 필요

• 보통 jar파일로 제공

• JDBC 드라이버 로딩

• • 로딩? 하드디스크로부터 메모리에 올리는 것

로딩코드

Class.forName("JDBC드라이버 클래스의 완전한 이름");

주요 DBMS의 JDBC드라이버

• 오라클 : oracle.jdbc.driver.OracleDriver

• MySQL : com.mysql.jdbc.Driver
• MS SQL 서버 : com.microsoft.sqlserver.jdbc.SQLServerDriver

JDBC URL

• DBMS와의 연결을 위한 식별 값
• JDBC 드라이버에 따라 형식 다름
• 일반적인 구성

• jdbc:[DBMS]:[데이터베이스 식별자]

• 주요 DBMS의 JDBC URL 구성

  Oracle: jdbc:oracle:thin:@HOST:PORT:SID MySQL : jdbc:mysql://HOST[:PORT]/DBNAME[?param=value& param1...] MS SQL : jdbc:sqlserver://HOST[:PORT];databaseName=DB

-> 오라클 드라이버는 thin 드라이버와 OCI 드라이버가 있는데, thin 드라이버는 자바 언어로만 구현된 JDBC 드라이버로서 JDK만 설치되어 있으면 어디서는 사용할 수 있다.

JDBC 프로그래밍 코딩 순서

1. JDBC 드라이버 로딩 Class.forName("oracle.jdbc.driver.OracleDriver");

-> 외우는 방법 : 오라클 JDBC 드라이버는 오라클꺼다~

2. 데이터베이스 커넥션(연결 객체) 생성

-> 순서 : 1)jdbcDriver 2)계정아이디 3)비밀번호

String jdbcDriver = "jdbc:oracle:thin:@localhost:1521:xe"; String dbUser = "사용자계정명"; String dbPass = "비밀번호";

-> 커넥션 객체에 이 세개를 담는다.

conn = DriverManager.getConnection(jdbcDriver,dbUser,dbPass);

3. Statement 생성

   stmt = conn.createStatement();

4. 쿼리 실행

   rs = stmt.excuteQuery(query);

5. 쿼리 실행 결과 출력

-> while(rs.next()) 사용

6. 사용한 Statement객체 종료

-> 중요! 닫지 않으면 메모리가 꽉차서 Connection 객체와 연결이 끊어진다.

if(rs!=null)try{rs.close();}catch(SQLException ex){}
if(stmt!=null)try{stmt.close();}catch(SQLException ex){}

7. 커넥션 객체 종료

   if(conn!=null)try{conn.close();}catch(SQLException ex){}

viewMemberList.jsp

<%@page import="java.sql.SQLException"%>
<%@page import="java.sql.ResultSet"%>
<%@page import="java.sql.Statement"%>
<%@page import="java.sql.Connection"%>
<%@page import="java.sql.DriverManager"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<title>회원 목록</title>
</head>
<body>
MEMBER 테이블의 내용<br>
<table width="100%" border="1">
    <tr>
        <th>이름</th><th>아이디</th><th>이메일</th>
    </tr>
<%
//1.JDBC 드라이버 로딩
Class.forName("oracle.jdbc.driver.OracleDriver");
//-->오라클 JDBC 드라이버는 오라클꺼다~~
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;

try{
//2.데이터베이스 커넥션(연결 객체) 생성
//jdbcDriver? 2)계정아이디? 3)비밀번호?
String jdbcDriver = "jdbc:oracle:thin:@localhost:1521:xe";
String dbUser = "jspexam";
String dbPass = "java";

    String query = "SELECT MEMBERID,PASSWORD,NAME,EMAIL FROM MEMBER";
    conn = DriverManager.getConnection(jdbcDriver,dbUser,dbPass);
//Connection 객체에 위에서 만든 세개 담기

//3.Statement 생성
    stmt = conn.createStatement();

//4.쿼리 실행
    rs = stmt.executeQuery(query);

//5.쿼리 실행 결과 출력
    while(rs.next()){
        out.print("<tr>");
        out.print("<td><a href='viewMember_pool.jsp?memberId="+rs.getString("MEMBERID")+"'>"+rs.getString("NAME")+"</td>");
        out.print("<td>"+rs.getString("MEMBERID")+"</td>");
        out.print("<td>"+rs.getString("EMAIL")+"</td>");
        out.print("</tr>");
    }

}catch(SQLException ex){
    out.print(ex.getMessage());
    ex.printStackTrace();
}finally{
//6.사용한 Statement객체 종료 (중요!!! 닫지않으면 메모리 꽉차서 Connection객체와 연결 끊어짐)
    if(rs!=null)try{rs.close();}catch(SQLException ex){}
    if(stmt!=null)try{stmt.close();}catch(SQLException ex){}
//7.커넥션 객체 종료
    if(conn!=null)try{conn.close();}catch(SQLException ex){}
}
%>
</table>
</body>
</html>

updateForm.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<title>이름 변경 폼</title>
</head>
<body>
<form method="post" action="update.jsp">
    <table border="1">
        <tr>
            <td>아이디</td><td><input type="text" name="memberId" size="10" /></td>
            <td>이름</td>
            <td><input type="text" name="name" size="10" /></td>
        </tr>
        <tr>
            <td colspan="4"><input type="submit" value="변경" /></td>
        </tr>
    </table>
</form>
</body>
</html>

*Statement 객체를 이용한 쿼리 실행 *

• Connection객체를 생성한 후에는 Connection 객체로부터 Connection.createStatement() 메서드를 사용하여 Statement를 생성하고 Query를 실행할 수 있다.
• Statement 객체가 제공하는 메서드로 쿼리를 실행한다.

• insert,update,delete문 실행 시 int excuteUpdate(String query) 메서드 사용 ===>실행 결과 변경된 레코드의 개수를 리턴!

-> select문 실행 시 ResultSet executeQuery(String query) 메서드 사용 ===> ResultSet을 결과값으로 리턴!

ResultSet에서 값 조회

• next()메서드로 데이터 조회 여부 확인(커서가 이동됨)

• 데이터 조회를 위한 주요 메서드

• ResultSet은 현재 커서 위치에 있는 행으로부터 데이터를 읽어오기 위해 get~~()형태의 메서드를 제공한다. ex) getString(), getInt(),getLong()...

ResultSet에서 데이터 조회하는 코드

• 1개 행 처리(if문 사용)
• 복수 행 처리 시 (whie문 사용)

PreparedStatement를 이용한 처리

• SQL의 틀을 미리 정해놓고, 나중에 값을 지정한다.

  stmt = conn.prepareStatement( "insert into MEMBER (MEMBERID, NAME, EMAIL) values (?, ?, ?)"); pstmt.setString(1, “a001”); // 첫번째 물음표의 값 지정 Pstmt.setString(2, “김은대"); // 두번째 물음표의 값 지정 pstmt.executeUpdate()

PreparedStatement의 사용 이유

• 반복해서 실행되는 동일 쿼리의 속도를 향상시킴

update.jsp

<%@page import="java.sql.DriverManager"%>
<%@page import="java.sql.SQLException"%>
<%@page import="java.sql.Statement"%>
<%@page import="java.sql.Connection"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%
    request.setCharacterEncoding("UTF-8");

    //파라미터 목록 중 memberId 및 name을 get함
    String memberId = request.getParameter("memberId");
    String name = request.getParameter("name");

    out.print("memberId : "+ memberId + ", name : " + name + "<br>");

    //jdbc 드라이버 로딩(메모리에 올림)
    Class.forName("oracle.jdbc.driver.OracleDriver");

    //커넥션 객체 선언
    Connection conn = null;
    //Statement 객체 선언
    Statement stmt = null;

    String query = "UPDATE MEMBER SET NAME = '"+name+"' WHERE MEMBERID = '"+memberId+"'";
    int updateCount = 0;

    try{
        String jdbcDriver = "jdbc:oracle:thin:@localhost:1521:xe";
        String dbUser = "jspexam";
        String dbPass = "java";

        //커넥션 객체 생성
        conn = DriverManager.getConnection(jdbcDriver,dbUser,dbPass);

        //Statement 객체 생성
        stmt = conn.createStatement();

        //insert,update,delete --> executeUpdate()
        //select --> executeQuery()
        updateCount = stmt.executeUpdate(query);
    }catch(SQLException ex){
        out.print(ex.getMessage());        
    }finally{
        if(stmt!=null)try{stmt.close();}catch(SQLException ex){}
        if(conn!=null)try{conn.close();}catch(SQLException ex){}        
    }
    if(updateCount>0){
        out.print(memberId + "의 이름을 " + name + "(으)로 변경");
    }else{
        out.print(memberId + " 아이디가 없음");
    }


%>

insertForm.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<title>MEMBER 테이블에 레코드 입력</title>
</head>
<body>
<form method="post" action="insert.jsp">
    <table border="1">
        <tr>
            <th>아이디</th>
            <td><input type="text" name="memberid" size="10"></td>
            <th>비밀번호</th>
            <td><input type="password" name="password" size="10"></td>
        </tr>
        <tr>
            <th>이름</th>
            <td><input type="text" name="name" size="10"></td>
            <th>이메일</th>
            <td><input type="text" name="email" size="10"></td>
        </tr>
        <tr>
            <td colspan="4"><input type="submit" value="입력" /></td>
        </tr>
    </table>
</form>
</body>
</html>

insert.jsp

<%@page import="java.sql.PreparedStatement"%>
<%@page import="java.sql.SQLException"%>
<%@page import="java.sql.DriverManager"%>
<%@page import="java.sql.Statement"%>
<%@page import="java.sql.Connection"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%
    request.setCharacterEncoding("UTF-8");

    String memberid = request.getParameter("memberid");
    String password = request.getParameter("password");
    String name = request.getParameter("name");
    String email = request.getParameter("email");

    out.print(memberid + ", " + password + ", " + name + ", " + email);

    Class.forName("oracle.jdbc.driver.OracleDriver");

    //커넥션 객체 선언
    Connection conn = null;
    //Statement 객체 선언
    PreparedStatement pstmt = null;

    String query = "INSERT INTO MEMBER(MEMBERID,PASSWORD,NAME,EMAIL) "
            + " VALUES(?,?,?,?)";

    try{
        String jdbcDriver = "jdbc:oracle:thin:@localhost:1521:xe";
        String dbUser = "jspexam";
        String dbPass = "java";

        //커넥션 객체 생성
        conn = DriverManager.getConnection(jdbcDriver,dbUser,dbPass);

        //Statement 객체 생성
        pstmt = conn.prepareStatement(query);
        pstmt.setString(1, memberid);
        pstmt.setString(2, password);
        pstmt.setString(3, name);
        pstmt.setString(4, email);

        //insert,update,delete --> executeUpdate()
        //select --> executeQuery()
        pstmt.executeUpdate();
    }catch(SQLException ex){
        out.print(ex.getMessage());        
    }finally{
        if(pstmt!=null)try{pstmt.close();}catch(SQLException ex){}
        if(conn!=null)try{conn.close();}catch(SQLException ex){}        
    }

%>

<!DOCTYPE html>
<html>
<head>
<title>입력</title>
</head>
<body>
    MEMBER 테이블에 새로운 레코드를 입력했습니다.
</body>
</html>

• 자바빈 클래스 생성

  Mem.java

  package dto;
  //자바빈 클래스
  public class Mem {
    private String memberid;
    private String password;
    private String name;
    private String email;
  
    //기본생성자
    public Mem() {
        super();
    }
  
    public String getMemberid() {
        return memberid;
    }
  
    public void setMemberid(String memberid) {
        this.memberid = memberid;
    }
  
    public String getPassword() {
        return password;
    }
  
    public void setPassword(String password) {
        this.password = password;
    }
  
    public String getName() {
        return name;
    }
  
    public void setName(String name) {
        this.name = name;
    }
  
    public String getEmail() {
        return email;
    }
  
    public void setEmail(String email) {
        this.email = email;
    }
  
  

}

## 커넥션 풀
- 데이터베이스와 연결된 커넥션을 미리 만들어서 풀(pool)속에 저장해두고 있다가 필요할 때에 커넥션을 풀에서 가져다 쓰고, 사용이 끝나면 다시 풀에 반환하는 기법

- 특징
1. 커넥션을 미리 생성해두기 때문에 사용자가 DB를 사용할 때마다 매번 생성하는 것보다 더 빠른 속도를 보장한다.

2. 커넥션의 최대 생성 개수도 제어해주기 때문에 많은 사용자가 몰려도 과부하를 방지할 수 있다.

- 커넥션 풀의 오픈소스에는 대표적으로 DBCP와 C3P0이 있는데 여기선 DBCP를 사용했다. DBCP는 Apache 사이트에서 받을 수 있다.
- 그 외에 DBCP에서 사용한 Pool인 Commons Pool이 필요하다.
- 부가적으로 로그 기록에 사용되는 Commons Logging도 필요하다.

### DBCP API를 이용한 커넥션 풀 사용
**1. 필요 라이브러리**
>
![](https://images.velog.io/images/hazel_jo/post/36075d1c-1eb5-41fd-8633-52210f3dddbb/image.png)

**    설치 방법**

https://mvnrepository.com/ 에서
commons-dbcp검색
Apache Commons DBCP클릭 - 2.9.0 클릭
jar 클릭해서 다운로드


commons-pool검색
Apache Commons Pool클릭 - 2.9.0
jar 클릭해서 다운로드


commons-logging검색
 Apache Commons Logging 클릭 -  1.2
jar 클릭해서 다운로드

다운로드 받은 파일들 복사해서 WEB-INF\lib에 붙여넣기

**2.데이터 베이스 세팅**

1)계정 생성 및 권한 부여
2)테이블 생성

- DBCP 설정 클래스
### DBCPInit.java

package jdbc;

import java.sql.DriverManager;

import javax.servlet.ServletException; import javax.servlet.http.HttpServlet;

import org.apache.commons.dbcp2.ConnectionFactory; import org.apache.commons.dbcp2.DriverManagerConnectionFactory; import org.apache.commons.dbcp2.PoolableConnection; import org.apache.commons.dbcp2.PoolableConnectionFactory; import org.apache.commons.dbcp2.PoolingDriver; import org.apache.commons.pool2.impl.GenericObjectPool; import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

//서블릿 클래스 public class DBCPInit extends HttpServlet { @Override public void init() throws ServletException{ //JDBC Driver를 로딩 loadJDBCDriver(); //커넥션풀을 초기화 initConnectionPool(); }

//JDBC Driver를 로딩
private void loadJDBCDriver() {
    try {
        //커넥션풀이 내부에서 사용할 JDBC Driver를 로딩함
        Class.forName("oracle.jdbc.driver.OracleDriver");
    }catch(ClassNotFoundException ex){
        throw new RuntimeException("fail to load JDBC Driver", ex);
    }
}
//커넥션풀을 초기화
private void initConnectionPool() {
    try {
        //의국에서 새로운 외과 의사를 생성할 때 필요한 외과가 있어야 함
        //커넥션풀에서 새로운 커넥션을 생성할 때 사용할 커넥션 팩토리를 생성 
        ConnectionFactory connFactory = 
                new DriverManagerConnectionFactory(
                        "jdbc:oracle:thin:@localhost:1521:xe"
                        ,"jspexam"
                        ,"java"
                        );
        //DBCP는 커넥션풀에 커넥션을 보관할 때 PoolableConnection을 사용
        //이 Class는 내부적으로 실제 Connection을 담고 있음
        //커넥션풀을 관리
        PoolableConnectionFactory poolableConnFactory = 
                new PoolableConnectionFactory(connFactory, null);

        //커넥션이 유효한지 여부 검사 시 사용할 쿼리
        poolableConnFactory.setValidationQuery("select 1");
        //커넥션 풀의 설정 정보 생성
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        //유휴 커넥션 검사 주기(1/1000초)
        //놀고 있는 커넥션을 풀에서 제거하는 시간 기준 (5분)
        poolConfig.setTimeBetweenEvictionRunsMillis(1000L * 60L * 5L);
        //풀에 보관중인 커넥션이 유효한지 검사할지 여부
        poolConfig.setTestWhileIdle(true);
        //커넥션 최소 개수
        poolConfig.setMinIdle(4);
        //커넥션 최대 개수
        poolConfig.setMaxTotal(50);

        //커넥션풀의 설정 정보를 생성. 팩토리와 커넥션풀 설정을 파라미터로 받음
        GenericObjectPool<PoolableConnection> connectionPool = 
                new GenericObjectPool<>(poolableConnFactory, poolConfig);
        //풀러블커넥션팩토리에도 생성이 된 커넥션 풀을 연결
        poolableConnFactory.setPool(connectionPool);
        //커넥션풀을 제공하는 JDBC 드라이버를 등록함
        Class.forName("org.apache.commons.dbcp2.PoolingDriver");
        PoolingDriver driver = (PoolingDriver)DriverManager.getDriver("jdbc:apache:commons:dbcp:");
        //커넥션 풀 드라이버에 생성된 커넥션풀을 등록
        //jdbc:apache:commons:dbcp:ddit
        driver.registerPool("ddit", connectionPool);
    }catch(Exception e) {
        throw new RuntimeException(e);

    }//end try
}//end initConnectionPool();

}

- 커넥션을 제공하는 클래스
### ConnectionProvider.java

package jdbc;

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

//커넥션을 제공해주는 클래스 public class ConnectionProvider { public static Connection getConnection() throws SQLException{ return DriverManager.getConnection("jdbc:apache:commons:dbcp:ddit"); } }

- JDBCUtil 클래스 생성해서 사용한 객체 종료 쉽게하기
### JDBCUtil.java

package jdbc;

import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; //하나의 클래스에 같은 이름의 메소드를 여러번 사용 가능? //오버로딩

public class JdbcUtil { public static void close(ResultSet rs) { if(rs!=null) try {rs.close();}catch(SQLException ex) {} } public static void close(Statement stmt) { if(stmt!=null) try {stmt.close();}catch(SQLException ex) {} } public static void close(Connection conn) { if(conn!=null) try {conn.close();}catch(SQLException ex) {} } public static void close(PreparedStatement pstmt) { if(pstmt!=null) try {pstmt.close();}catch(SQLException ex) {} } public static void rollback(Connection conn) { if(conn!=null) try {conn.close();}catch(SQLException ex) {} } }

#### JSP 서블릿(Servlet)
- 동적 웹 어플리케이션 컴포넌트
- .java 확장자
- 클라이언트의 요청에 동적으로 작동하고, 응답은 html을 이용
- 자바 thread를 이용하여 동작 -> 서버에 부하가 적게 걸리는 장점이 있음
- MVC 패턴에서 controller로 이용됨(JSP는 뷰로 이용됨)



**DBCP 이용한 방법으로 list 출력하기**
### viewMemberUsingPool.jsp

<%@page import="jdbc.ConnectionProvider"%> <%@page import="jdbc.JdbcUtil"%> <%@page import="java.sql.SQLException"%> <%@page import="java.sql.DriverManager"%> <%@page import="java.sql.ResultSet"%> <%@page import="java.sql.Statement"%> <%@page import="java.sql.Connection"%> <%@ page language="java" contentType="text/html; charset=UTF-8"%> <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

try{ //2.데이터베이스 커넥션(연결 객체) 생성 //1)jdbcDriver? 2)계정아이디? 3)비밀번호? String jdbcDriver = "jdbc:apache:commons:dbcp:ddit"; String query = "SELECT MEMBERID,PASSWORD,NAME,EMAIL FROM MEMBER"; // conn = DriverManager.getConnection(jdbcDriver); 이제 이거 안씀 conn = ConnectionProvider.getConnection();

//3.Statement 생성 stmt = conn.createStatement();

//4.쿼리 실행 rs = stmt.executeQuery(query);

//5.쿼리 실행 결과 출력 while(rs.next()){ out.print("

}catch(SQLException ex){ out.print(ex.getMessage()); ex.printStackTrace(); }finally{ //6.사용한 Statement객체 종료 JdbcUtil.close(rs); JdbcUtil.close(stmt); //7.커넥션 객체 종료 -> dbcp이니까 커넥션 객체를 커넥션 풀로 반환 JdbcUtil.close(conn); } %>

위 리스트에서 a태그(memberid)클릭 시 상세화면 이동

viewMember.jsp

<%@page import="dto.Mem"%>
<%@page import="jdbc.ConnectionProvider"%>
<%@page import="jdbc.JdbcUtil"%>
<%@page import="java.sql.DriverManager"%>
<%@page import="java.sql.SQLException"%>
<%@page import="java.sql.ResultSet"%>
<%@page import="java.sql.Statement"%>
<%@page import="java.sql.Connection"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%
    String memberId = request.getParameter("memberId");
%>
<!DOCTYPE html>
<html>
<head>
<title>회원 정보</title>
</head>
<body>
<%
    //jdbc 드라이버 로딩(메모리에 올림)
    Class.forName("oracle.jdbc.driver.OracleDriver");

    Connection conn = null;
    Statement stmt = null;
    ResultSet rs = null;
    Mem memVO = new Mem();

    String query = "SELECT MEMBERID,PASSWORD,NAME,EMAIL FROM MEMBER "
                + " WHERE MEMBERID = '"+memberId+"'";

    try{
//         conn = DriverManager.getConnection(
//                 "jdbc:oracle:thin:@localhost:1521:xe",
//                 "jspexam",
//                 "java");
        conn = ConnectionProvider.getConnection();
        stmt = conn.createStatement();
        rs = stmt.executeQuery(query);
        if(rs.next()){
            memVO.setMemberid(rs.getString("MEMBERID"));
            memVO.setName(rs.getString("NAME"));
            memVO.setPassword(rs.getString("PASSWORD"));
            memVO.setEmail(rs.getString("EMAIL"));
        }
        out.print("memVO : " + memVO.toString());
    }catch(SQLException ex){
        out.print(ex.getMessage());
    }finally{
        //6.사용한 Statement객체 종료 
        JdbcUtil.close(rs);
        JdbcUtil.close(stmt);
        //7.커넥션 객체 종료 -> dbcp이니까 커넥션 객체를 커넥션 풀로 반환
        JdbcUtil.close(conn);
    }
%>
<c:set var="memVO" value="<%=memVO%>" scope="request" />
<!-- scope="request" 면 하나의 객체를 공유해서 쓸수있다 -->
<table border="1">
    <tr>
        <th>아이디 </th><td>${memVO.memberid}</td>
    </tr>
    <tr>
        <th>비밀번호 </th><td>${memVO.password}</td>
    </tr>
    <tr>
        <th>이름</th><td>${memVO.name}</td>
    </tr>
    <tr>
        <th>이메일</th><td>${memVO.email}</td>
    </tr>
</table>



</body>
</html>

웹브라우저를 실행하면 JSessionID가 자동으로 생성되고, 쿠키에 들어간다.

장바구니는 세션, 장바구니 Id = 세션 Id

addCart.jsp

<%@page import="java.util.ArrayList"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%@ page import="dto.Product"%>
<%@ page import="ch04.com.dao.ProductRepository"%>
<%@ page import="java.util.List"%>
<%
    String id = request.getParameter("id");
    //id가 없거나 값이 없을 때
    if(id==null||id.trim().equals("")){
        response.sendRedirect("products.jsp");
        return;
    }

    //상품저장소 객체 생성
    ProductRepository dao = ProductRepository.getInstance();

    //상품 아이디에 해당하는 정보를 얻어와보자
    Product product = dao.getProductById(id);
    //id의 값이 P999 이런 경우 상품이 없다
    if(product == null){
        response.sendRedirect("/exceptionNoProductId.jsp");
    }
    //모든 상품을 가져와보자
    List<Product> goodsList = dao.getAllProducts();
    Product goods = new Product();
    for(int i=0; i<goodsList.size();i++){
        //요청 파라미터 아이디의 상품이 존재하는지 검사
        goods = goodsList.get(i);
        //A.equals(id)
        if(goods.getProductId().equals(id)){
            //for문에서 벗어나라
            break;
        }
    }

    //*요청 파라미터 아이디의 상품을 담은 장바구니를 초기화
    //세션 : cartlist를 얻어와  Array 객체에 저장
    ArrayList<Product> list = (ArrayList<Product>)session.getAttribute("cartlist");
    out.print("list의 크기 : " + list);
    //만약 cartlist라는 세션 정보가 없다면 ArrayList 객체를 생성하고 cartlist세션 생성
    if(list == null){
        list = new ArrayList<Product>();
        session.setAttribute("cartlist", list);
    }
    //list : 장바구니에 담긴 상품 목록
    int cnt = 0;
    Product goodsQnt = new Product();
    for(int i=0; i<list.size();i++){
        //요청 파라미터 아이디 addCart.jsp?id=P1234의 상품이 장바구니에 담긴 목록에 있다면
        //해당 상품의 수량을 1 증가
        goodsQnt = list.get(i);
        if(goodsQnt.getProductId().equals(id)){
            cnt++;
            int orderQuantity = goodsQnt.getQuantity() + 1;
            goodsQnt.setQuantity(orderQuantity);
        }
    }
    //요청 파라미터 아이디 addCart.jsp?id=P1234의 상품이 장바구니에 담긴 목록에 없다면
    //해당 상품의 수량을 1로 처리
    if(cnt == 0){
        goods.setQuantity(1);
        list.add(goods);
    }

    response.sendRedirect("product.jsp?id=" + id);
%>

product.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%@ page import="dto.Product"%>
<%@ page import="ch04.com.dao.ProductRepository"%>
<%@ page errorPage="/exceptionNoProductId.jsp" %>
<!DOCTYPE html>
<html>
<head>
<link rel="stylesheet" href="/css/bootstrap.min.css" />
<title>상품 상세 정보</title>
<script type="text/javascript">
    function addToCart(){
        //확인 : true, 취소 : false
        if(confirm("상품을 장바구니에 추가하겠습니까?")){ //확인
            document.addForm.submit();
        }else{
            document.addForm.reset();
        }
    }
</script>
</head>
<body>
<%-- 객체를 새로 생성한다.
<jsp:useBean id="productDAO" class="ch04.com.dao.ProductRepository" /> --%>
<%
    ProductRepository productDAO = ProductRepository.getInstance();
%>
    <div class="jumbotron">
        <div class="container">
            <h1 class="display-3">상품 정보</h1>
        </div>
    </div>
    <%
//     product.jsp?id=P1234
    String id = request.getParameter("id");
//     out.print("id : " + id + "<br />");

    //예전엔 이렇게 썼지만 이제는 useBean사용
//  ProductRepository productDAO = new ProductRepository();
    Product product = productDAO.getProductById(id); 

    //null.toString() -> 오류 임의 발생(errorPage 발생 유도)
    product.toString();
    %>
    <c:set var="product" value="<%=product%>" />
    <div class="container">
        <div class="row">
            <div class="col-md-5">
                <img src="/upload/${product.filename}" style="width:100%;"/>
            </div>
            <div class="col-md-6">
                <h3>${product.pname}</h3>
                <p>${product.description}</p>
                <p>
                    <b>상품 코드 : </b>
                    <span class="badge badge-danger">${product.productId}</span>
                </p>
                <p><b>제조사</b> : ${product.manufacturer}</p>
                <p><b>분류</b> : ${product.category}</p>
                <p><b>재고 수</b> : ${product.unitsInStock}</p>
                <h4>${product.uniPrice}원</h4>
                <p>
                    <form name="addForm" method="post" action="addCart.jsp?id=${product.productId}">
                        <a href="#" class="btn btn-info" onclick="addToCart()">상품 주문&raquo;</a>
                        <a href="cart.jsp" class="btn btn-warning">장바구니&raquo;</a>
                        <a href="products.jsp" class="btn btn-secondary">상품목록&raquo;</a>
                    </form>
                </p>

            </div>
        </div>
    </div>
</body>
</html>

deleteCart.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%
String id = request.getParameter("cartId");
if(id==null||id.trim().equals("")){
    response.sendRedirect("cart.jsp");
    return;
}
//장바구니에 등록된 모든 상품을 삭제
session.invalidate();

//cart.jsp로 되돌아가기
response.sendRedirect("cart.jsp");
%>

products.jsp

<%@page import="ch04.com.dao.ProductRepository"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%@ page import="dto.Product"%>
<%@ page import="java.util.List"%>
<!DOCTYPE html>
<html>
<head>
<link rel="stylesheet" href="/css/bootstrap.min.css" />
<title>상품 목록</title>
</head>
<body>
<%-- <jsp:useBean id="productDAO" class="ch04.com.dao.ProductRepository" /> --%>
<%
ProductRepository productDAO = ProductRepository.getInstance();
%>

<!-- top.jsp 인클루드 시작 -->
    <jsp:include page="/ch03/top.jsp" />
<!-- top.jsp 인클루드 끝 -->
<!-- jumbotron 스타일 시작 -->
    <div class="jumbotron">
        <div class="container">
        <!-- container -> 이 안에 내용이 있을거야 -->
            <h1 class="display-3">상품 목록</h1>
        </div>
    </div>
<!-- jumbotron 스타일 끝 -->
    <%
        List<Product> listOfProducts = productDAO.getAllProducts();
    %>
        <div class="container">
            <div class="row" align="center">
            <!-- row -> 행 단위로 찍을거야 -->
            <!-- 상품 반복 시작 -->
            <%
                for(int i=0; i<listOfProducts.size(); i++){
                    Product product = listOfProducts.get(i);
            %>

                <div class="col-md-4">
                    <img src="/upload/<%=product.getFilename()%>" style="width: 350px; height: 300px"/>
                    <h3><%=product.getPname() %></h3>
                    <p><%=product.getDescription() %></p>
                    <p><%=product.getUniPrice() %>원</p>
                    <p><a href="product.jsp?id=<%=product.getProductId() %>" class="btn btn-secondary" role="button">상세 정보&raquo;</a></p>
                </div>
            <%
                }//end for
            %>    

            <!-- 상품 반복 끝 -->        
            </div>
        </div>
<!-- bottom.jsp 인클루드 시작 -->
    <jsp:include page="/ch03/bottom.jsp" />        
<!-- bottom.jsp 인클루드 끝 -->
</body>
</html>

shippingInfo.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<link rel="stylesheet" href="/css/bootstrap.min.css" />
<title>배송 정보</title>
</head>
<body>
<!-- top 인클루드 시작 -->
    <jsp:include page="/ch03/top.jsp" />
<!-- top 인클루드 끝 -->
    <div class="jumbotron">
        <div class="container">
            <h1 class="display-3">배송 정보</h1>
        </div>
    </div>
    <div class="container">
        <form method="post" class="form-horizontal" action="shippinginfo_process.jsp">
            <input type="hidden" name="cartId" value="${param.cartId}" />
            <div class="form-group row">
                <label class="col-sm-2">성명</label>
                <div class="col-sm-3">
                    <input type="text" name="name" class="form-control" />
                </div>
            </div>
            <div class="form-group row">
                <label class="col-sm-2">배송일</label>
                <div class="col-sm-3">
                    <input type="text" name="shippingDate" class="form-control" />
                    (yyyy/mm/dd)
                </div>
            </div>
            <div class="form-group row">
                <label class="col-sm-2">국가</label>
                <div class="col-sm-3">
                    <input type="text" name="country" class="form-control" />
                </div>
            </div>
            <div class="form-group row">
                <label class="col-sm-2">우편번호</label>
                <div class="col-sm-3">
                    <input type="text" name="zipCode" class="form-control" />
                </div>
            </div>
            <div class="form-group row">
                <label class="col-sm-2">주소</label>
                <div class="col-sm-3">
                    <input type="text" name="addressName" class="form-control" />
                </div>
            </div>
            <div class="form-group row">
                <div class="col-sm-offset-2 col-sm-10">
                <!-- ?cartId=3F33D163E0590415FB7AB78354FC6BD3 -->
                    <a href="shippingInfo.jsp?cardId=${param.cartId}" class="btn btn-secondary" role="button">이전</a>
                    <input type="submit" class="btn btn-primary" value="등록" />                
                    <a href="checkOutcancelled.jsp" class="btn btn-secondary" role="button">취소</a>
                </div>
            </div>

        </form>

    </div>
<!-- bottom 인클루드 시작 -->
    <jsp:include page="/ch03/bottom.jsp" />
<!-- bottom 인클루드 끝 -->

</body>
</html>

shippinginfo_process.jsp

<%@page import="java.net.URLEncoder"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%
    request.setCharacterEncoding("UTF-8");

    //쿠키 생성 문법?
    //Cookie 객체명 = new Cookie(name,value);
    Cookie cartId = new Cookie("Shipping_cartId",
            URLEncoder.encode(request.getParameter("cartId"),"UTF-8"));
    Cookie name = new Cookie("Shipping_name",
            URLEncoder.encode(request.getParameter("name"),"UTF-8"));
    Cookie shippingDate = new Cookie("Shipping_shippingDate",
            URLEncoder.encode(request.getParameter("shippingDate"),"UTF-8"));
    Cookie country = new Cookie("Shipping_country",
            URLEncoder.encode(request.getParameter("country"),"UTF-8"));
    Cookie zipCode = new Cookie("Shipping_zipCode",
            URLEncoder.encode(request.getParameter("zipCode"),"UTF-8"));
    Cookie addressName = new Cookie("Shipping_addressName",
            URLEncoder.encode(request.getParameter("addressName"),"UTF-8"));
    //생성한 쿠키의 유효시간을 24시간으로 설정
    cartId.setMaxAge(24*60*60);
    name.setMaxAge(24*60*60);
    shippingDate.setMaxAge(24*60*60);
    country.setMaxAge(24*60*60);
    zipCode.setMaxAge(24*60*60);
    addressName.setMaxAge(24*60*60);
    //쿠키를 등록하기 위해 response객체를 통해 클라이언트(크롬)에게 전달해 줌
    response.addCookie(cartId);
    response.addCookie(name);
    response.addCookie(shippingDate);
    response.addCookie(country);
    response.addCookie(zipCode);
    response.addCookie(addressName);

    response.sendRedirect("orderConfirmation.jsp");

%>

orderConfirmation.jsp

<%@page import="java.net.URLDecoder"%>
<%@page import="dto.Product"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%
    request.setCharacterEncoding("UTF-8");

    String cartId = session.getId();

    Cookie[] cookies = request.getCookies();
    String shipping_cartId = "";
    String shipping_name = "";
    String shipping_shippingDate = "";
    String shipping_country = "";
    String shipping_zipCode = "";
    String shipping_addressName = "";

    // 쿠키가 있어야 함 
    if(cookies != null){
       for(int i=0; i<cookies.length;i++){
          Cookie thisCookie = cookies[i];
          // 쿠키명을 가져오기
          String n = thisCookie.getName();
          // 쿠키명에 매핑되어 있는 값을 가져오기
          if(n.equals("Shipping_cartId")){
             shipping_cartId = URLDecoder.decode(thisCookie.getValue(),"UTF-8");
          }
          if(n.equals("Shipping_name")){
             shipping_name = URLDecoder.decode(thisCookie.getValue(),"UTF-8");
          }
          if(n.equals("Shipping_shippingDate")){
             shipping_shippingDate = URLDecoder.decode(thisCookie.getValue(),"UTF-8");
          }
          if(n.equals("Shipping_country")){
             shipping_country = URLDecoder.decode(thisCookie.getValue(),"UTF-8");
          }
          if(n.equals("Shipping_zipCode")){
             shipping_zipCode = URLDecoder.decode(thisCookie.getValue(),"UTF-8");
          }
          if(n.equals("Shipping_addressName")){
             shipping_addressName = URLDecoder.decode(thisCookie.getValue(),"UTF-8");
          }


       }
    }
%>

<!DOCTYPE html>
<html>
<head>
<link rel="stylesheet" href="/css/bootstrap.min.css">
<title>주문 정보</title>
</head>
<body>
<!-- top 인클루드 시작 -->
    <jsp:include page="/ch03/top.jsp" />
<!-- top 인클루드 끝 -->
    <div class="jumbotron">
        <div class="container">
            <h1 class="display-3">주문 정보</h1>
        </div>
    </div>
    <!-- 배송에 관한 정보 시작 -->
    <div class="container col-8 alert alert-info">
        <div class="text-center">
            <h1>영수증</h1>
        </div>
        <div class="row justify-content-between">
            <div class="col-4" align="left">
                <strong>배송 주소</strong><br>
                성명 : <%=shipping_name%> <br>
                우편번호 : <%=shipping_zipCode%> <br>
                주소 : <%=shipping_addressName%>(<%=shipping_country%>)<br>
            </div>
            <div class="col-4" align="right">
                <p><em>배송일 : <%=shipping_shippingDate %></em></p>
            </div>
        </div>
    <!-- 배송에 관한 정보 끝 -->
        <div>
            <table class="table table-hover">
                <tr>
                    <th class="text-center">상품</th>
                    <th class="text-center">#</th>
                    <th class="text-center">가격</th>
                    <th class="text-center">소계</th>
                </tr>
                <%
                    //장바구니는 세션을 사용한다(세션명 : cartlist)
                    List<Product> cartList = (List<Product>)session.getAttribute("cartlist");
                %>
                <c:set var="cartList" value="<%=cartList%>"/>
                <!--상품에 관한 정보 시작-->
                <c:forEach var="product" items="${cartList}">
                <tr>
                    <td class="text-center"><em>${product.pname}</em></td>
                    <td class="text-center">${product.quantity}</td>
                    <td class="text-center"><fmt:formatNumber value="${product.uniPrice}" pattern="#,###"/>원</td>
                    <td class="text-center"><fmt:formatNumber value="${product.quantity * product.uniPrice}" pattern="#,###"/>원</td>
                </tr>
                    <!-- sum으로 누적 -->
                    <c:set var="sum" value="${sum + product.quantity * product.uniPrice}" />
                </c:forEach>
                <tr>
                    <td></td>
                    <td></td>
                    <td><strong>총액 : </strong></td>
                    <td class="text-center text-danger"><strong><fmt:formatNumber value="${sum}" pattern="#,###"/>원</strong></td>
                </tr>
            </table>
        <a href="shippingInfo.jsp?cartId=${param.cartId }" class="btn btn-secondary" role="button">이전</a>
        <a href="thankCustomer.jsp" class="btn btn-success">주문완료</a>
        <a href="checkOutCancelled.jsp" class="btn btn-secondary" role="button">취소</a>

        </div>


    </div>        
<!-- bottom 인클루드 시작 -->
    <jsp:include page="/ch03/bottom.jsp" />
<!-- bottom 인클루드 끝 -->
</body>
</html>

checkOutcancelled.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<link rel="stylesheet" href="/css/bootstrap.min.css" />
<title>주문 취소</title>
</head>
<body>
<!-- top 인클루드 시작 -->
    <jsp:include page="/ch03/top.jsp" />
<!-- top 인클루드 끝 -->

    <div class="jumbotron">
        <div class="container">
            <h1 class="display-3">주문 취소</h1>
        </div>
    </div>
    <div class="container">
        <h2 class="alert alert-danger">주문이 취소되었습니다.</h2>
    </div>
    <div class="container">
        <p>
            <a href="products.jsp" class="btn btn-secondary">&raquo;상품 목록</a>
        </p>

    </div>

<!-- bottom 인클루드 시작 -->
    <jsp:include page="/ch03/bottom.jsp" />
<!-- bottom 인클루드 끝 -->
</body>
</html>

thankCustomer.jsp

<%@page import="java.net.URLDecoder"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%
    Cookie[] cookies = request.getCookies();

    String shipping_cartId = "";
    String shipping_shippingDate = "";

    if(cookies != null){
        for(int i=0;i<cookies.length;i++){
            Cookie thisCookie = cookies[i];
            String n = thisCookie.getName();
            if(n.equals("Shipping_cartId")){
                shipping_cartId = URLDecoder.decode(thisCookie.getValue(),"UTF-8");
            }
            if(n.equals("Shipping_shippingDate")){
                shipping_shippingDate = URLDecoder.decode(thisCookie.getValue(),"UTF-8");
            }
        }
    }
%>
<!DOCTYPE html>
<html>
<head>
<link rel="stylesheet" href="/css/bootstrap.min.css" />
<title>주문 완료</title>
</head>
<body>
<!-- top 인클루드 시작 -->
    <jsp:include page="/ch03/top.jsp" />
<!-- top 인클루드 끝 -->

    <div class="jumbotron">
        <div class="container">
            <h1 class="display-3">주문 완료</h1>
        </div>
    </div>
    <div class="container">
        <h2 class="alert alert-danger">주문해주셔서 감사합니다.</h2>
        <p>주문은 <%=shipping_shippingDate %> 에 배송될 예정입니다.</p>
        <p>주문번호 : <%=shipping_cartId %> </p>
    </div>
    <div class="container">
        <p>
            <a href="products.jsp" class="btn btn-secondary">&raquo;상품 목록</a>
        </p>

    </div>

<!-- bottom 인클루드 시작 -->
    <jsp:include page="/ch03/bottom.jsp" />
<!-- bottom 인클루드 끝 -->
</body>
</html>

<%
    //세션으로 저장된 장바구니 정보를 모두 삭제함
    session.invalidate();
    //쿠키에 저장된 배송 정보를 모두 삭제함
    for(int i=0;i<cookies.length;i++){
        Cookie thisCookie = cookies[i];
          // 쿠키명을 가져오기
          String n = thisCookie.getName();
          // 쿠키명에 매핑되어 있는 값을 가져오기
          if(n.equals("Shipping_cartId")){
              thisCookie.setMaxAge(0);
          }
          if(n.equals("Shipping_name")){
              thisCookie.setMaxAge(0);
          }
          if(n.equals("Shipping_shippingDate")){
              thisCookie.setMaxAge(0);
          }
          if(n.equals("Shipping_country")){
              thisCookie.setMaxAge(0);
          }
          if(n.equals("Shipping_zipCode")){
              thisCookie.setMaxAge(0);
          }
          if(n.equals("Shipping_addressName")){
              thisCookie.setMaxAge(0);
          }

          response.addCookie(thisCookie);

    }
%>

cart.jsp

<%@page import="dto.Product"%>
<%@page import="java.util.ArrayList"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%
    //세션의 고유 아이디를 가져옴
    String cartId = session.getId();
%>

<!DOCTYPE html>
<html>
<head>
<link rel="stylesheet" href="/css/bootstrap.min.css" />
<title>장바구니</title>
</head>
<body>
<!-- top.jsp 인클루드 시작 -->
    <jsp:include page="/ch03/top.jsp" />
<!-- top.jsp 인클루드 끝 -->
    <div class="jumbotron">
        <div class="container">
            <h1 class="display-3">장바구니</h1>
        </div>
    </div>    
        <div class="container">
            <div class="row">
            <table width="100%">
                <tr>
                    <td align="left">
                        <a href="deleteCart.jsp?cartId=<%=cartId%>" class="btn btn-danger">삭제하기</a>
                    </td>
                    <td align="right">
                        <a href="shippingInfo.jsp?cartId=<%=cartId %>" class="btn btn-success">주문하기</a>
                    </td>
                </tr>
            </table>
            </div>


        <!-- 장바구니 목록 구현 시작 -->
        <div style="padding-top:50px;">
            <table class="table table-hover">
                <tr>
                    <th>상품</th>
                    <th>가격</th>
                    <th>수량</th>
                    <th>소계</th>
                    <th>비고</th>
                </tr>
<%
ArrayList<Product> cartList = (ArrayList<Product>)session.getAttribute("cartlist");
//세션으로 가져오면 object이므로 형변환 필수
//out.print("cartList 크기 : " + cartList.size());
//cartList : 장바구니
if(cartList == null){
    cartList = new ArrayList<Product>();
}

int sum = 0; //total을 누적
for(int i=0; i<cartList.size();i++){
    Product product = cartList.get(i);
    //금액 = 가격 * 수량
    int total = product.getUniPrice() * product.getQuantity();
    //total을 누적
    sum = sum + total;
%>
                <tr>
                    <td><%=product.getProductId() %>-<%=product.getPname() %></td>
                    <td><%=product.getUniPrice() %></td>
                    <td><%=product.getQuantity() %></td>
                    <td><%=total %></td>
                    <td>삭제</td>
                </tr>    
<%
}
%>
                <tr>
                    <td></td>
                    <td></td>
                    <td>총액</td>
                    <td><%=sum %></td>
                    <td></td>
                </tr>

            </table>
            <a href="products.jsp" class="btn btn-secondary">&raquo; 쇼핑 계속하기</a>
        </div>
        </div>

<!-- bottom.jsp 인클루드 시작 -->
    <jsp:include page="/ch03/bottom.jsp" />        
<!-- bottom.jsp 인클루드 끝 -->
</body>
</html>

• 쿠키(cookie)는 웹 브라우저가 보관하고 있는 데이터로서 웹 서버에 요청을 보낼 때 함께 전송

• 동작 방식

• 웹 브라우저에 쿠키가 저장되면, 웹 브라우저는 쿠키가 삭제되기 전까지 웹 서버에 쿠키를 전송함

• 웹 어플리케이션을 사용하는 동안 지속적으로 유지해야 하는 정보는 쿠키를 사용해서 저장하면 됨

쿠키의 구성

구성요소

• 이름 : 각각의 쿠키를 구별하는 데 사용되는 이름
• 값 : 쿠키의 이름과 관련된 값
• 유효시간 : 쿠키의 유지 시간
• 도메인 : 쿠키를 전송할 도메인
• 경로 : 쿠키를 전송할 요청 경로

쿠키 이름의 제약

• 쿠키의 이름은 아스키 코드의 알파벳과 숫자만을 포함할 수 있다.

• 콤마(,), 세미콜론(;), 공백(' ') 등의 문자는 포함할 수 없다.

• $로 시작할 수 없다.

• 보통 쿠키 이름을 작성할 때에는 알파벳과 숫자만 이용함

• 쿠키 값을 생성할 때에는 알맞은 방식으로 인코딩 함

• 별도 유효시간을 지정하지 않으면 웹 브라우저를 종료할 때 쿠키를 함께 삭제함. 지정한 도메인이나 경로로만 쿠키를 전송하도록 제한할 수도 있음

JSP에서 쿠키 생성/읽기

• Cookie 클래스를 이용해서 쿠키 생성

  <%
    Cookie cookie = new Cookie("cookieName", "cookieValue");
    response.addCookie(cookie);
  %>

• 클라이언트가 보낸 쿠키 읽기 Cookie[] cookies = request.getCookies();

• 읽기 관련 주요 메서드

  메서드     리턴타입    설명 getName()    String   쿠키의 이름을 구한다. getValue()     String   쿠키의 값을 구한다.

쿠키 값의 인코딩/디코딩 처리

• 쿠키는 값으로 한글과 같은 문자를 가질 수 없음

• 쿠키의 값을 인코딩해서 지정할 필요 있음

• 쿠키 값의 처리

  -> 값 설정시 : URLEncoder.encode("값", "euc-kr") 예, new Cookie("name", URLEncoder.encode("값", "euc-kr"));  

• 값 조회시 : URLDecoder.decode("값", "euc-kr") Cookie cookie = …; String  value  =  URLDecoder.decode(cookie.getValue(), "euc-kr");

쿠키 값 변경

• 기존에 존재하는지 확인 후, 쿠키값 새로 설정

  Cookie[] cookies = request.getCookies();
  if(cookies!=null && cookies.length > 0){
    for(int i = 0; i<cookies.length; i++){
        if(cookies[i].getName().equals("name")){
            Cookie cookie = new Cookie(name, value);
                    response.addCookie(cookie);
                }
        }
  }

쿠키 삭제

• Cookie 클레스의 setMaxAge() 메서드를 호출할 때 인자값 0을 주면 됨

• Cookie.setMaxAge(0);

• Cookie 클래스는 쿠키를 삭제하는 기능을 별도로 제공하지 않음
• 유효시간을 0으로 지정해준 후 응답 헤더에 추가하면, 웹 브라우저가 관련 쿠키를 삭제하게 됨

[쿠키] 정리

1. 쿠키란?

• 세션과 마찬가지로 클라이언트(크롬)와 웹 서버(톰켓)간의 상태를 지속적으로 유지하는 방법
• 상태 정보(name, value)를 클라이언트(크롬의 쿠키저장소)에 저장
• 쿠키 생성은 서버에서 함. 그 이후에 웹 서버로 전송되는 요청에는 쿠키 정보가 포함됨 예) 아이디 저장하기
• 처음 방문한 사용자가 로그인 인증 -> 아이디와 비밀번호를 기록한 쿠키가 생성 -> 그 이후에 사용자가 그 웹사이트에 접속하면 별도의 절차를 거치지 않고 쉽게 접속 가능

2. 쿠키 생성은?

   Cookie cookie = new Cookie("memberid", "admin"); response.addCookie(cookie);

3. 쿠키 삭제는?

   cookie.setMaxAge(0); response.addCookie(cookie);

4. 쿠키 생성?

   Cookie cookie = new Cookie(String name, String value);

5. 쿠키 정보 받기

• request.getCookie() 메소드를 사용
• 쿠키 객체를 얻어온 후 getName()메소드를 통해 쿠키 이름을 가져옴
• getValue() 메소드를 통해 해당 이름의 쿠키의 값을 얻음

6. 쿠키 삭제

• 쿠키를 더 유지할 필요가 없다면 유효기간을 만료하기
• setMaxAge(0)

cookie01.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<title>Cookie</title>
</head>
<body>
    <form method="post" action="cookie01_process.jsp">
        <p>아 이 디 : <input type="text" name="id" /></p>
        <p>비밀번호 : <input type="text" name="passwd" /></p>
        <p><input type="submit" value="전송" /></p>
    </form>
</body>
</html>

cookie01_process.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<title>Cookie</title>
</head>
<body>
<%
    //?id=admin&passwd=1234
    String user_id = request.getParameter("id");
    String user_pw = request.getParameter("passwd");

    if(user_id.equals("admin")&&user_pw.equals("1234")){
        //Cookie 객체 생성
        Cookie cookie_id = new Cookie("userID", user_id);
        Cookie cookie_pw = new Cookie("userPW", user_pw);
        response.addCookie(cookie_id);
        response.addCookie(cookie_pw);

        out.print("쿠키 생성 성공!");
        out.print(user_id + "님 환영합니다");
    }else{
        out.print("쿠키 생성 실패");
    }
%>
</body>
</html>

cookie02.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%
    //쿠키 정보를 얻어오기
    Cookie[] cookies = request.getCookies();

    for(int i=0; i<cookies.length; i++){
        out.print("설정된 쿠키의 속성 명 [" + i + "] : " + cookies[i].getName() + "<br>");
        out.print("설정된 쿠키의 속성 값 [" + i + "] : " + cookies[i].getValue() + "<br>");
        out.print("===============================<br>");
    }

%>

detele.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<title>Cookie</title>
</head>
<body>
<%
    Cookie[] cookies = request.getCookies();

    for(int i=0; i<cookies.length; i++){
        //쿠키 삭제 : 유효기간을 0으로 설정
        cookies[i].setMaxAge(0);
        response.addCookie(cookies[i]);
    }
    response.sendRedirect("cookie02.jsp");

%>
</body>
</html>

모달 사용 시 https://adminlte.io/themes/v3/pages/UI/modals.html 참고

세션(session)이란

• 서버 세션을 사용하면 클라이언트(크롬)의 상태를 저장할 수 있음

• 쿠키와의 차이점은 세션은 웹 브라우저가 아닌 서버에 값을 저장한다는 점

• 웹 컨테이너(톰켓)에서 클라이언트(크롬)의 정보를 보관 및 상태를 유지할 때 사용

• 로그인한 사용자 정보를 유지하기 위한 목적

• 클라이언트마다 세션이 생성(크롬과 edge의 세션이 다름) (웹 브라우저마다 세션이 따로 존재하기 때문에, 세션은 웹 브라우저와 관련된 정보를 저장하기에 알맞은 장소임)

• 웹 브라우저에 정보 보관 : 쿠키 (클라이언트 측의 데이터 보관소)

• 웹 컨테이너에 정보 보관 : 세션 (서버측의 데이터 보관소)

• 쿠키와 마찬가지로 세션도 생성을 해야만 정보를 저장할 수 있음

• 일단 세션을 생성하면 session 기본 객체를 통해서 세션을 사용할 수 있음

세션과 session 기본 객체

• page 디렉티브의 session 속성 값을 true로 지정

• 세션이 존재하지 않을 경우 세션이 생성되고, 세션이 존재할 경우 이미 생성된 세션을 접근

• session 기본 객체를 이용해서 세션에 접근

• session 기본값은 true(생략 가능)이므로 false로 하지 않는 이상 항상 세션 사용

• 속성 이용해서 클라이언트 관련 정보 저장

• 세션이 생성되면 session 기본 객체를 통해서 세션을 사용할 수 있음

세션이 생성되는 원리

session 기본 객체가 제공하는 세션 정보 관련 메서드

메서드              리턴타입                 설명 getId()                  String          세션의 고유 ID를 구함(세션ID) getCreationTime()    long           세션이 생성된 시간을 구함. 시간은 1970년 1월 1일 이후 흘러간 시간을 의미. 단위는 1/1000초 getLastAccessedTime()    long    웹 브라우저가 가장 마지막에 세션에 접근한 시간을 구함. 시간은 1970년 1월 1일 이후 흘러간 시간을 의미. 단위는 1/1000초

• 웹 브라우저마다 별도의 세션을 갖음. 이때 각 세션을 구분하기 위해 세션마다 고유 ID를 할당하는데 그 아이디를 세션ID라고 함
• 웹 서버는 웹 브라우저에 세션ID를 전송함
• 웹 브라우저는 웹 서버에 연결할 때마다 매번 세션ID를 보내서 웹 서버가 어떤 세션을 사용할 지 판단할 수 있게 함
• 웹 서버는 세션ID를 이용해서 웹 브라우저를 위한 세션을 찾으므로 웹 서버와 웹 브라우저는 세션ID를 공유할 수 있는 방법이 필요함. 세션ID를 공유하기 위해 사용하는 것이 쿠키임 JSESSIONID 쿠키가 세션ID를 공유할 때 사용하는 쿠키

세션 종료

• 세션을 유지할 필요가 없으면 session.invalidate()을 이용해서 세션 종료

• 세션이 종료되면 기존에 생성된 세션이 삭제

• 현재 사용중인 session 기본 객체를 삭제하고, session 기본 객체에 저장했던 속성 목록도 함께 삭제

• 이후 접근 시 새로운 세션 생성됨

sessioninfo.jsp

<%@page import="java.util.Date"%>
<%@page import="java.text.SimpleDateFormat"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<title>세션 정보</title>
</head>
<body>
<%
    //long 타입의 시간 값을 저장하기 위해 사용
    Date time = new Date();    
    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
%>

세션 ID : <%=session.getId() %> <br>
<%
    //세션의 생성 시간을 Date 객체인 time에 저장
    time.setTime(session.getCreationTime());
%>
세션 생성시간 : <%=formatter.format(time)%> <br>
<%
    //세션의 마지막 접근 시간(long) -> Date 타입으로 세팅
    time.setTime(session.getLastAccessedTime());
%>
최근 접근시간 : <%=formatter.format(time) %> <br>
</body>
</html>

setMemberinfo.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%
    session.setAttribute("MEMBERID", "ddit");
    session.setAttribute("NAME", "개똥이");
%>

<!DOCTYPE html>
<html>
<head>
<title>세션에 정보 저장</title>
</head>
<body>
세션에 정보를 저장했습니다.<br>
<a href="getMemberInfo.jsp">저장된 세션의 정보 보기</a>
</body>
</html>

getMemberinfo.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%
    String memberId = (String)session.getAttribute("MEMBERID"); //ddit 가져올거야 , 결과는 object 형태이므로 형변환한다
    String name = (String)session.getAttribute("NAME"); //개똥이 가져올거야
%>

<!DOCTYPE html>
<html>
<head>
<title>저장된 세션의 정보 확인</title>
</head>
<body>
회원 id : <%=memberId %><br>
회원 이름 : <%=name %><br>
<a href="setMemberInfo.jsp">되돌아가기</a>
</body>
</html>

session.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<title>Session</title>
</head>
<body>
    <form method="post" action="session_process.jsp">
        <p>아 이 디 : <input type="text" name="id"></p>
        <p>비밀번호 : <input type="password" name="passwd"></p>
        <p><input type="submit" value="전송"></p>
    </form>
</body>
</html>

session_process.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%
    String memberId = (String)session.getAttribute("MEMBERID"); //ddit 가져올거야 , 결과는 object 형태이므로 형변환한다
    String name = (String)session.getAttribute("NAME"); //개똥이 가져올거야
%>

<!DOCTYPE html>
<html>
<head>
<title>저장된 세션의 정보 확인</title>
</head>
<body>
회원 id : <%=memberId %><br>
회원 이름 : <%=name %><br>
<a href="setMemberInfo.jsp">되돌아가기</a>
</body>
</html>

welcome.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%
    String userID = (String)session.getAttribute("userID");
    String userPW = (String)session.getAttribute("userPW");
%>
<!DOCTYPE html>
<html>
<head>
<title>Insert title here</title>
</head>
<body>
    <h1><%=userID %>님 반갑습니다.</h1>
    <a href="session_out.jsp">로그아웃</a>
</body>
</html>

session_out.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%
    session.invalidate();

    response.sendRedirect("session.jsp");
%>

<!DOCTYPE html>
<html>
<head>
<title>Insert title here</title>
</head>
<body>

</body>
</html>

login.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
<head>
<title>Login</title>
<link rel="stylesheet" href="/css/bootstrap.min.css" />
</head>
<body>
    <div class="jumbotron">
        <div class="container">
            <h1 class="display-3">로그인</h1>
        </div>
    </div>
    <div class="container" align="center">
        <div class="col-md-4 col-md-offset-4">
            <h3 class="form-singin-heading">Please Sign in</h3>
            <c:if test="${param.error eq '1'}">
                <!--parma 목록 중에 error라는 목록이 있냐? 그 값이 1이 맞냐? -->
                <div class="alert alert-danger">
                    아이디와 비밀번호를 확인해주세요.
                </div>
            </c:if>
        </div>
        <!-- j_security_check, j_username, j_password : 폼 기반 인증 처리 -->
        <form class="form-signin" method="post" 
            action="j_security_check">
            <div class="form-group">
                <label for="inputUserName" class="sr-only">User Name</label>
                <input type="text" class="form-control" placeholder="ID"
                    name="j_username" required autofocus />
            </div>
            <div class="form-group">
                <label for="inputPassword" class="sr-only">Password</label>
                <input type="password" class="form-control" placeholder="Password"
                    name="j_password" required autofocus />
            </div>
            <button class="btn btn btn-lg btn-success btn-block"
                type="submit">로그인</button>
        </form>
    </div>
</body>
</html>

login_failed.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%
//로그인 인증(login.jsp)에 실패 시 강제 이동
response.sendRedirect("login.jsp?error=1");
%>

logout.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%
    //로그아웃
    //security를 통해 로그인 인증을 할 때 웹 브라우저에 저장된 모든 사용자를 삭제함
    session.invalidate();
    response.sendRedirect("addProduct.jsp");
%>

예외처리

1. 프로그램이 처리되는 동안 특정한 문제가 발생 시 처리를 중단하고 다른 처리를 하는 것(오류 처리)

2. Page 디렉티브를 이용

   • errorPage 속성으로 오류 페이지 호출 <%@ page errorPage="오류 페이지 URL" %>
   • isErrorPage 속성으로 오류 페이지 만듦(나는 오류 페이지야) default는 false(생략 시) <%@ page isErrorPage="true" %>

3. web.xml web.xml 파일을 통해 오류 상태(404,500,널오류)와 오류 페이지를 보여줌

   <error-page>
    <error-code>오류 코드</error-code>
    <location>오류 페이지 URI</location>
   </error-page>
   

4. try-catch-finally
try{
    실행문
}catch(처리할 예외 유형 설정){
    예외 처리문
}finally{
    예외와 상관없이 무조건 실행(생략 가능)
}


### exceptionNoPage.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%> <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<div class="jumbotron">
    <div class="container">
        <h2 class="alert alert-danger">요청하신 페이지를 찾을 수 없습니다.</h2>
    </div>
</div>
<!-- 
중요!!!!!!!!!!!!!!!!
request.getRequestURL() : 오류 발생 시 해당 오류 페이지 경로를 출력 
                http://localhost:8090/ch04/addProduct.jsp
request.getQueryString() : 요청 파라미터(productId=P1234)
            결과 : http://localhost:8090/ch04/addProduct.jsp?productId=P1234
-->
<div class="container">
    <p><%=request.getRequestURL()%>?<%=request.getQueryString()%></p> 
    <p>
    <a href="/ch04/products.jsp" class="btn btn-secondary">
    상품 목록 &raquo;
    </a>
    </p> 


</div>

<jsp:include page="/ch03/bottom.jsp" />

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<link rel="stylesheet" href="/css/bootstrap.min.css" />
<title>상품 아이디 오류</title>
</head>
<body>
<!-- top 인클루드 시작 -->
    <jsp:include page="/ch03/top.jsp" />
<!-- top 인클루드 끝 -->

    <div class="jumbotron">
        <div class="container">
            <h2 class="alert alert-danger">해당 상품이 존재하지 않습니다.</h2>
        </div>
    </div>
    <!-- 
    중요!!!!!!!!!!!!!!!!
    request.getRequestURL() : 오류 발생 시 해당 오류 페이지 경로를 출력 
                    http://localhost:8090/ch04/addProduct.jsp
    request.getQueryString() : 요청 파라미터(productId=P1234)
                결과 : http://localhost:8090/ch04/addProduct.jsp?productId=P1234
    -->
    <div class="container">
        <p><%=request.getRequestURL()%>?<%=request.getQueryString()%></p> 
        <p>
        <a href="/ch04/products.jsp" class="btn btn-secondary">
        상품 목록 &raquo;
        </a>
        </p> 


    </div>

<!-- bottom 인클루드 시작 -->
    <jsp:include page="/ch03/bottom.jsp" />
<!-- bottom 인클루드 끝 -->    
</body>
</html>

1. 페이지에 태그 라이브러리 추가

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %> 

2. body 태그에 아래와 같이 추가

1) fmt:setLocale 설정

<!-- ko는 한글, en은 영어 -->
    <fmt:setLocale value="${param.language}"/>
    <fmt:bundle basename="resourceBundle.message">
<!-- 패키지명.파일명 으로 접근한다(ko는 resourceBundle.properties)-->

2)${param.language} 속성을 사용해서 Korean 클릭 시 languae의 값으로 ko를, English 클릭시 en을 파라미터로 보낸다.

<div class="text-right">
    <a href="?language=ko">Korean</a>|<a href="?language=en">English</a>
    <a href="logout.jsp" class="btn btn-sm btn-success pull-right">logout</a>
</div>

3. resourceBundle 패키지 및 properties 파일 생성 bundle : 꾸러미

message.properties

<!--순서는 key = value -->
title=\uC0C1\uD488 \uB4F1\uB85D
productId=\uC0C1\uD488 \uCF54\uB4DC
pname=\uC0C1\uD488\uBA85
unitPrice=\uAC00\uACA9
description=\uC0C1\uC138 \uC124\uBA85
manufacturer=\uC81C\uC870\uC0AC
category=\uBD84\uB958
unitsInStock=\uC7AC\uACE0\uC218
condition=\uC0C1\uD0DC
productImage=\uC774\uBBF8\uC9C0
condition_New=\uC2E0\uADDC \uC81C\uD488
condition_Old=\uC911\uACE0 \uC81C\uD488
condition_Refurbished=\uC7AC\uC0DD \uC81C\uD488
button=\uB4F1\uB85D

message_en.properties

<!--순서는 key = value -->
title=Product Addition
productId=Product ID
pname=Name
unitPrice=Unit Price
description=Description
manufacturer=Manufacturer
category=Category
unitsInStock=Units in Stock
condition=Condition
productImage=Imange
condition_New=New
condition_Old=Old
condition_Refurbished=Refurbished
button=Insert

4. 해당 값에 fmt:message 설정

   <div class="form-group row">
    <label class="col-sm-2"><fmt:message key="category" /></label>
    <div class="col-sm-3">
        <input type="text" name="category" class="form-control" />
    </div>
   </div>

addProduct.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %> 
<!DOCTYPE html>
<html>
<head>
<link rel="stylesheet" href="/css/bootstrap.min.css">
<script type="text/javascript" src="/ckeditor/ckeditor.js"></script>
<script type="text/javascript" src="/js/validation.js"></script>
<title>상품 등록</title>
</head>
<body>
<!-- ko는 한글, en은 영어 -->
    <fmt:setLocale value="${param.language}"/>
    <fmt:bundle basename="resourceBundle.message">
<!-- 패키지명.파일명 으로 접근한다(ko는 resourceBundle.properties)-->

<!-- top 인클루드 시작 -->
    <jsp:include page="/ch03/top.jsp" />
<!-- top 인클루드 끝 -->

<!-- content 시작 -->
    <div class="jumbotron">
        <div class="container">
            <h1 class="display-3"><fmt:message key="title" /></h1>
            <!-- key에는  message.properties에서 적어놓은 속성들을 적는다-->
        </div>
    </div>
    <div class="container">
        <div class="text-right">
            <a href="?language=ko">Korean</a>|<a href="?language=en">English</a>
            <a href="logout.jsp" class="btn btn-sm btn-success pull-right">logout</a>
        </div>
    <!-- addProduct_process.jsp : common-fileupload -->
    <!-- addProduct_process2.jsp : cos.jar -->
        <form name="newProduct" action="addProduct_process2.jsp" 
            method="post" class="form-horizontal" enctype="multipart/form-data">
            <div class="form-group row">
                <label class="col-sm-2"><fmt:message key="productId" /></label>
                <div class="col-sm-3">
                    <input type="text" name="productId" id="productId"
                        class="form-control" />
                </div>
            </div>
            <div class="form-group row">
                <label class="col-sm-2"><fmt:message key="pname" /></label>
                <div class="col-sm-3">
                    <input type="text" name="pname" id="pname"
                        class="form-control" />
                </div>
            </div>
            <div class="form-group row">
                <label class="col-sm-2"><fmt:message key="unitPrice" /></label>
                <div class="col-sm-3">
                    <input type="text" name="uniPrice" id="uniPrice"
                        class="form-control" />
                </div>
            </div>
            <div class="form-group row">
                <label class="col-sm-2"><fmt:message key="description" /></label>
                <div class="col-sm-5">
                    <textarea name="description" rows="2" cols="50" class="form-control"></textarea>
                </div>
            </div>
            <div class="form-group row">
                <label class="col-sm-2"><fmt:message key="manufacturer" /></label>
                <div class="col-sm-3">
                    <input type="text" name="manufacturer"
                        class="form-control" />
                </div>
            </div>
            <div class="form-group row">
                <label class="col-sm-2"><fmt:message key="category" /></label>
                <div class="col-sm-3">
                    <input type="text" name="category"
                        class="form-control" />
                </div>
            </div>
            <div class="form-group row">
                <label class="col-sm-2"><fmt:message key="unitsInStock" /></label>
                <div class="col-sm-3">
                    <input type="text" name="unitsInStock" id="unitsInStock"
                        class="form-control" />
                </div>
            </div>
            <div class="form-group row">
                <label class="col-sm-2"><fmt:message key="condition" /></label>
                <div class="col-sm-5">
                    <input type="radio" name="condition" id="condition1" value="new" />
                        <label for="condition1"><fmt:message key="condition_New" /></label>
                    <input type="radio" name="condition" id="condition2" value="old" />
                        <label for="condition2"><fmt:message key="condition_Old" /></label>
                    <input type="radio" name="condition" id="condition3" value="Refurbished" />
                        <label for="condition3"><fmt:message key="condition_Refurbished" /></label>
                </div>
            </div>
<!--             <div class="form-group row">
                <label class="col-sm-2">이미지</label>
                <div class="col-sm-5">
                    <input type="file" name="productImage" class="form-control" />
                </div>
            </div> -->
            <div class="form-group row">
                <label class="col-sm-2"><fmt:message key="productImage" /></label>
                <div class="col-sm-5">
                    <input type="file" name="productImage2" class="form-control" />
                </div>
            </div>
            <div class="form-group row">
                <div class="col-sm-offset-2 col-sm-10">
                    <input type="button" class="btn btn-primary" value="<fmt:message key="button" />" onclick="CheckAddProduct()"/>
                </div>

            </div>
        </form>    
    </div>
<!-- content 끝 -->
<script type="text/javascript">
CKEDITOR.replace("description");
</script>

<!-- bottom 인클루드 시작 -->
    <jsp:include page="/ch03/bottom.jsp" />
<!-- bottom 인클루드 끝 -->
</fmt:bundle>
</body>
</html>

시큐리티

1. 시큐리티란?

• 허가된 사용자만이 접근할 수 있도록 제한하는 보안 기능

2. 프로세스?

• 사용자가 웹 페이지에 접근
• JSP 컨테이너(Tomcat)는 요청된 페이지에 보안 제약(Constraints)이 있는지 확인
• 사용자에게 인증(authentication)을 요청
• 권한 부여(authorization) : JSP 컨테이너는 사용자가 해당 페이지에 접근할 수 있는지 확인. 승인

3. 역할?

• 사용자가 권한이 없는 데이터에 접근하는 것을 막음
• 스니핑(sniffing) : 웹 공격자가 전송 데이터를 중간에 가로채는 것 방지

4. 그래서 시큐리티란?

• 허가된 사용자만이 특정 웹 페이지에 접근할 수 있도록 제한하는 보안 기능
• 사용자가 권한이 없는 데이터에 접근하는 것을 막아줌
• 웹 공격자가 전송 데이터를 중간에 가로채는 것을 방지(스니핑 방지)

5. 선언적 시큐리티

• web.xml 파일(웹 어플리케이션(JSPBook)) 배포 설명자)에 보안 구성을 작성하여 수행
• 보안 역할(role), 보안 제약 사항(constraint), 인증 처리(login.jsp, login-failed.jsp) 설정

1) tomcat-users.xml 설정 34번째 줄<role>부터 주석 제거 <role rolename> 은 권한 <user username> 은 사용자

  <role rolename="tomcat"/>
  <role rolename="role1"/>
  <user username="tomcat" password="tomcat1234" roles="tomcat"/>
  <user username="both" password="both1234" roles="tomcat,role1"/>
  <user username="role1" password="role1234" roles="role1"/>

2) JSPBook web.xml 설정 마지막줄에 추가

     <!-- 시큐리티 admin 관리 시작 -->
<!--     <security-role>
        <description></description>
        <role-name>admin</role-name>
    </security-role> -->
    <!-- 시큐리티 제약 사항 설정 -->
    <security-constraint>
        <web-resource-collection>
            <web-resource-name>JSPBook</web-resource-name>
            <!-- 접근을 제한할 요청 경로 -->
            <url-pattern>/ch04/addProduct.jsp</url-pattern>
            <http-method>GET</http-method>
        </web-resource-collection>
        <auth-constraint>
            <description></description>
            <!-- 권한이 부여된 role 이름 -->
            <role-name>admin</role-name>
            <!-- 위의 admin과 url-pattern을 admin권한을 가진 사용자만 이용할 수 있도록 매핑 -->
        </auth-constraint>
    </security-constraint>
    <security-constraint>
        <web-resource-collection>
            <web-resource-name>JSPBook</web-resource-name>
            <!-- 접근을 제한할 요청 경로  -->
            <url-pattern>/ch03/*</url-pattern>
            <http-method>GET</http-method>
        </web-resource-collection>
        <auth-constraint>
            <description></description>
            <!-- 권한이 부여된 role 이름 -->
            <role-name>tomcat</role-name>
        </auth-constraint>
    </security-constraint>
    <!-- 시큐리티 인증 설정 -->
    <login-config>
        <!-- BASIC 인증 처리 기법으로 설정 -->
        <!-- <auth-method>BASIC</auth-method> -->
        <!-- FORM 기반 인증 처리 기법으로 설정 -->
        <auth-method>FORM</auth-method>
        <form-login-config>
            <!-- 인증 처리를 위한 로그인 페이지 설정 -->
            <form-login-page>/ch04/login.jsp</form-login-page>
            <!-- 인증 실패 시 오류 페이지 설정 -->
            <form-error-page>/ch04/login_failed.jsp</form-error-page>
        </form-login-config>
    </login-config>
    <!-- 시큐리티 역할 role1  관리 끝 -->
    <!-- 
        웹 어플리케이션이 시작할 때(톰켓을 시작할 때) DBCPInit 서블릿 클래스가
        자동으로 시작되고, init() 메서드가 호출됨
    -->
    <servlet>
        <servlet-name>oracleDriverLoader</servlet-name>
        <servlet-class>jdbc.DBCPInit</servlet-class>
        <load-on-startup>1</load-on-startup>
        <!-- 1 : 톰켓이 재 기동할 때 이 클래스를 가장 먼저 실행해라~ -->
    </servlet>

security01.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<title>Security</title>
</head>
<body>
    <h2>인증 성공했습니다.</h2>
    <h4>사용자명 : <%=request.getRemoteUser() %></h4>
    <h4>인증방법 : <%=request.getAuthType() %></h4>
    <h4>
        역할명(role) tomcat에 속한 사용자가 로그인한건가요?
        <%=request.isUserInRole("tomcat") %>
    </h4>
    <h4>
        역할명(role) role1에 속한 사용자가 로그인한건가요?
        <%=request.isUserInRole("role1") %>
    </h4>
</body>
</html>

login.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<title>Security</title>
<link rel="stylesheet" href="" />
</head>
<body>
    <!-- 폼 기반 인증 처리를 위해 j_security_check을 사용 -->
    <form name="loginForm" action="j_security_check" method="post">
        <p>사용자명 : <input type="text" name="j_username" /></p>
        <p>비밀번호 : <input type="password" name="j_password" /></p>
        <p><input type="submit" value="전송" /></p>
    </form>
</body>
</html>

login_failed.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<title>Security</title>
</head>
<body>
    <h2>인증 실패했습니다.</h2>
</body>
</html>

숫자만 : ^[0-9]*$
영문자만 : ^[a-zA-Z]*$
한글만 : ^[가-힣]*$
이메일 : /^[0-9a-zA-Z]([-_\.]?[0-9a-zA-Z])*@[0-9a-zA-Z]([-_\.]?[0-9a-zA-Z])*\.[a-zA-Z]{2,3}$/i
휴대전화 : ^01(?:0|1|[6-9])-(?:\d{3}|\d{4})-\d{4}$
전화번호 : ^\d{2,3}-\d{3,4}-\d{4}$ 
주민번호 : ^\d{6]\-[1-4]\d{6}
IP주소 : ([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})
URL : ^(file|gopher|news|nntp|telnet|https?|ftps?|sftp):\/\/([a-z0-9-]+\.)+[a-z0-9]{2,4}.*\$
날짜 : ^\d{2,4}\/\d{1,2}\/\d{1,2}$

http://regexlib.com에 정규식 관련 정보 있으니 찾아보기

6. 데이터 형식 유효성 검사

• 사용자가 폼 페이지의 입력 항목에 입력한 데이터 값이 특정 형태에 적합한지 검사하기 위해 정규 표현식을 사용하는 방법
• 특정한 규칙을 가진 문자열의 집합을 표현하는 데 사용하는 형식 언어
• 정규 표현식(regExp)에서 사용하는 기호를 메타 문자라고 함
• 메타 문자는 정규 표현식 내부에서 특정한 의미를 가진 문자

validation05.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<title>Validation</title>
</head>
<body>
<script type="text/javascript">
    function checkMember() {
        //id 체크 정규식 : 숫자, 영문만 입력 가능 
        var regExpId = /^[0-9a-z]+$/;
        //비밀번호 : 숫자, 특수문자 각 1회 이상, 영문은 2개 이상 사용하여 8자리 이상 입력
        var regExpPasswd = /(?=.*\d{1,50})(?=.*[~`!@#$%\^&*()-+=]{1,50})(?=.*[a-zA-Z]{2,50}).{8,50}$/;
        //이름 : 한글 검사
        var regExpName = /^[가-힣]*$/;
        //전화번호 형식인지 검사
        var regExpPhone = /^\d{2,3}-\d{3,4}-\d{4}$/;
        //이메일 형식인지 검사
        var regExpEmail = /^[0-9a-zA-Z]([-_\.]?[0-9a-zA-Z])*@[0-9a-zA-Z]([-_\.]?[0-9a-zA-Z])*\.[a-zA-Z]{2,3}$/i;


        var form = document.Member;

        var id = form.id.value;
        var passwd = form.passwd.value;
        var name = form.name.value;
        var phone = form.phone1.value + "-" + form.phone2.value + "-" + form.phone3.value;
        var email = form.email.value;

        //정규표현식.test(변수)
        if(!regExpId.test(id)){
            alert("아이디는 숫자, 영문만 입력 가능합니다.");
            form.id.select();
            return;
        }
        if(!regExpPasswd.test(passwd)){
            alert("숫자, 특수문자 각 1회 이상, 영문은 2개 이상 사용하여 8자리 이상 입력 가능합니다.");
            form.passwd.select();
            return;
        }
        if(!regExpName.test(name)){
            alert("이름은 한글만 입력해주세요");
            form.name.select();
            return;
        }
        if(!regExpPhone.test(phone)){
            alert("연락처 형식에 맞춰주세요");
            form.phone2.select();
            return;
        }
        if(!regExpEmail.test(email)){
            alert("이메일 형식에 맞춰주세요");
            form.email.select();
            return;
        }
        //모두 테스트 통과 시 submit 처리
        form.submit();
    }
</script>

<h3>회원 가입</h3>
<form name="Member" method="post" action="validation05_process.jsp">
    <p>아이디 : <input type="text" name="id"/></p>
    <p>비밀번호 : <input type="text" name="passwd"/></p>
    <p>이름: <input type="text" name="name"/></p>
    <p>연락처 :
        <select name="phone1">
            <option value="010">010</option>
            <option value="011">011</option>
            <option value="016">016</option>
            <option value="017">017</option>
            <option value="019">019</option>
        </select>
        <input type="text" maxlength="4" size="4" name="phone2" />
        <input type="text" maxlength="4" size="4" name="phone3" />
    </p>
    <p>이메일 : <input type="text" name="email"/></p>
    <p><input type="button" value="가입하기" onclick="checkMember()" />
</form>

</body>
</html>

jstl_fmt02.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %> 
<!DOCTYPE html>
<html>
<head>
<title>숫자 형식 맞춰 화면출력</title>
</head>
<body>
<p>숫자 : <fmt:formatNumber value="3200100" /></p>
<p>설정된 숫자를 숫자 형식으로 표현 : 
    <fmt:formatNumber value="3200100" type="number" />
</p>
<p>천 단위 구분 기호(,) 없이 표현 :
    <fmt:formatNumber value="3200100" type="number" groupingUsed="false"/>
</p>
    <!-- groupingUsed가 true여야만 통화 형식으로 표현된다  -->
<p>천 단위 구분 기호(,) 있고, 통화 형식으로 표현 :
    <fmt:formatNumber value="3200100" type="currency" groupingUsed="true"/>
</p>
<p>천 단위 구분 기호(,) 있고, 통화 형식으로 표현 :
    <fmt:formatNumber value="3200100" type="currency" currencySymbol="&"/>
</p>
<p>퍼센트 형식 :
    <fmt:formatNumber value="0.45" type="percent"/>
</p>
<p>소수점 자리 표현 (최대 10자리, 소수점 둘째 자리):
    <fmt:formatNumber value="3200100" minIntegerDigits="10" minFractionDigits="2"/>
</p>
<p>패턴 지정:
    <fmt:formatNumber value="3200100.45" pattern=".000"/>
</p>
<p>패턴 지정:
    <fmt:formatNumber value="3200100.45" pattern="#,#00.0#"/>
</p>
</body>
</html>

숙제 ⦁ 다음 조건에 맞게 작업해보자

1) WebContent/js/ 폴더에 validationBook.js 파일 생성 2) 생성된 validationBook.js 파일에 유효성 검사를 위한 핸들러 함수 작성

• 도서 아이디가 ISBN으로 시작되고 숫자를 포함하여 문자 길이가 5~12자 인지 검사
• 도서명의 문자 길이가 4~12인지 검사
• 가격의 문자 길이가 0인지 숫자인지 검사(길이가 0이면 안됨)
• 가격이 음수인지 검사(음수이면 안됨)
• 재고 수가 숫자인지 검사

validationBook.js

function CheckAddBook(){
    var bookCode = document.getElementById("bookCode");    
    var bookName = document.getElementById("bookName");    
    var price = document.getElementById("price");
    var stock = document.getElementById("stock");

    //도서 아이디가 ISBN으로 시작되고 숫자를 포함하여 문자 길이가 5~12자 인지 검사
    if(!check(/^[0-9]{5,12}$/,bookCode,
        "[상품 코드]\nISBN으로 시작되고 숫자를 포함하여 문자 길이를  5~12자까지 입력하세요.")){
        //submit 안함
        return false;
    }
    //도서명의 문자 길이가 4~12인지 검사
    if(bookName.value.length < 4 || bookName.value.length > 12){
        alert("[도서명]\n최소 4자에서 최대 12자까지 입력하세요");
        bookName.select();
        bookName.focus();
        return false;
    }
    //가격의 문자 길이가 0인지 숫자인지 검사(길이가 0이면 안됨)
    if(price.value.length == 0 || isNaN(price.value)){
        alert("[가격]\n숫자만 입력해주세요");
        price.select();
        price.focus();
        return false;
    }//가격이 음수인지 검사(음수이면 안됨)
    if(price.value < 0){
        alert("[가격]\n음수는 입력할 수 없습니다.");
        price.select();
        price.focus();
        return false;
    }
    //재고 수가 숫자인지 검사
    if(isNaN(stock.value)){
        alert("[재고 수]\n숫자만 입력해주세요");
        stock.select();
        stock.focus();
        return false;
    }

    //regExg : 정규표현식, e : 대상객체, msg : alert할 메시지
    //정규표현식에 맞으면 true, 다르면 false를 요청한 곳으로 return
    function check(regExp, e, msg){
        //정규식에 맞으면 바로 true를 return
        if(regExp.test(e.value)){
            return true;
        }
        //정규식에 맞지 않으면..
        alert(msg);
        e.select();
        e.focus();
        //form이 submit 되지 않음
        return false;
    }//end check()
    document.newBook.submit();
}

3) WebContent/ch08/ 폴더에 addBook.jsp 파일 작성

• 폼 페이지에서 입력되는 도서 아이디, 도서명, 가격, 재고 수의 유효성 검사를 위해 핸들러 함수가 저장되어 있는 validationBook.js 파일을 연결하도록 작성
• [등록] 버튼을 클릭하면 핸들러 함수가 실행되도록 onclick 속성을 작성

addBook.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<link rel="stylesheet" href="/css/bootstrap.min.css">
<script type="text/javascript" src="/ckeditor/ckeditor.js"></script>
<script type="text/javascript" src="/js/validationBook.js"></script>
<title>도서 등록</title>
</head>
<body>
    <jsp:include page="/ch03/top.jsp" />

    <div class="jumbotron">
        <div class="container">
            <h2 class="display-3">도서 등록</h2>
        </div>
    </div>
    <div class="container">    
    <form name="newBook" action="processAddBook.jsp" 
                method="post" class="form-horizontal" enctype="multipart/form-data">
                <div class="form-group row">
                    <label class="col-sm-2">도서 코드</label>
                    <div class="col-sm-3">
                        <input type="text" name="bookCode" id="bookCode"
                            class="form-control" />
                    </div>
                </div>
            <div class="form-group row">
                <label class="col-sm-2">도서명</label>
                <div class="col-sm-3">
                    <input type="text" name="bookName" id="bookName"
                        class="form-control" />
                </div>
            </div>
            <div class="form-group row">
                <label class="col-sm-2">가격</label>
                <div class="col-sm-3">
                    <input type="text" name="price" id="price"
                        class="form-control" />
                </div>
            </div>
            <div class="form-group row">
                <label class="col-sm-2">저자</label>
                <div class="col-sm-3">
                    <input type="text" name="writer"
                        class="form-control" />
                </div>
            </div>
            <div class="form-group row">
                <label class="col-sm-2">출판사</label>
                <div class="col-sm-3">
                    <input type="text" name="publisher"
                        class="form-control" />
                </div>
            </div>                        
            <div class="form-group row">
                <label class="col-sm-2">출판일</label>
                <div class="col-sm-3">
                    <input type="text" name="bookDate"
                        class="form-control" />
                </div>
            </div>                        
            <div class="form-group row">
                <label class="col-sm-2">총페이지 수</label>
                <div class="col-sm-3">
                    <input type="text" name="bookPage"
                        class="form-control" />
                </div>
            </div>
            <div class="form-group row">
                <label class="col-sm-2">상세정보</label>
                <div class="col-sm-5">
                    <textarea name="bookInfo" rows="2" cols="50" class="form-control"></textarea>
                </div>
            </div>
            <div class="form-group row">
                <label class="col-sm-2">분류</label>
                <div class="col-sm-3">
                    <input type="text" name="category"
                        class="form-control" />
                </div>
            </div>
            <div class="form-group row">
                <label class="col-sm-2">재고 수</label>
                <div class="col-sm-3">
                    <input type="text" name="stock" id="stock"
                        class="form-control" />
                </div>
            </div>
            <div class="form-group row">
                <label class="col-sm-2">상태</label>
                <div class="col-sm-5">
                    <input type="radio" name="condition" id="condition1" value="new" />
                        <label for="condition1">신규도서</label>
                    <input type="radio" name="condition" id="condition2" value="Refurbished" />
                        <label for="condition2">중고도서</label>
                    <input type="radio" name="condition" id="condition3" value="ebook" />
                        <label for="condition3">E-Book</label>
                </div>
            </div>
            <div class="form-group row">
                <label class="col-sm-2">이미지</label>
                <div class="col-sm-5">
                    <input type="file" name="filename" class="form-control" />
                </div>
            </div>
            <div class="form-group row">
                <div class="col-sm-offset-2 col-sm-10">
                    <input type="submit" class="btn btn-primary" value="등록" onclick="CheckAddBook()"/>
                </div>

            </div>
        </form>    
    </div>
<!-- content 끝 -->
<script type="text/javascript">
CKEDITOR.replace("bookInfo");
</script>

<!-- bottom 인클루드 시작 -->
    <jsp:include page="/ch03/bottom.jsp" />
<!-- bottom 인클루드 끝 -->
</body>
</html>

4) Src.dto 패키지에 Book.java 작성

• 위 그림에서 입력 받는 요소들을 담을 자바빈 클래스 작성
• 멤버변수, getter/setter 메소드, toString 메소드 생성

Book.java

package dto;

public class Book {

    private String bookCode;
    private String bookName;
    private Integer price;
    private String writer;
    private String publisher;
    private String bookDate;
    private Integer bookPage;
    private String bookInfo;
    private String category;
    private long stock;
    private String condition;
    private String filename;


    public Book() {
        super();
    }

    //생성자 
    public Book(String bookCode, String bookName, Integer price) {
        super();
        this.bookCode = bookCode;
        this.bookName = bookName;
        this.price = price;
    }

    public String getBookCode() {
        return bookCode;
    }
    public void setBookCode(String bookCode) {
        this.bookCode = bookCode;
    }
    public String getBookName() {
        return bookName;
    }
    public void setBookName(String bookName) {
        this.bookName = bookName;
    }
    public Integer getPrice() {
        return price;
    }
    public void setPrice(Integer price) {
        this.price = price;
    }
    public String getWriter() {
        return writer;
    }
    public void setWriter(String writer) {
        this.writer = writer;
    }
    public String getPublisher() {
        return publisher;
    }
    public void setPublisher(String publisher) {
        this.publisher = publisher;
    }
    public String getBookDate() {
        return bookDate;
    }
    public void setBookDate(String bookDate) {
        this.bookDate = bookDate;
    }
    public Integer getBookPage() {
        return bookPage;
    }
    public void setBookPage(Integer bookPage) {
        this.bookPage = bookPage;
    }
    public String getBookInfo() {
        return bookInfo;
    }
    public void setBookInfo(String bookInfo) {
        this.bookInfo = bookInfo;
    }
    public String getCategory() {
        return category;
    }
    public void setCategory(String category) {
        this.category = category;
    }
    public long getStock() {
        return stock;
    }
    public void setStock(long stock) {
        this.stock = stock;
    }
    public String getCondition() {
        return condition;
    }
    public void setCondition(String condition) {
        this.condition = condition;
    }
    public String getFilename() {
        return filename;
    }
    public void setFilename(String filename) {
        this.filename = filename;
    }

    @Override
    public String toString() {
        return "Book [bookCode=" + bookCode + ", bookName=" + bookName + ", price=" + price + ", writer=" + writer
                + ", publisher=" + publisher + ", bookDate=" + bookDate + ", bookPage=" + bookPage + ", bookInfo="
                + bookInfo + ", category=" + category + ", stock=" + stock + ", condition=" + condition + ", filename="
                + filename + "]";
    }



}

5) src.ch08.com.dao 패키지에 BookRepository.java 클래스 생성

• src.ch04.com.dao.ProductRepository.java 클래스를 참고하여 적합하게 작성

BookRepository.java

package ch04.com.dao;

import java.util.ArrayList;
import java.util.List;

import dto.Book;

//자바빈즈로 사용할 상품 데이터 접근 클래스
public class BookRepository {
    private List<Book> listOfBooks = new ArrayList<Book>();

    //싱글톤 패턴
    private static BookRepository instance = new BookRepository();
    public static BookRepository getInstance() {
        return instance;
    }

    //생성자
    public BookRepository() {
        Book hbook = new Book("9788983928207", "해리 포터와 마법사의 돌 (미나리마 에디션)", 30000);
        hbook.setWriter("J.K. 롤링");
        hbook.setPublisher("문학수첩");
        hbook.setBookDate("2020-10-20");
        hbook.setBookPage(368);
        hbook.setBookInfo("해리 포터 미나리마 에디션 시리즈");
        hbook.setCategory("외국판타지/환상소설");
        hbook.setStock(100);
        hbook.setCondition("New");
        hbook.setFilename("B1234.jpg");

        Book dbook = new Book("9791165343729", "달러구트 꿈 백화점 2 ", 13800);
        dbook.setWriter("이미예");
        dbook.setPublisher("팩토리나인");
        dbook.setBookDate("2021-07-27");
        dbook.setBookPage(308);
        dbook.setBookInfo("달러구트 꿈 백화점 2 - 단골손님을 찾습니다");
        dbook.setCategory("한국판타지/환상소설");
        dbook.setStock(1000);
        dbook.setCondition("EBook");
        dbook.setFilename("B1235.jpg");

        Book sbook = new Book("9791157675982", "2022 수제비 정보처리기사 실기 FINAL 실전 모의고사 ", 25000);
        sbook.setWriter("NCS 정보처리기술사 연구회");
        sbook.setPublisher("건기원");
        sbook.setBookDate("2021-06-15");
        sbook.setBookPage(474);
        sbook.setBookInfo("수험생 입장에서 제대로 쓴 합격 비법서");
        sbook.setCategory("수험서/자격증");
        sbook.setStock(1000);
        sbook.setCondition("Refurbished");
        sbook.setFilename("B1236.jpg");

        listOfBooks.add(hbook);
        listOfBooks.add(dbook);
        listOfBooks.add(sbook);
    }
    //저장된 모든 상품 가져오기
    public List<Book> getAllBooks(){
        return listOfBooks;
    }

    //상품  상세정보 가져오기
    public Book getBookByCode(String bookCode) {
        Book BookByCode = null;

        for(int i=0; i<listOfBooks.size(); i++) {
            Book book = listOfBooks.get(i);

            if(book!=null&&book.getBookCode()!=null&&
                    book.getBookCode().equals(bookCode)) {
                BookByCode = book;
                break;
            }
        }
        return BookByCode;
    }

    //상품 추가
    public void addBook(Book book) {
        listOfBooks.add(book);
    }


}

6) WebContent/ch08/ 폴더에 addBook_process.jsp 파일 작성

• addBook.jsp 요청 시 담긴 폼 데이터를 받아 BookRepository 클래스를 통해 생성한 객체에 넣어줌

ProcessAddBook.jsp

<%@page import="dto.Book"%>
<%@page import="ch04.com.dao.BookRepository"%>
<%@page import="java.util.Enumeration"%>
<%@page import="com.oreilly.servlet.multipart.DefaultFileRenamePolicy"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<%@ page import="com.oreilly.servlet.MultipartRequest"%>
<!DOCTYPE html>
<html>
<head>
<title>cos.jar 도서 업로드</title>
</head>
<body>

<%
    request.setCharacterEncoding("UTF-8");
    //웹 어플리케이션상의 절대 경로
    String realFolder = "C:\\JSPSpring\\workspace\\JSPBook\\WebContent\\upload";

    String filename="";

    //최대 업로드될 파일의 크기 5MB
    int maxSize = 5*1024*1024;

    //인코딩 유형
    String encType = "UTF-8";

    //cos.jar 라이브러리의 핵심 클래스
    MultipartRequest multi = new MultipartRequest(
            request, realFolder, maxSize, encType, new DefaultFileRenamePolicy()
            );
    //폼 데이터 처리
    String bookCode = multi.getParameter("bookCode");
    String bookName = multi.getParameter("bookName");
    String price = multi.getParameter("price");
    String writer = multi.getParameter("writer");
    String publisher = multi.getParameter("publisher");
    String bookDate = multi.getParameter("bookDate");
    String bookPage = multi.getParameter("bookPage");
    String bookInfo = multi.getParameter("bookInfo");
    String category = multi.getParameter("category");
    String stock = multi.getParameter("stock");
    String condition = multi.getParameter("condition");

    Integer bprice;
    if(price.isEmpty()){
        bprice = 0;
    }else{
        bprice = Integer.valueOf(price);
    }

    Integer bpage;
    if(bookPage.isEmpty()){
        bpage = 0;
    }else{
        bpage = Integer.valueOf(bookPage);
    }

    long bstock;
    if(stock.isEmpty()){
        bstock = 0;
    }else{
        bstock = Long.valueOf(stock);
    }

    //파일객체 처리
        //multi객체 안에는 request 객체가 들어있고, request객체 안에는 파일 객체가 있음
        Enumeration files = multi.getFileNames();
        //productImage2
        String fname = (String)files.nextElement();
        //폼 페이지에서 전송되어 서버에 업로드된 파일을 가져옴
        String fileName = multi.getFilesystemName(fname);

        out.print("fname : " + fname + ", fileName : " + fileName);

        //싱글톤패턴
        BookRepository dao =  BookRepository.getInstance();

        Book newBook = new Book();
        newBook.setBookCode(bookCode);
        newBook.setBookName(bookName);
        newBook.setPrice(bprice);
        newBook.setWriter(writer);
        newBook.setPublisher(publisher);
        newBook.setBookDate(bookDate);
        newBook.setBookPage(bpage);
        newBook.setBookInfo(bookInfo);
        newBook.setCategory(category);
        newBook.setStock(bstock);
        newBook.setCondition(condition);


        //파일 객체의 파일명(fileName : P1237.jpg)
        newBook.setFilename(fileName);
        //dao : data access object(여기서는 메모리 DB라고 생각)
        dao.addBook(newBook);
        //상품 목록으로 리다이렉트
        response.sendRedirect("books.jsp");
    %>

    </body>
    </html>

7) WebContent/ch08/products.jsp 생성

• addBook.jsp와 addBook_process.jsp를 통해 추가된 book정보를 목록으로 출력
• WebContent/ch04/products.jsp 참고

Books.jsp

<%@page import="dto.Book"%>
<%@page import="ch04.com.dao.BookRepository"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html>
<html>
<head>
<link rel="stylesheet" href="/css/bootstrap.min.css" />
<title>도서 목록</title>
</head>
<body>
<%
BookRepository bookDAO = BookRepository.getInstance();
%>
    <jsp:include page="/ch03/top.jsp" />
    <div class="jumbotron">
    <div class="container">
        <h1 class="display-3">도서 목록</h1>
    </div>
    </div>
<%
    List<Book> listOfBooks = bookDAO.getAllBooks();
%>    
    <div class="container">
        <div class="row" align="center">
        <%
            for(int i=0; i<listOfBooks.size(); i++){
                Book book = listOfBooks.get(i);
        %>
            <div class="col-md-4">
                <img src="/upload/<%=book.getFilename()%>" style="width: 350px; height: 370px"/>
                <h3><%=book.getBookName() %></h3>
                <p><%=book.getBookInfo() %></p>
                <p><%=book.getWriter()%>|<%=book.getPublisher()%>|<%=book.getPrice() %>원</p>
                <a href="book.jsp?id=<%=book.getBookCode() %>" class="btn btn-secondary" role="button">상세 정보&raquo;</a>

            </div>
        <%
            }
        %>

        </div>
    </div>        
    <jsp:include page="/ch03/bottom.jsp" />            
</body>
</html>