SpringMVCStudy 메모

▶ SpringMVC Study

1. Spring MVC.txt

■■■ Spring MVC ■■■

1. 웹 개발을 위한 MVC 패턴이 적용된 Spring Framework.
   Spring 에서는 DispatcherServlet 클래스가 컨트롤러 역할을 수행하게 된다.

2. Spring MVC 의 주요 구성 요소
- DispatcherServlet
- HandlerMapping
- Controller : 사용자 정의 Controller. 액션 처리. 우리가 작성
- ModelAndView
- ViewResolver 
- view : 결과 출력. 우리가 작성.
- web.xml : DispatcherServlet 객체 등록. 우리가 작성
- dispatcher-servlet.xml : Controller 객체 등록. 우리가 작성.

3. Spring MVC 실행 흐름
- 사용자 요청 → DispatcherServlet
- DispatcherServlet → HandlerMapping 에 주소 분석 요청
- DispatcherServlet → 특정 Controller 객체 호출 및 결과 수신
       결과는 ModelAndView 객체
※ ModelAndView 객체
    : View 객체 정보와 결과값이 들어있는 객체.

- DispatcherServlet → ViewResolver 에 View 객체 분석 요청
- Dispatcherservelt → 특정 View 객체에 Model 객체를 넘겨주고
       결과 출력.

4. Spring MVC 에서 우리가 해야 할 일

- Controller
  액션 처리를 담당하는 Controller 클래스 작성.
  Annotation 을 사용하거나, Controller 인터페이스를 구현하여 작성

- View
  결과 출력용 JSP 페이지 작성.

- web.xml
  서블릿 주소와 DispatcherServlet 클래스 등록

- dispathcer-servlet.xml
  우리가 작성한 Controller 객체 등록
  URL 매핑 주소 등록

- 필요한 경우 업무 로직 적용 및 수행 가능한 
          Model 관련 계층 서비스 구성
   ·Connection 
   ·DTO
   ·DAO
      :

※ Spring 이 스트럿츠를 비롯하여 다양한 웹 프레임워크와
   비교적 연동이 잘 되는 편이기는 하지만
   서로 다른 두 프레임워크를 연동하기 위해서는
   설정의 중복 등 개발 과정에서 불편함이 존재할 수 밖에 없다. 
   따라서 Spring 이 자체적으로 제공하는 MVC 프레임워크를 사용하게 되면
   Spring 이 제공하는 AOP, 트랜잭션 처리, IoC / DI 등의 기능을
   그대로 사용하면서 MVC 패턴에 기반하여 웹 어플리케이션을 개발할 수 있다.
   또한, 다른 프레임워크와 Spring 을 연동하기 위해서
   설정을 중복해서 적용해야 하거나.. 하는 개발과정에서 나타나는
   불편을 해소할 수 있게 된다. 

----------------------------------------------------------------------------------
■■■ Spring MVC 프로젝트 실습 01 ■■■

○ Perspective
   : JavaEE

○ 다이나믹 웹 프로젝트 생성 (비STS 버전)
   : Mvc01

○ 톰캣 서버 등록 및 포트(port) 설정 (인코딩 필터 적용 이전)
   : port 3306 / URIEncoding="UTF-8"

○ 기타 환경 설정
   : 기본 환경 설정은 『web_standard.epf』를 통해 구성
     (폰트, 줄번호, 편집포맷, 인코딩방식, 템플릿 등...)

○ Spring MVC 환경 설정을 위한 라이브러리 등록
   : WebContent > WEB-INF > lib 경로에 등록
     - 경로 1 → C:\s-f-3.0.2-with-docs\dist
       ·파일1 → org.springframework.aop-3.0.2.RELEASE.jar
       ·파일2 → org.springframework.asm-3.0.2.RELEASE.jar
       ·파일3 → org.springframework.beans-3.0.2.RELEASE.jar
       ·파일4 → org.springframework.context-3.0.2.RELEASE.jar
       ·파일5 → org.springframework.core-3.0.2.RELEASE.jar
       ·파일6 → org.springframework.expression-3.0.2.RELEASE.jar
       ·파일7 → org.springframework.jdbc-3.0.2.RELEASE.jar
       ·파일8 → org.springframework.transaction-3.0.2.RELEASE.jar
       ·파일9 → org.springframework.web.servlet-3.0.2.RELEASE.jar
       ·파일10 → org.springframework.web-3.0.2.RELEASE.jar

     - 경로2 → C:\s-f-3.0.2-dependencies\org.apache.commons\cohttp://m.springsource.org.apache.commons.logging\1.1.1
·파일11 → cohttp://m.springsource.org.apache.commons.logging-1.1.1.jar

     - 경로3 → C:\oraclexe\app\oracle\product\11.2.0\server\jdbc\lib
        ·파일12 → ojdbc6.jar
     - 경로4 → C:\Downloads\12_JSTL\jakarta-taglibs-standard-1.1.2\lib
                (JSTL 다운로드 경로)
        ·파일13 → jstl.jar
        ·파일14 → standard.jar

○ 물리적 파일 구성
    - HelloController.java
    - Hello.jsp
    - dispatcher-servlet.xml
    - web.xml
    - hello.action

    ※ 『dispatcher-servlet.xml』 파일의 기본 설정 내용(템플릿)을 구성하기 위해
        스프링 DOC 의 내용을 참고해서 작성할 수 있도록 한다.
        · 경로 → C:\s-f-3.0.2-with-docs\docs\spring-framework-reference\pdf
        · 파일 → spring-framework-reference.pdf 
        · 내용(위치) → 해당 pfd 문서의 페이지 번호 상 425 페이지  
 파일 구조의 바로가기 인덱스 상 450/805 페이지
        ·해당 위치로 이동하면 XML 파일에 대한 샘플(템플릿) 코드가 있다.
    이 내용을 복사하여 dispatcher-servlet.xml 파일의 기본 내용으로 작성한다.

○ 사용자 최초 요청 주소
    http://localhost:3306/Mvc01/hello.action


※ 우리가 작성한 Mvc01 프로젝트의 실행 및 처리 과정 정리

① 외부 요청
           http://localhost:3306/Mvc01/hello.action
   ===========================
http://www.test.co.kr

  → web.xml 관여
     (→ Front Controller 등록 → DispatcherServlet 등록)

② DispatcherServlet 요청 접수

   → web.xml → DispatcherServlet 등록
      web.xml → URL 패턴 등록

   → 사용자 요청 분석 → 특정 컨트롤러 지정

③ 해당 컨트롤러의 특정 메소드 호출 (액션처리, ModelAndView 객체 반환)

   → 사용자의 요청에 맞는 액션 처리

   → 결과 데이터가 들어있는 모델 객체 준비

   → 뷰 정보 (JSP 페이지 정보) 반환

※ JSP 페이지 정보
    - 여기서는 객체가 아닌 경로 포함된 View 페이지의 이름

④ 뷰 페이지에서 최종 웹 페이지를 작성

   → JSP 페이지 내에서 ELL 이나 JSTL 등의 표기 사용 가능

⑤ 응답 완료~!!! 
----------------------------------------------------------------------------------

■■■ Spring MVC 프로젝트 실습 02 ■■■

○ Perspective
   : JavaEE

○ 다이나믹 웹 프로젝트 생성 (비STS 버전)
   : Mvc02

○ 기본 환경 구성 및 라이브러리 설정
   :Mvc00 (우리가 임의로 구성해둔 샘플)로 부터
    src, WebContent 디렉터리 복사 & 덮어쓰기

○ 실습 성격
   : 데이터 송수신 관련 실습 (Spring MVC 패턴)

○ 물리적 파일 구성
    - SendController.java  → 컨트롤러 객체
    - Send.jsp → 뷰 객체

    - ReceiveController.java → 컨트롤러 객체
    - Receive.jsp → 뷰 객체

    - web.xml → DispatcherServlet 객체 등록 / URL 매핑 주소 등록
    - dispatcher-servlet.xml → 컨트롤러 객체 등록 / URL 매핑 주소 등록

    - send.do → 이클립스 실행 과정에서 요청을 위한 빈 파일

    
○ 사용자 최초 요청 주소
    http://localhost:3306/Mvc02/send.do


----------------------------------------------------------------------------------

■■■ Spring MVC 프로젝트 실습 03 ■■■

○ Perspective
   : JavaEE

○ 다이나믹 웹 프로젝트 생성 (비STS 버전)
   : Mvc03

○ 기본 환경 구성 및 라이브러리 설정
   :Mvc00 (우리가 임의로 구성해둔 샘플)로 부터
    src, WebContent 디렉터리 복사 & 덮어쓰기

○ 실습 성격
   : 데이터 송수신 관련 실습 (Spring MVC 패턴)
     JDBC 모듈 추가 활용
     SimpleDriverDataSource 클래스(객체) 활용

○ 기능 구현
    : 사용자로부터 이름, 전화번호, 정보를 입력받아 데이터 베이스에 저장
      저장된 이름, 전화번호 항목을 데이터베이스로부터 읽어 화면에 구성

○ 사전 작업
    - TBL_MEMBERLIST 테이블 생성
    - MEMBERLISTSEQ 생성
    - 샘플 데이터 입력 및 조회

○ 기본 레이아웃 (페이지화면 구성)
   이름 [ ] → <input type="text">
   전화 [ ]  → <input type="text">
     <회원 추가> → <button type="button">

   전체 인원 수 : 2명   → <p>...</p>
   ------------------   → <table>...</table>
   번호 이름 전화번호
    1   노..  010..
    2   김..  010..
   ------------------



○ 물리적 파일 구성
    - Mvc03_scott.sql  → 데이터베이스 관련 객체 구성 및 실습 데이터 준비
    
    - MemberDTO.java  → 사용자 정의 자료형 클래스 (DTO 활용)

    - IMemberDAO.java  → 인터페이스
    - MemberDAO.java  → 데이터베이스 액션 처리 클래스 
 → Connection 객체에 대한 의존성 주입
         (의존성 주입을 위한 준비 필요)   

    - MemberListController.java  → 사용자 정의 컨트롤러 클래스
    리스트 출력 액션
       DAO 객체에 대한 의존성 주입   
    (의존성 주입을 위한 준비 필요) 

    - MemberList.jsp   → 회원 리스트 출력용 뷰
     회원 데이터 입력(추가) 폼 화면 구성

    - MemberInsertController.java → 사용자 정의 컨트롤러
                                     회원 데이터 추가
     DAO 객체에 대한 의존성 주입   
     (의존성 주입을 위한 준비 필요)

    - web.xml   → DispatcherServlet 객체 등록 
     URL 매핑 주소 등록

    - dispatcher-servlet.xml   → 컨트롤러 객체 등록 
     URL 매핑 주소 등록
     SimpleDriverDataSource 객체 등록
     의존 객체 주입 설정
     DAO 객체 등록

    - memberlist.do   → 이클립스 실행 과정에서 요청을 위한 빈 파일

    
○ 사용자 최초 요청 주소
    http://localhost:3306/Mvc03/memberlist.do


----------------------------------------------------------------------------------

■■■ Spring MVC 프로젝트 실습 04 ■■■

○ Perspective
   : JavaEE

○ 다이나믹 웹 프로젝트 생성 (비STS 버전)
   : Mvc04

○ 기본 환경 구성 및 라이브러리 설정
   :Mvc00 (우리가 임의로 구성해둔 샘플)로 부터
    src, WebContent 디렉터리 복사 & 덮어쓰기

○ 실습 성격
   : 직원 관리 프로그램 (Spring MVC 패턴)
     JDBC 모듈 추가 활용
     SimpleDriverDataSource 클래스(객체) 활용

○ 기능 구현 (데이터 각 유형별 CRUD 실습)
    - 직원 정보 입력, 출력, 수정, 삭제 기능 구현.
    - 지역 정보 입력, 출력, 수정, 삭제 기능 구현.
    - 부서 정보 입력, 출력, 수정, 삭제 기능 구현.
    - 직위 정보 입력, 출력, 수정, 삭제 기능 구현.
    - 로그인 / 로그아웃 기능 구현
      → 관리자 및 일반 직원 로그인 구분.
    ==> Spring MVC, JSP/Servlet, Oracle, HTML/CSS/Javascript, AJAX
        , jQuery, EL, JSTL 표현 등 사용.

○ 사전 작업 → 테이블 및 시퀀스, 주요 쿼리문, 샘플 데이터 등 구성
   - EMPLOYEE   직원
   - REGION     지역
   - DEAPRTMENT 부서
   - POSITION   직위
   - 샘플 데이터 입력...

○ 사전 작업
    - TBL_MEMBERLIST 테이블 생성
    - MEMBERLISTSEQ 생성
    - 샘플 데이터 입력 및 조회

○ 기본 레이아웃 (페이지화면 구성)
   이름 [ ] → <input type="text">
   전화 [ ]  → <input type="text">
     <회원 추가> → <button type="button">

   전체 인원 수 : 2명   → <p>...</p>
   ------------------   → <table>...</table>
   번호 이름 전화번호
    1   노..  010..
    2   김..  010..
   ------------------



○ 물리적 파일 구성
    #00. Mvc04_scott.sql  → 데이터베이스 관련 객체 구성 및 실습 데이터 준비
    
    #01. Employee.java  → DTO 계층, 직원 데이터 자료형 클래스.
    #02. Department.java  → DTO 계층, 부서 데이터 자료형 클래스.
    #03. Region.java  → DTO 계층, 지역 데이터 자료형 클래스.
    #04. Position.java  → DTO 계층, 직위 데이터 자료형 클래스.

    #05. IEmployeeDAO.java  → 인터페이스.
    #06. IDepartmentDAO.java    → 인터페이스.
    #07. IRegionDAO.java  → 인터페이스.
    #08. IPositionDAO.java  → 인터페이스.

    #09. EmployeeDAO.java     → 데이터베이스 액션 처리 클래스
              직원 데이터 CRUD 액션
                     Connection 객체에 대한 의존성 주입 준비
               (인터페이스 속성 구성 / setter 구성)


    #10. DepartmentDAO.java     → 데이터베이스 액션 처리 클래스
      직원 데이터 CRUD 액션
                      Connection 객체에 대한 의존성 주입 준비
          (인터페이스 속성 구성 / setter 구성)


    #11. RegionDAO.java     → 데이터베이스 액션 처리 클래스
          직원 데이터 CRUD 액션
                    Connection 객체에 대한 의존성 주입 준비
          (인터페이스 속성 구성 / setter 구성)

    #12. PostionDAO.java   →  데이터베이스 액션 처리 클래스
        직원 데이터 CRUD 액션
                         Connection 객체에 대한 의존성 주입 준비
                  (인터페이스 속성 구성 / setter 구성)

   
    #13. EmployeeMenu.jsp    → 메인 메뉴 뷰 페이지.
      로그아웃 기능 포함.
    #14. menuStyle.css    → 메뉴 스타일 구성.

    #15. EmployeeList.jsp      → 직원 리스트 출력 페이지.
    #16. main.css    → 메인 스타일 구성
 

    #17. EmployeeListController.java  → 사용자 정의 컨트롤러 클래스
      (employeelist.action)       리스트 출력 액션
         DAO 객체에 대한 의존성 주입   
      (의존성 주입을 위한 준비 필요)


   #18. web.xml   → DispatcherServlet 객체 등록 
     URL 매핑 주소 등록

   #19. dispatcher-servlet.xml   → 컨트롤러 객체 등록 
     URL 매핑 주소 등록
     SimpleDriverDataSource 객체 등록
     의존 객체 주입 설정
     DAO 객체 등록

   #20. employeelist.action   → 이클립스 실행 과정에서 요청을 위한 빈 파일

   #21. EmployeeInsertForm.jsp   → 
   

   #22. EmployeeInsertFormController.java
        (employeeinsertform.action)

   #23. jquery-ui.js
   #24. jquery-ui.css
   #25. images
   
   #26. AjaxController.java
        (ajax.action)

   #27. Ajax.jsp

   #28. EmployeeInsertController.java
        (employeeinsert.action)


   #29. EmployeeUpdateForm.jsp

   #30. EmployeeUpdateFormController.java
      (employeeupdateform.action)

   #31. EmployeeUpdateController.java
      (employeeupdate.action)

   #32. EmployeeDeleteController.java
      (employeedelet.action)

   #33. LoginForm.jsp

   #34. LoginFormController.java
(loginform.action)
   
   #35. LoginController.java
(login.action)

   #36. LogoutController.java

   #37. EmpList.jsp

   #38. EmpListController.java
        (emplist.action)

:
      :
==========================================
  #39. DepartmentList.jsp
  #40. DepartmentInsertForm.jsp
  #41. DepartmentUpdateForm.jsp

  #42. DepartmentListController.java
      (departmentlist.action)
  #43. DepartmentInsertFormController.java
      (departmentinsert.action)
  #44. DepartmentInsertController.java
      (departmentinsertcontroller.action)

  #45. DepartmentUpdateFormController.java
      (departmentupdateform.action)
  #46. DepartmentUpdateController.java
      (departmentupdate.action)
  #47. DepartmentDeleteController.java

  #48. DeptList.jsp
  #49. DeptListController.java

:
:

  #50. RegionList.jsp
  #51. RegionInsertForm.jsp
  #52. RegionUpdateForm.jsp

  #53. RegionListController.java
  #54. RegionInsertFormController.java
  #55. RegionInsertController.java
  #56. RegionUpdateFormController.java
  #57. RegionUpdateController.java
  #58. RegionDeleteController.java

  #59. RegList.jsp            
  #60. RegListController.java
:
:

  #61. PositionList.jsp
  #62. PositionInsertForm.jsp
  #63. PositionUpdateForm.jsp   

  #64. PositionListController.java
       (positionlist.action)
  #65. PositionInsertFormController.java
      (positioninsertform.action)
  #66. PositionInsertController.java
  #67. PositionUpdateFormController.java
  #68. PositionUpdateController.java
  #69. PositionDeleteController.java

:
:

  #70. PosList.jsp
  #71. PosListController.java
==========================================    

    
○ 사용자 최초 요청 주소
    http://localhost:3306/Mvc04/employeelist.action → 관리자
    http://localhost:3306/Mvc04/emplist.action → 일반직원

※ 추후 우리는... 실무 프로젝트를 수행하는 과정에서...
   컨트롤러를 액션 단위가 아닌, 업무 단위로 묶어 작업 및 처리하게 될 것이다.
   이후, 어노테이션을 활용하여 컨트롤러를 지정해서 처리하는 방법도 수행하게 될 것이다.
   하지만, 이번 실습 과정에서는 기본 액션 단위의 컨트롤러 구성을 수행해 봄으로써
   Model-View-Controller 의 기능 및 처리 흐름에 대한 이해와 파악을 제대로 할 수 있도록 한다.

2. Annotation.txt

■■■ Annotation(어노테이션) ■■■

○ 개요
- 일종의 주석(사전적인 의미 :  주석달기, 메타데이터)
- 메타 데이터 : 데이터를 부연 설명하기 위한 데이터
- 주석의 지속성
  : *.java(소스 레벨) → [컴파일러(Compiler)] → *.class → [JVM:Runtime]
    이 과정에서 보통 컴파일이 수행되면 주석이 제거
         (//, /*...*/, /**...*/)
- 『@』 : Annotation, JDK 1.5(JavaSE 5.0)부터 사용 가능, Runtime 까지도 존재
- AT(Annotation Type)


○ 메타 데이터의 가치

일반적으로 메타 데이터의 효용은 다음의 세 가지로 나눌 수 있다.
문서화, 컴파일러 체크, 코드 분석

- 문서화
  모든 레벨의 문서화는 자주 인용되는 사용법이다.
    메타 데이터는 메소드가 다른 메소드에 의존하고 있다는 것을 알려주는
  유용한 방법을 제공한다. 
     또한 그들이 불완전한지, 특정 클래스가 또 다른 클래스를 레퍼런싱 하는지
  등을 알려준다.
  이는 유용하지만 문서화는 메타 데이터를 자바에 추가하는 것과 가장 관련이
    적은 항목이다. 
  코드 문서화에 있어서는 Javadoc 라는 사용이 쉽고 강력한 방식을 
  제공하고 있기 때문이다.

- 컴파일러 체크
  보다 중요한 메타 데이터의 장점은
  컴파일러가 메타 데이트를 사용하여 몇 가지 기본적인 컴파일 시간 체크를
  수행할 수 있는 기능이라고 할 수 있다.
  예를 들어, Override 어노테이션을 이용하여 슈퍼 클래스의 메소드가
  재정의된 것을 기술, 자바 컴파일러는 메타 데이터에서 알려주는 작동이
  실제로 코드 레벨에서 발생한다는 것을 확인할 수 있다.
  이는 실수로 오버라이딩하는 경우의 버그를 쉽게 찾을 수 있다.

- 코드 분석
  좋은 어노테이션 또는 메타 데이터 틀의 최고의 기능은
  여분의 데이터를 사용하여 코드를 분석하는 것이다.
  간단한 경우, 코드 목록을 구현하고 필요한 인풋 유형을 제공하고
  리턴 유형을 제시한다.
  자바 리플렉션도 같은 기능을 제공한다고 생각할 수 있다.
  결국 이 모든 정보에 대한 코드를 검사할 수 있다.
  표면적으로 볼 때 그럴듯 하지만 실제로 그렇지 않다.
  많은 경우 메소드는 인풋으로 받아들이거나 아웃풋으로 리턴한다.
  이는 메소드가 원하는 것이 아니다.
  예를 들어, 매개변수 유형이 Object 이지만 메소드는  Integer 를 사용해서만 작동한다.
  이는 메소드가 겹쳐쓰기된 곳에서 쉽게 발생할 수 있다.
  그리고 슈퍼 클래스가 메소드를 일반 매개변수로 선언하던가
  많은 직렬화가 진행되는 시스템에서 쉽게 발생한다.
  두 경우 모두 메타 데이터는 코드 분석 틀을 지정할 수 있다.
      매개변수 유형이 Object 이더라도 정말로 원하는 것은 Integer 라는 것을 나타낼 수 있다.
  이러한 종류의 분석은 상당히 유용하며 그 가치는 상당하다.
 
  보다 복잡한 코드 분석 툴은 모든 종류의 추가 태스크를 수행할 수 있다. 
  그 예 중 하나가 EJB(Enterprise JavaBean) 컴포넌트이다.
  심지어 간단한 EJB 시스템도 의존성과 복잡성은 상당하다.
  로컬 인터페이스이면서 로컬 홈 인터페이스가 될 가능성과 함께 
  홈 인터페이스와 원격 인터페이스를 얻는다.
  이 모든 클래스들을 연동시키는 것은 꽤 힘들다.
  하지만, 메타 데이터는 이 문제에 대한 솔루션을 제공한다.
  좋은 툴은 이 모든 의존성을 관리하면서 코드-레벨 연결이 없지만
    코드-레벨 관계를 가진 클래스들이 연동될 수 있도록 한다.
  이것이 바로 메타 데이터의 진정한 가치라고 할 수 있다.

○ Annotation의 종류

1) Mark Annotation
 변수가 없다. 이 어노테이션은 이름으로 구분되며 추가 데이터 없이 나타난다.
 예를 들어, @ Mark Annotation은  marker 어노테이션이다.
 데이터가 없으며 단지 어노테이션 이름만 있을 뿐이다. 
 ex) @Stateless

2) Single Annotation
marker 와 비슷하지만 데이터를 제공한다.
싱글 비트 데이터를 제공하기 때문에 간단한 신택스를 사용할 수 있다.
(단, 어노테이션 유형이 이 문법을 수용해야 함)
: @SingleValueAnnotation("my data")
 → 이는 @ 표시만 제외하고는 일반적인 자바 메소드 호출과 비슷하다.

3) Full Annotation(Multi value Annotation)
다중 데이터 멤버를 가지고 있다.
결과적으로 전체 신택스를 사용해야 한다. 
(그리고, 어노테이션은 일반 자바 메소드와 더이상 비슷하지 않다. )
: @FullAnnotation(var1="dataValue1", var2="dataValue2", var3="dataValue3")

4) Custom Annotation 구현
: 개발자가 직접 Annotation을 구현
ex)
public @interface TODO // Single Value Annotation
{
  String Value(); // value 가 아닌 이름을 사용하면
} // 사용시 메소드의 이름을 써준다.

// @TODO("Something todo")

public @interface TODO // Single-value Annotation
{
  String msg(); // value 가 아닌 이름을 사용한 경우
  }

// @TODO(msg="Something todo")


○ Annotation 을 구분하는 또 다른 기준
 
1) Simple Annotation
   메소드가 변수 위에 붙이는 일반적인 Annotation

2) Meta Annotation
   Annotation 의 Annotation
   (한 Annotation 위에 다른 Annotation 설정)

※ Meta Annotation

 1) @Target Annotation
   작성한 Annotation 이 어디에서 사용하게 될지를 결정
 
   @Target(
   {
     ElementType.type // 클래스, 인터페이스, enum
    , ElementType.METHOD // 생성자를 제외한 모든 메소드
    , ElementType.CONSTRUCTOR // 생성자
    , ElementType.ANNOTATION_TYPE // 메타 Anntation
   })

2) @Retention Annotation
   @Retention Annotation([속성값])
   작성한 Annotation의 지속성을 설정

  - RententionPosicy.SOURCE
    : 컴파일러가 컴파일 시 삭제하여 클래스 파일에 저장되지 않는다. 
  - RententionPosicy.CLASS
    : 클래스 파일에 저장되지만 JVM 은 무시
  - RententionPosicy.RUNTIME
    : 클래스 파일에 저장되도 JVM 은 유지

○ 내장(Built-in) Annotation (※ java.lang.* 에 정의된 3개의 표준 어노테이션)

1) @Override
   슈퍼 클래스의 메소드를 오버라이드

  public class OverrideTest
  {
    public OverrideTest() { }

    @Override
    public String toString()
    {
        return super.toString() + "[Override Test Implementation]";
    }
  

    @Override
    public int hashCode()
    {
      return super.toString().hashCode();
    }

  }

2) @Deprecated
   @Override 와 마찬가지로 @Deprecated 는 marker 어노테이션이다.
   @Deprecated를 사용하여 더이상 사용되지 말아야 할 메소드에 주석을 부여한다.
   @Override와 다른 점은, @Deprecated는 더 이상 사용되지 말아야 하는 (deprecated)
   메소드와 동일한 라인상에 놓여져야 한다.

   public class Deprecated
   {
     @Deprecated public void doSomethig()
     {
//.. 실행 코드
  // doSomethig() 메소드를 사용하는 것 보다
// 향상된 형태의 코드
       }
   }

3) @SuppressWarnings
   번거로운 경고를 제거한다.
   Override 나 Deprecated 와는 다르게 @SuppressWarnings 는 변수를 갖고 있다.
   따라서 이를 작동하게 하려면 Single-value Annotation 유형으로 사용해야 한다.
   값 어레이로서 변수를 제공할 수 있다.
   각각 삭제할(Suppress) 특정 유형의 경고를 나타낸다.

   @SuppressWarnings(value="unchecked")
   public void nonGenericMethod()
   {
     List wordList = new ArrayList();
     wordList.add("foo");
   }





------------------------------------------------------------------------------------------------------

■■■ Spring Annotation ■■■

○ 개요
Spring Framework 는 JAVA 5+ 부터 Annotation을 제공하며,
Annotation 의 사용으로 설정 파일을 간결화하고
객체 또는 메소드의 매핑을 명확하게 처리할 수 있다. 

○ @Component
- 패키지 : org.springframework.stereotype
- 버전 : spring2.5
- 개요
  : 『<context:component-scan>』태그를 설정 파일에 추가하면
     해당 어노테이션이 적용된 클래스를 빈으로 등록하게 된다.
     범위는 디폴트로 싱글톤(Singleton)이며 『@Scope』를 사용하여 지정할 수 있다.
- 설정 위치 : 클래스 선언부 위
- 추가 설정
  : XML 설정 파일에 『<context:component-scan>』을 정의하고
    적용할 기본 패키지를 『<base-package>』속성으로 등록한다.
    『<context:component-scan>』태그를 사용하면
      @Component, @Required, @Autowired 등의 어노테이션이 함께 적용된다.

   예를 들면, 『<context:component-scan base-package="xxx">』 에서
   xxx 패키지의 하위에서 @Component 로 선언된 클래스는 Bean 으로 자동 등록한다.
   Bean 의 이름은 해당 클래스명(첫 글자는 소문자)이 사용된다.

   『<context:component-scan>』 요소에는 scoped-proxy 속성이 존재한다.
   scoped-proxy 속성은 <aop:scoped-proxy/> 요소처럼
   WebApplicationContext 에서만 유효하며
   " session", "globalSession", "request" 이외의 scope 는 무시되며
   다음의 3가지 값을 설정할 수 있다.
   ·no : proxy 를 설정하지 않는다.(기본값)
       ·interfaces : JDK Dynamic Proxy를 이용한 proxy 생성
     ·targetClass : 클래스에 대해 프록시를 생성(CGLIB 를 이용한 Proxy 생성) 

- 사용 예
  @Component
  @Scope("prototype") //-- 생략하면 싱글콘
  public class Test
  {
             //...
  }


○ @Required
- 패키지 : org.springframework.beans.factory.annotation
- 버전 : spring 2.0
- 개요
  : @Required 어노테이션은 필수 프로퍼티임을 명시하는 것으로
    필수 프로퍼티를 설정하지 않을 경우 빈 생성 시 예외를 발생시키게 된다.
- 설정 위치 : setter 메소드
- 추가 설정
  : <bean class="org.springframeword.beans.factory.annotation"
    .RequiredAnnotationBeanPostProcessor"> 클래스를
    빈으로 등록시켜 줘야 한다.
    해당 설정 대신에 『<context:annotation-config>』태그를 사용해야 된다.

    『<context:annotation-config>』 태그는
    어노테이션과 관련하여 다음의 BeanPostProcessor 를 함께 등록한다.
    ·@Required(RequiredAnnotationBeanPostProcessor)
    ·@Autowired(AutowiredAnnotationBeanPostProcessor)
            ·@Resource, @PostConstruct, @PreDestroy(CommonAnnotationBeanPostProcessor)
    ·@Configuration(ConfigurationClassPostProcessor)
   
① 1 단계 : 코드 내에 프로퍼티 설정 메소드에 『@Required』 어노테이션을 붙인다.

  public class TestBean
  {
     private TestDAO testDAO;
     
     @Required
         public void setTestDAO(TestDAO testDAO)
             {
this.testDAO = testDAO;
             }

    }

② 2 단계 : 스프링 설정 파일에 RequiredAnnotationBeanPostProcessor 클래스를
    빈으로 등록한다.

   <bean class="org.springframework.beans.factory.annotation
   .RequriedAnnotationBeanPostProcessor"/>

   <bean name="testBean" class="com.test.TestBean">
<!-- 『@Required』 어노테이션을 적용하였으므로
설정하지 않을 겨웅 예외를 발생시키게 된다. -->
<property name="testDAO" ref="testDAO"/>
   </bean>

  RequiredAnnotationBeanPostProcessor 클래스는
  스프링 컨테이너에 등록된 bean 객체를 조사하여
  @Required 어노테이션으로 설정되어 있는 프로퍼티에 대해
  값이 제대로 설정되어 있는지 검사하고
  설정되어 있지 않으면 bean 생성 시 예외를 발생시키게 되는 것이다.

  RequiredAnnotationBeanPostProcessor 클래스를 빈으로 등록하지 않고
  『<context:annotation-config>』 와 같이 태그를 이용할 수도 있다.

<?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:p="http://www.springframework.org/schema/p"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
          <context:annotation-config />  <!-- ◀◀◀ -->

       </beans>


○ @Autowired
- 패키지 : org.springframework.beans.factory.annotation
- 버전 : spring 2.5
- 개요
  : @@Autowired 어노테이션은 의존관계를 자동 설정할 때 사용하며
    타입을 이용하여 의존하는 객체를 삽입해 주도록 처리한다.
    그러므로 해당 타입의 빈 객체가 존재하지 않거나
    또는 2개 이상 존재할 경우, 스프링은 예외를 발생시키게 된다.
- 설정 위치 : 생성자, 필드, 메소드(setter 가 아니어도 무방하다.)
- 추가 설정
  : <bean class="org.springframework.beans.factory.annotation"
    .AutowiredAnnotationBeanPostProcessor"/> 클래스를
   빈으로 등록시켜줘야 한다.
   해당 설정 대신에 『<context:annotation-config/>』 태그를 사용해도 된다.
- 옵션
  ·required
    @Autowired 어노테이션을 적용한 프로퍼티에 대해
    설정한 필요가 없는 경우에 false 값을 부여하며,
    이 때 , 해당 프로퍼티가 존재하지 않더라도 스프링은 예외를 발생시키지 않는다.
    『@Autowired(required=false)』로 선언한다. (기본값은 true)

- 특징
  byType 으로 의존관계를 자동으로 설정한 경우
  같은 타입의 빈이 2개 이상 존재하면 예외가 발생하게 되는데,
  @Autowired 도 이러한 문제가 발생한다.
  이럴 경우, @Qualifier 를  사용하면 동일한 타입의 빈 중
  특정 빈을 사용하도록 하여 문제를 해결할 수 있다.

  @Autowired
  @Qualifier("test")
  private Test test;

○ @Qualifier
- 패키지 : org.springframework.beans.factory.annotation
- 버전 : spring 2.5
- 개요
  : @Qualifier 어노테이션은  @Autowired 의 목적에서
    동일 타입의 빈 객체가 존재할 경우 특정 빈을 삽입할 수 있게 설정한다.
    @Qualifier("mainBean")의 형태로 @Autowired 와 같이 사용하며
    해당 <bean>태그에 <quaulifier value="mainBean"/> 태그를 선언해 주어야 한다.
    메소드에서 두 개 이상의 파라미터를 사용할 경우에는
    그 파라미터 앞에 선언해야 한다.
- 설정 위치 : @Autowired 어노테이션과 함께 사용.
- 추가 설정 : 동일 타입의 빈 객체 설정에서
『<qualifier value="[alias명]"/>』를 추가해 준다.
- 옵션 : name -alias명

○ @Resource
- 개요
: Java 6 버전 및 JEE 5 버전에 추가된 것으로
  어플리케이션에서 필요로 하는 자원을 자동 연결할 때 사용한다.
  스프링 2.5 부터 지원하는 어노테이션으로
  스프링에서는 의존하는 빈 객체를 전달 할 때 사용한다.
  @Autowired와 같은 기능을 수행하며
  @Autowired 와의 차이점은 @Autowired는 타입으로(byType)
  @Resource 는 이름으로 (byName) 연결을 수행한다는 것이다.
- 설정 위치 : 프로퍼티, setter 메소드
- 추가 설정
  : 『<bean class="org.springframework.beans.factory.annotation
.CommonAnnotationBeanPostProcessor"/>』 클래스를
    빈으로 등록시켜줘야 한다.
    해당 설정 대신에 『<context:annotation-config/>』 태그를 사용해도 된다.
- 옵션 : name
  name 속성에 자동으로 연결된 빈 객체의 이름을 입력한다.
  @Resource(name="testDAO")
  CommonAnnotationBeanPostProcessor 클래스를
  설정 파일에 빈 객체로 등록하여 어노테이션을 적용시키게 된다.

○ @PostConstruct
- 패키지 : javax.annotation
- 버전 : jdk 1.6, spring 2.5
- 개요
  : 의존하는 객체를 설정한 이후에 초기화 작업을 수행하기 위해 사용,
- 설정 위치 : 초기화 작업 수행 메소드
- 추가 설정
  : 『<bean class="org.springframework.beans.factory.annotation
    .CommomnAnnotationPostProcessor"/>』 클래스를
    빈으로 등록시켜줘야 한다.
    해당 설정 대신에 『<context:annotation-config/>』 태그를 사용해도 된다.


○ @PreDestory
- 패키지 : javax.annotation
- 버전 : jdk 1.6, spring 2.5
- 개요
  : 컨테이너에서 객체를 제거하기 전에 해야할 작업을 수행하기 위해 사용
- 설정 위치 : 해당 작업 수행 메소드
- 추가 설정
  : 『<bean class="org.springframework.beans.factory.annotation
    .CommomnAnnotationPostProcessor"/>』 클래스를
    빈으로 등록시켜줘야 한다.
    해당 설정 대신에 『<context:annotation-config/>』 태그를 사용해도 된다.

------------------------------------------------------------------------------------------------

■■■ Spirng AOP 관련 Annotation ■■■

※ spring AOP Annotation 을 활용하기 위한 관련 용어
- advice : 공통 기능을 구현한 클래스
- target : advice 가 적용될 객체
- joinpoint : advice 가 적용될 지점(즉, target 의 메소드)
- pointcut : 실제로 advice 가 적용된 joinpoint(pointcut 은 joinpoint의 부분집합)
- advisor(=aspect) : advice + pointcut
- weaving : advice 를 핵심 로직 코드에 적용하는 것

○ @Aspect
- 개요
  : AspectJ 5 버전에 새롭게 추가된 어노테이션으로 
    @Apspect 어노테이션을 사용하면 설정 파일에 Advice 및 Pointcut 등의 설정을
     하지 않고도 자동으로 Advice 를 적용할 수 있다.
- 설정 위치
  : 클래스 선언부 위
- 추가 설정
    : XML 설정 파일에 『<aop:aspectj-autoproxy/>』를 정의한다.
    『<aop:aspectj-autoproxy/>』태그는 @Aspect 어노테이션이 적용된 클래스를
    로딩하여 클래스에 명시된 Advice 및 Pointcut 정보를 이용하여
    알맞은 빈 객체에 Adivce를 적용하게 된다.

※ @Aspect 어노테이션이 적용된 클래스 
Advice 로 사용될 메소드에는 Advice 를 의미하는 어노테이션을 설정한다.
 
1) @Before 어노테이션
   Before Advice로 사용할 메소드에 적용
2) @After 어노테이션
   Afer Advice로 사용할 메소드에 적용
3) @AfterReturning 어노테이션과 @AfterThrowing 어노테이션
   각각 리턴값과 예외 객체를 전달받을 파라미터의 이름으로 지정하며
   Advice 메소드에서 리턴값과 예외 객체를 사용할 수 있도록 한다.
4) @Around 어노테이션
   ProceedingJoinPoint.proceed() 메소드를 호출하여
   프록시 대상 객체의 메소드를 호출한다.
5) @Around 어노테이션을 제외한 나머지 Advice를 표시하는 어노테이션들
   메소드는 프록시 대상 객체에 대한 정보가 필요한 경우
   첫 번째 파라미터로 JoinPoint 를 사용한다.

※ AspectJ의 표현식
   AspectJ 는 Pointcut을 명시할 수 있는 다양한 명시자를 제공하는데,
   스프링은 메소드 호출과 관련한 명시자만을 지원하고 있다.
   execution 명시자는 Advice 를 적용할 메소드를 명시할 때 사용되며, 
   기본형식은 다음과 같다.

  execution(수식어패턴 리턴타입패턴 패키지패턴.클래스패턴.메소드패턴(파라미터패턴))
- 수식어패턴 : 생략 가능하며 public, protected 등이 온다.
- 리턴타입패턴 : 리턴 타입을 명시한다.
- 패키지패턴, 클래스패턴, 메소드패턴 : 클래스 이름 및 메소드 이름을 패턴으로 명시
- 파라미터패턴 : 매칭될 파라미터에 대해 명시한다.

각 패턴은 『*』를 이용하여 모든 값을 표현할 수 있으며,
『..』을 이용하여 0개 이상이라는 의미를 표현할 수 있다.
『within』명시자는 일반 메소드가 아닌 특정 타입에 속하는 메소드를
Pointcut 으로 설정할 때 사용된다.
각각의 표현식은 『&&』나 『||』연산자를 이용하여 연결할 수 있다.

예를 들어 『@Aspect』 어노테이션을 사용하는 경우

@AfterThrowing(pointcut="execution(public * get*())
    && execution(public void set*(..))")
public void throwingLogging()
{
  //...
}

------------------------------------------------------------------------------------------------------------

■■■ Spring MVC 관련 Annotation ■■■

○ 개요
Spring Web MVC Framework 는 JAVA 5+ 부터 Annotation 을 제공하며,
Annotation 의 사용으로 설정 파일을 간소화하고,
View 페이지와 객체 또는 메소드의 매핑을 명확하게 처리할 수 있다.

※ 4개의 스테레오(stereo)타입 어노테이션
- @Component
  : 스테레오 타입 어노테이션의 조상
- @Controller
  : Spring NVC 에서 컨트롤러로 인식
- @Service
  : 역할 부여 없이 스캔 대상이 되는데... 비즈니스 클래스에 사용
- @Repository
  : @Repository 어노테이션은 일반적으로 DAO 에 사용되며
    DB Exception 을 DataAccessException으로 변환


※ Spring Annotation 에서 정리한 내용에... 추가 ++

○ @Service
- 개요
  : @Service 를 적용한 클래스는 비즈니스 로직이 들어가는 Service 로 등록이 된다.
    Controller 에 있는 @Autowired 는 @Servic("xxxService")에 등록된
    『xxxService』와 변수명이 같아야 하며
    Service 에 있는 @Autowired 는 @Repository("xxxDao")에 등록된
            『xxxDao』 와 변수명이 같아야 한다.

    @Service("helloService")
    public class HelloServiceImpl implements HelloService
      {
@Autowired
private HelloDAO helloDao;

public void hello()
{
  System.out.println("HelloServiceImpl :" + hello());
  helloDao.selectHello(); // ◀◀◀
}
    }

  // 『helloDao.selectHello();』와 같이 @Autowired, 를 이용한
  // 객체를 활용하여 DAO  객체를 호출한다.

○ @Repository
- 패키지 : org.springframework.stereotype
- 버전 : spring 2.0
- 개요
  : @Repository 어노테이션은 일반적으로 DAO 에 사용되며 
    DB Exception 을 DataAccessException 으로 변환하는 기능을 수행한다.

○ @Controller
- 패키지 : org.springframework.stereotype
- 버전 : spring 2.5
- 개요
  : Spring MVC 의 Controller 클래스 선언을 단순화시켜준다.
    스프링 컨트롤러 서블릿 등을 상속할 필요가 없으며,
    @Controller 로 등록된 클래스 파일에 대한 bean 을 자동으로 생성해준다.
    @Controller 로 사용하고자 하는 클래스에 @Controller 를 지정해주면
    Component-scan 으로 자동 등록된다.
- 추가 설정(java)
  : package com.test;
  
    import org.springframework.sterotype.Controller;

    @Controller
    public class SpringC
    {
              //..
    }


○ @RequestMapping
- 개요
   : @RequestMapping 어노테이션은 URL 을 class 또는 method 와
     mapping 시켜주는 역할을 수행한다.
         Annotation 을 사용하지 않을 때 지정했던 Controller 등록을 위한
     URL bean 설정을 생략할 수 있다.
     클래스에 하나의 url mapping  을 할 경우
     class  위에 『@RequestMapping("/url")』을 지정하며,
     GET 또는 POST 방식 등의 옵션을 부여할 수 있다.
     해당 메소드가 실행된 후 return 페이지가 별도로 정의되어 있지 않으면
     @RequestMapping("/url")에서 설정된 url 로 다시 돌아간다.

    @Controller
    @RequestMapping("/com/test/*")
    public class HelloController
    {
@RequestMapping(method=RequestMethod.GET, value="go")
public returntype getMethodBName()
{
  //...
}

@RequestMapping(method=RequestMethod.GET, value="go2")
public returntype getMethodBName2()
{
  //...
}
    }

○ @RequestParam
- 개요
   : @RequestParam 어노테이션을 key=value 형태로
     화면에서 넘어오는 파라미터를 매핑된 메소드의 파라미터로 지정해준다.
     주로 get 방식으로 들어오는 request에서 사용한다.

   @Controller
   public class BlogController
   {
//...

@RequestMapping("/editBlog")
public ModelMap eidtBlogHandler(@RequestParam("blogId") int blogId)
{
  blog = blogService.findBlog(blogId);
  return new ModelMap(blog);
}

//...
   }

  // 『.../editblog.action?blogId=3』 과 같은 요청으로 접근할 때 
  // editBlogHandler() 메소드의 파라미터인 blogId 에는 3 이 세팅된다.
  // 필수요건이 아닐 경우, @RequestParam(value="id", required="false")와 같이
  // 옵션을 부여해서 사용할 수 있다.

○ @ModelAttribute
- 개요
: @ModelAttribute 어노테이션은 화면의 form 속성으로 넘어온 model을
    매핑된 method의 파라미터로 지정해주는 역할을 수행한다.
   주로 post 타입으로 넘어오는 form 속성의 model 값을 받아올 때 사용한다.
   (하지만 주로 get / post 모드로 통용된다.)

@Controller
  public class BlogController
{
  // ...
  @RequestMapping("/updateBlog")
  public String updateBlogHandler(@ModelAttribute("blog") Blog blog)
  {
     blogService.updateBlog(blog);
     return "redirect:fingBlog.action";
  }
     // ...
}

○ @SessionAttribute
- 개요 
: @SessionAttribute 어노테이션은 세션 상에서 model의 정보를 
  유지하고자 할 경우 사용할 수 있다.


@Controller
@SessionAttributes("blog")
  public class BlogController
{
  // ...
  @RequestMapping("/createBlog")
  public ModelMap creatBlogHandler
  {
     blog = new Blog();
     blog.setRegDate(new Date());
     // ...    
     return new ModelMap(blog);
  }
     // ...
}


○ @InitBinder
- 개요
: WebDateBinder 를 초기화 하는 method 를 지정할 수 있는 설정을 제공한다
  일반적으로 WebDateBinder 는 Annotation Handler 메소드의
  command 와 form  객체 인자를 조작하는데 사용된다. 
  initBinder 메소드가 필수적으로 변환 값을 가질 필요는 없으며,
  일반적으로 이런 경우에 voide를 선언한다.
  특별히 인자는 WebDataBinder 와 WebRequest 또는 Locale 의 조합으로 이루어지며
  이러한 조건이 만족되면 context-specific eidtors를 등록하는 것이 허용된다. 

·WebDateBinder 
  : WebDateBinder 는 web request parameter를
    자바 빈 객체에 바인딩하는 특정한 DataBinder, dlek.
    WebDateBinder 는 웹 환경이 필요하지만
      Servlet API에 의존적이지 않다.
      Servlet API에 의존적인 Servlet RequestDatatBinder와 같이
    특정한 DataBinder 를 위한 더 많은 bass class를 제공한다.
· RequestMapping
   : RequestMapping 어노테이션은 web request 를
     특정한 handelr class 와 handelr method 에 mapping 하는 역할을 수행한다.
     대응하는 handlerMapping(for type level annotation)과
     handlerAdatpter(for method level anntation) 가 dispath 에 존재한다며느
     @RequestMapping이 처리될 것이다. 
·WebRequest
  : WebRequest는 웹 요청에 대한 Generic interface 이다.
    주로 일반 request metadata  에 generic web request interseptors 의
    접근을 허용하여 metadate 에 대한 처리를 위한 것이지
    request 자체를 처리하기 위한 것은 아니다.

※ Annotation 기반 Controller 에서 ServletContext 구하기

// ...

  @Controller
public class downloadController
{
  @Autowired
  private ServletContext sc;

  @RequestMapping
  public ModelAndView download(@RequestParam("filePath") String filePath) theows Exception
  {
    String path = sc.getRealPath(filePath);
    return new ModelAndView("common.download", "downloadfile", new file(path));
  }
}

 

3. Mybatis Framework.txt

■■■ Mybatis Framework 개념 정리 ■■■

※ ORM(Object Relational Mapping : 객체 관계 매핑)
   ORM 은 데이터베이스의 테이블들을 객체화하여 접근할 수 있으며,
   PreparedStatement의 파라미터와 ResultSet 의 값들을
   자바 빈과 객체화가 쉬운 매핑을 시켜주어
   자바 코드의 감소에 도움을 주는 것으로, 
   오픈 소스로는 mybatis(ibatis), Hibernate 등이 있다.

※ SQL Mapper
   - 자바 객체를 실제 SQL 문장에 매핑. (자바 코드에서 SQL 관련 부분을 제거)
   - SQL 문장이 자동으로 생성되는 것이 아니라 개발자가 기술해준다.
   - 매핑 자체는 데이터베이스의 엔티티와 관계에 독립적이다.
     (mapping 자체가 SQL 문에 국한)
   - 실제적으로 모든 임베디드 SQL 시스템은 모두 SQL Mapper로 간주 가능
   - 마이바티스(mybatis) SQL Map 의 경우
     XML 에 임베디드된 SQL. (자바 코드의 SQL을 XML 파일로 분리)

○ 마이바티스(mybatis) 개요
   mybatis 는 persistence(영속적인, 소멸되지 않고 오래도록 지속되는) 계층의
   프레임워크로 다른 객체 관계 매핑 프레임워크들과는 달리
   정형화된 테이블 구조에 의존하지 않고
   SQL 구문의 실행 결과에 객체를 매핑하는 방식으로
   테이블 구조가 복잡해지고 정규화가 되어 있지 않더라도 테이블을 변경할 필요 없이
   기존 개발 방법에서 사용한 SQL 을 그대로 사용할 수가 있으며,
   SQL 에 적용한 각각의 튜닝 항목들도 모두 그대로 유지된다.

   mybatis 프로젝트는 mybatis SQL Map 과 mybatis DAO 컴포넌트로 구성되어 있다.
   이 중, mybatis SQL Map 은 SQL 문 관리에 초점을 맞추고 있다.
   mybatis DAO 컴포넌트는 hibernate 와 mybatis SQL Map 을 함께 사용할 경우
   트랜잭션 통합과 같은 저장 매커니즘에 초점을 맞추고 있다.

   mybatis Data Mapper 프레임워크는 관계형 데이터베이스에 접근할 때 
   필요한 자바 코드를 현저하게 줄일 수 있는데
   간단한 XML 서술자를 사용해서 편리하게 자바 빈즈를 SQL Statement 에 매핑시킨다.
   간단함(Simpleicity)이란 다른 프레임워크와 객체 관계 매핑 도구와 비교하여
   mybatis의 가장 큰 장점이다. 
   mybatis Data Mapper 를 사용하기 위해서는 자바 빈즈와 XML 그리고 SQL 에 대한
   선수지식이 필요하며 Data Mapper 를 사용하면
   실제 SQL 문의 모든 기능을 사용할 수 있다.

   객체 관계형 데이터베이스의 관계 매핑을 설정하면
   SQL 문을 자동으로 생성해주는 hibernate 에 비해 SQL 문 자동 생성 기능이 없는
   mybtis 의 SQL Mapper 는 진정한 의미의 ORM 이 아니라는 분위기도 있었지만
   관계형 데이터베이스와 통신할 수 있는 유일한 매개체인 SQL 문과 객체를
   매핑시켜준다는 의미에서 SQL Mapper 또한 ORM 으로 다루고 있다.

○ 마이바티스(mybatis)의 특징
  
   - 프레임워크(환경, 툴, 약속)
     ·mybatis 는 JDBC 프레임워크다.
     ·개발자는 SQL 을 작성하기로 약속하고
마이바티스는 JDBC 를 사용해서 이를 실행시키기로 약속한다. 

   - 간단한 
·간단한 퍼시스턴스 프레임워크
·JDBC를 사용할 때의 try / catch / finally 구문을 사용할 필요가 없다.

   - 생산성
·JDBC와 비교했을 때 62%정도 줄어드는 코드와 간단한 설정
  (근거 : 이탈리아나자바 사용자 그룹의 연구)

   - 성능
·구조적 강점(데이터 접근 속도를 높여주는 join매핑)
·여러가지 방식의 데이터 가져오기 전략.(가져오기 미루기, SQL 줄이기 기법 등)

   - 관심사의 분리
·설계를 향상(차후 유지보수성을 위해)
·리소스를 관리하여 계층화를 지원(Connection, PrepareStatement, ResultSet 등)

   - SQL 문이 애플리케이션 소스 코드로부터 완전히 분리.

   - 작업의 분배 : 팀을 세분화하여 업무 구분을 명확히 하는 것을 도움
 
   - 이식성 : 어떤 프로그래밍 언어로도 구현가능 (JAVA, C#, RUBY 등)
   
   - 오픈소스 : 무료 + 커뮤니티

   - SQL Mapper
·기본적으로 ORM은 데이터베이스 객체를 자바 객체로 매핑함으로써
  객체 간의 관계를 바탕으로 SQL 을 자동으로 생성해 주지만,
    마이바티스는 SQL을 작성 및 명시해 주어야 한다.

   - 스프링과 같은 외부 트랜잭션 관리자를 사용할 수도 있다.
 
   - 스프링 연동 모듈을 제공하기 때문에 스프링과 연동할 수도 있다.


○ 마이바티스(mybatis) 작동 원리

   Data Mapper 는 자바 빈즈, Map 구현, 원시 래퍼 타입 (String, Integer, ...)
   그리고  SQL 문을 위해 XML 문서를 매핑하기 위한 XML 서술자를 사용하는
   간단한 프레임워크를 제공한다.

   1) 파라미터(자바 빈즈, Map 또는 원시래퍼)로써 객체를 제공한다.
      파라미터 객체는 update 문 내부에 입력 값을 세팅하기 위해 사용되거나
      쿼리문의 where 절을 세팅하기 위해 사용된다.

   2) 매핑된 statement를 실행한다.
      Data Mapper 프레임워크는 PrepareStatement 인스턴스를 생성하고
      제공된 파라미터 객체를 사용해서 파라미터를 세팅한다.
      그리고 statement 를 실행하고 ResultSet 으로부터 결과 객체를 생성한다.

   3) update문의 경우에 영향을 미친 rows의 숫자를 반환한다.
      조회문일 경우에 한 개 (single)의 객체 또는 컬렉션 객체를 반환한다.
      파라미터처럼 결과 객체는 자바 빈즈, Map, 원시 래퍼, XML 이 될 수 있다.

○ 마이바티스(mybatis) 작동 흐름

   - 데이터 처리를 위해 DAO 는 mybatis 에 제공하는 객체의 메소드를 호출한다.
   - mybatis 는 SQL 문이 저장된 매퍼 파일에서 데이터 처리에 필요한 SQL문을 찾는다.
   - mybatis 는 매퍼 파일에서 찾은 SQL문을 서버로 보내고자 JDBC 드라이버를 사용한다.
   - JDBC 드라이버는 SQL 문을 데이터베이스 서버로 전송한다.
   - mybatis는 select문의 실행 결과를 값 객체에 담아서 반환한다.
     (insert, update, delete 문인 경우 입력, 변경, 삭제된 레코드의 갯수를 반환한다.)

○ 마이바티스(mybatis)관련 사이트

   - ibatis이전 홈페이지
     http://ibatis.apache.org/

   - mybatis 새 홈페이지
     http://www.mybatis.org/

   - 다운로드
     ·mybatis
       http://blog.mybatis.org/p/products/html
     ·spring 연동
       http://github.com/mybatis/spring/release

   - 도움말
      http://mybatis.github.io/mybatis-3/ko/getting-starged.html

   - API
      http://ibatis.apache.org/docs/java/dev

※ 참고

   - 2.3.0.677 버전부터는 jar파일들(/lib 디렉터리 내)이
     ibatis-2.3.0.677.jar 하나로 통합되었다.
   - ibatis-common-2.jar
     : SQL Maps와 DAO 프레임워크 모두가 사용하는 공통 컴포넌트 포함
   - ibatis-sqlmap-2.jar
     : SQL Maps 프레임워크의 컴포넌트들을 포함하고 있는 파일
   - ibatis-dao-2.jar
     : DAO 프레임워크 컴포넌트들을 포함하고 있는 파일

○ 주요 클래스 및 인터페이스

  - SqlSessionFactoryBuilder
    ·SqlSessionFactory 를 만들기 위해 한 번만 사용하면 되기 때문에
      계속 이 클래스의 인스턴스를 유지할 필요는 없다.

  - SqlSessionFactory
    ·SqlSessionFactory 객체가 mybatis 의 전반적인 정보를 가지고 제어한다.
    ·SqlSessionFactory 객체를 생성하기 위해 SqlSessionFactoryBuilder 객체를
      먼저 생성한다.
    ·SqlSessionFactory 객체는 SqlSessionFactoryBuilder 의 build 메소드로 생성한다.
    ·SqlSessionFactory 객체가  mybatis 의 전반적인 정보를 갖는 특성으로 인해
      이 객체는 애플리케이션 내에서 한 개만 생성되어야 한다.

  - SqlSessionFactory 에서 SqlSession 객체 생성
    ·SqlSessionFactory 이름에서 알 수 있듯이 SqlSession 인스턴스를 만들 수 있다.
    ·SqlSession 은 데이터베이스에 대해  SQL 명령어를 실행하기 위해
      필요한 모든 메소드를 가지고 있다.
      그래서 SqlSssion 인스턴스를 통해 직접 SQL구문을 실행할 수 있다.

      ex)
      Reader reader = Resource.getResourceAsReader("mybatis/mybatis-config.xml");
      SqlSessionFactory factory = new SqlSessionFactoryBuilder().builder(reader);
      SqlSession session = factory.openSession();

   - SqlSession
     각각의 스레드는 자체적으로 SqlSession 인스턴스를 가져야 한다.
     SqlSession 인스턴스는 각 요청을 받은 쿼리문을 실행하는 객체이다.
     따라서 SqlSession 인스턴스는 공유되지 않고, 
     thread safety하게 만들어지지도 않았다.
     (여러 스레드가 접근해서 사용해도 정보가 어긋나지 않도록 만들어지는 것)
     그렇기 때문에 이 인스턴스르 공유해서 사용하지 않는다.
     예를 들어, 어떤 클래스 안에 static변수나, 서블릿의 HttpSession  과 같은
     관리 범위 안에 저장해서도 안되는 것이다.
     만약, 사용해야 할 경우에는 Http 요청을 받을 때마다 만들고
     응답을 리턴할 때 마다 SqlSession 을 닫아야(리소스를 반납해야)한다.
     SqlSession 이 닫히지 않으면 해당 인스턴스 리소스가 계속 유지되므로
     꼭 닫아야 한다.

     ex)
    
     ...
     SqlSession session = SqlSessionFactory.openSession();
     try
     {
...
     }
     finally
     {
        session.close();    // ◀◀◀◀
     }

   - Mapper 인스턴스
     Mapper 는 SQL 구문과 객체를 설정해놓은대로 바인딩하기 위한 인터페이스이다.
     Mapper 인터페이스의 인스턴스는 SqlSession 에서 생성한다. 
     그래서 Mapper 인스턴스의 가장 좋은 스코프는 SqlSession 과 동일하다.
     사용할 메소드가 호출이 되면 생성되고 종료되기 때문에
     명시적으로 닫을 필요는 없다.

     ex)
     ...
     SqlSession session = SqlSessionFactory.openSession();
     try
     {
        BolgMapper mapper = session.getMapper(BlogMapper.class);
     }
     finally
     {
        session.close();
     }

   - Mapper XML 파일
     mybatis의 가장 큰 장점은 매핑된 구문이며,
     SQL Map XML 파일을 상대적으로 간단하다.
     그리고 동일한 기능의 JDBC 코드와 비교하면 다량의 코드가 감소하기도 한다.
     즉, mybatis 는 SQL 을 작성하는데 집중하돌고 만들어졌다.

     ※ SQL Map XML 파일은 첫 번째 (first class)요소만을 가진다.

     ·cache     : 해당 명명공간을 위한 캐시 설정
     ·cache-ref    : 다른 명명공간의 캐시 설정에 대한 참조
     ·resultMap    : 데이터베이스 결과 데이터를 객체에 로드하는 방법을 정의하는 요소
     ·parameterMap : 권장하지 않음
         과거에는 파라미터를 매핑하기 위해 사용했으나
      현재는 사용하지 않음
     ·sql      : 다른 구문에서 재사용하기 위한 SQL 조각
     ·insert      : 매핑된 insert 구문
     ·update      : 매핑된 update 구문
     ·delete      : 매핑된 delete 구문
     ·select     : 매핑된 select 구문 

 

4. Mybatis Framework 환경설정.txt

■■■ Mybatis Framework 환경설정 ■■■

1. 『http://blog.mybatis.org/』 에서 mybatis 다운로드

  - Products 메뉴 선택(클릭)
    → 『https://blog.mybatis.org/p/products.html』 로 이동
  
  - 이동한 페이지의 Products 항목의 리스트들 중
    『MyBatis 3 SQL Mapping Framework for Java』에서
     download 메뉴 선택(클릭)
     → 『https://github.com/mybatis/mybatis-3/releases』로 이동
  
  - 이동한 페이지에서 『Mybatis 3.5.10』 항목의
    『▶ Assets』 선택(클릭) → 『▼ Assets』 형태로 노드 확장

  - 확장된 노드의 목록들 중 『mybatis-3.5.10.zip 3.69 MB May 24, 2022』 선택 (클릭)
    → 파일 다운로드 진행

  - 다시 웹브라우저 뒤로가기 버튼 선택(클릭)
    → 『https://blog.mybatis.org/p/products.html』로 이동

  - 이동한 페이지의 Integration 항목의 리스트들 중
    『Spring Integration with Spring』에서
     download 메뉴 선택(클릭)
     → 『https://github.com/mybatis/spring/releases』로 이동

  - 이동한 페이지에서 『mybatis-spring-1.3.2』 항목의
    『▶ Assets』 선택(클릭) → 『▼ Assets』 형태로 노드 확장

  - 확장된 노드의 목록들 중 『mybatis-spring-1.3.2.zip 52.1 KB Mar 14, 2018』 선택(클릭)
    → 파일 다운로드 진행

2. 다운로드 완료된 파일을 압축 해제하여 아래의 파일을 준비한다.

  - mybatis-3.5.10.jar
  - mybatis-spring-1.3.2.jar

3. SpringMVC + mybatis 프로젝트 관련 라이브러리 등록
   - org.springframework.aop-3.0.2.RELEASE.jar
   - org.springframework.asm-3.0.2.RELEASE.jar
   - org.springframework.beans-3.0.2.RELEASE.jar
   - org.springframework.context-3.0.2.RELEASE.jar
   - org.springframework.core-3.0.2.RELEASE.jar
   - org.springframework.expression-3.0.2.RELEASE.jar
   - org.springframework.jdbc-3.0.2.RELEASE.jar
   - org.springframework.transaction-3.0.2.RELEASE.jar
   - org.springframework.web-3.0.2.RELEASE.jar
   - org.springframework.web.servlet-3.0.2.RELEASE.jar
 
   - cohttp://m.springsource.org.apache.commons.logging-1.1.1.jar
   
   - ojdbc6.jar
   
   - jstl.jar
   - standard.jar

     +

   - mybatis-3.5.10.jar
   - mybatis-spring-1.3.2.jar

※ 매퍼 XML 샘플
 
   다운로드를 수행한 pdf 파일(mybatis-3.5.10.pdf)의 내용 중
   『2.1.5 Exploring Mapped SQL Statements』항목의
   XML 관련 내용을 확인하여 샘플 DTD 를 구성할 수 있도록 한다.
   (→ pdf 파일의 페이지 번호 4)

<?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="org.mybatis.example.BlogMapper">
<select id="selectBlog" resultType="Blog">
select * from Blog where id = #{id}
</select>
</mapper>

-------------------------------------------------------------------------------------
■■■ Spring MVC + Annotation + mybatis 프로젝트 실습 01 ■■■

○ 프로젝트
   : MybatisWork01

○ 관련 라이브러리 등록 및 환경구성 (※ 위에서 정리한 내용참조)
   ..

○ 기능 구현
   : 마이바티스 환경 구성 후 프로젝트 정상 실행 여부 확인


-------------------------------------------------------------------------------------
■■■ Spring MVC + Annotation + mybatis 프로젝트 실습 02 ■■■

○ 프로젝트
   : MybatisWork02

○ 관련 라이브러리 등록 및 환경구성 (※ 위에서 정리한 내용참조)
   ..

○ 기능 구현
   : 이름, 전화번호를 데이터베이스에서 읽어내어 화면에 출력
     이 과정에서 mybatis 활용.

○ 데이터베이스 관련 객체 준비
   - 사용 계정 : scott
   - 테이블 : TBL_MEMBERLIST
   - 테이블 구조 : MID NUMBER      --PK
                   , NAME VARCHAR2(30)
   , TELEPHONE VARCHAR2(40)
   - 시퀀스 : MEMBERLISTSEQ

○ 페이지 레이아웃 구성
   회원 관리
 
   이름 [ ]
   전화 [  ]

    < 회원 추가 >

    전체 인원 수 : 2명
    ----------------------
     번호  이름     전화
      1    노은하   010-11..
      2    이주형   010-22..
    ----------------------

○ 물리적 파일 구성

   - MybatisWork02_scott.sql → 데이터베이스 관련작업
   
   - MemberDTO.java → 데이터 전송 객체 자료형 클래스(DTO)
   - IMemberDAO.java → 인터페이스
   - MemberDAO.xml → mybatis 환경 설정 파일 활용
   - MemberMain.java         → mybatis 객체 활용(Controller)
   - MemberList.jsp         → view 페이지 활용

   - dispatcher-servlet.xml → mybatis 객체 등록 및 활용
   - web.xml → front Controller 등록 및 인코딩 설정 (필터활용)

○ 사용자 최초 요청 주소
   http://localhost:3306/MybatisWork02/memberlist.action



-------------------------------------------------------------------------------------
■■■ Spring MVC + Annotation + mybatis 프로젝트 실습 03 ■■■

○ 프로젝트
   : MybatisWork03

○ 관련 라이브러리 등록 및 환경구성 (※ 위에서 정리한 내용참조)
   ..

○ 기능 구현
   : 기본적인 성적 관리
     이 과정에서 mybatis 활용

○ 데이터베이스 관련 객체 준비
   - 사용 계정 : scott
   - 테이블 : TBL_STUDENT
   - 테이블 구조 : SID NUMBER      --PK
                   , NAME VARCHAR2(30)
   , TEL VARCHAR2(40)

   - 테이블 : TBL_GRADE
   - 테이블 구조 : SID NUMBER      --PK
                   , SUB1 NUMBER(3)
   , SUB2 NUMBER(3)
   , SUB3 NUMBER(3)

   - 뷰 : STUDENTVIEW
      ·뷰 구조 : SID, NAME, TEL, SUB
  ---- 참조 레코드 수
   - 뷰 : GRADEVIEW
      ·뷰 구조 : SID, NAME, SUB1, SUB2, SUB3, TOT, AVG, CH
       ---- ---  ---
       총점 평균 등급(합격, 과락, 불합격)



○ 물리적 파일 구성

   - MybatisWork03_scott.sql → 데이터베이스 관련작업
   
   - StudentDTO.java → 데이터 전송 객체 자료형 클래스(DTO)
   학생 데이터 저장 및 전송

   - GradeDTO.java → 데이터 전송 객체 자료형 클래스(DTO)
   성적 데이터 저장 및 전송

   - IStudentDAO.java → 인터페이스
   학생 데이터 액션 처리 메소드 선언
   - IGradeDAO.java → 인터페이스
   성적 데이터 액션 처리 메소드 선언

   - StudentDAO.xml → mybatis 환경 설정 파일 활용
   - GradeDAO.xml → mybatis 환경 설정 파일 활용

   - StudentController.java     → Controller
   - GradeController.java → Controller

   - StudentList.jsp       → View 페이지
       (학생 명단 출력 레이아웃 구성)
   - StudentInsertForm.jsp → View 페이지
       (학생 데이터 입력 폼 구성)
   - GradeList.jsp       → View 페이지
       (성적 리스트 출력 레이아웃 구성)
   - GradeInsertForm.jsp → View 페이지
       (성적 데이터 입력 폼 구성)


   - dispatcher-servlet.xml → mybatis 객체 등록 및 활용
   - web.xml → front Controller 등록 및 인코딩 설정 (필터활용)

○ 사용자 최초 요청 주소
   http://localhost:3306/MybatisWork03/studentlist.action

5. 파일시스템 및 파일업로드.txt

■■■ 파일 시스템 및 파일 업로드.txt ■■■

○ java.io.FileInputStream 클래스

  자바에서는 파일에 대한 바이트 단위 입출력을 수행할 수 있도록 하기 위해
  FileInputStream 클래스와 FileOutputStream 클래스를 제공하고 있다.

  ※  FileInputStream 클래스
: 시스템의 파일로부터 데이터를 바이트스트림으로 읽어들이기 위해 사용
  ※  FileInputStream 클래스를 이용하여 데이터를 읽어들일 때에는
      데이터소스인 파일과 직접 연결하여 사용한다.
      (이 때, 지정한 파일이 존재하지 않을 경우 IOExcepion 발생)
  ※  FileInputStream 클래스는 Inputstream 클래스의 하위 클래스이므로
      InputStream 클래스의 기본적인 메소드를 상속받거나 재정의하여 사용한다.
      (InputStream 클래스는 바이트 단위 입출력 기능의 최상위 클래스이며 추상 클래스이다.)

  - 생성자
  · FileInputStream(File file)
     : 주어진 File 객체가 가리키는 파일을 바이트스트림으로 읽기 위한
       FileInputStream 객체를 생성한다.
  · FileInputStream(FileDescriptor fdObj)
     : 주어진 FileDescriptor 객체가 가리키는 파일을 바이트스트림으로 읽기 위한
       FileInputStream 객체를 생성한다.
  · FileInputStream(String name)
     : 주어진 이름이 가리키는 파일을 바이트스트림으로 읽기 위한
       FileInputStream 객체를 생성한다.

○ java.io.FileOutputStream 클래스

   FileOutputStream 클래스는
   데이터를 파일에 바이트스트림으로 저장하기 위해 사용한다.
   파일명이나 File 클래스의 객체를 인수로 넘겨줌으로써
   시스템에 파일을 직접 생성할 수 있다.
   기본적으로(default) 파일이 이미 존재한다면 덮었긔로 처리되기 때문에
   기존의 내용은 사라지게 된다.

   ※FileOutputStream 클래스는 OutputStream 클래스의 하위 클래스이므로
     OutputStream 클래스의 기본적인 메소드를 상속받거나 재정의하여 사용할 수 있다.   

  - 생성자
  · FileOutputStream(File file)
     : 주어진 File 객체가 가리키는 파일을 바이트스트림으로 쓰기 위한
       FileOutputStream 객체를 생성한다.
       기존의 파일이 존재할 경우 기본적으로 (default) 그 내용을 지우고
       새로운 파일을 생성하게 된다.(덮어쓰기)
  · FileOutputStream(FileDescriptor fdObj)
     : 주어진 FileDescriptor 객체가 가리키는 파일을 바이트스트림으로 쓰기 위한
       FileOutputStream 객체를 생성한다.
       기존의 파일이 존재할 경우 기본적으로 (default) 그 내용을 지우고
       새로운 파일을 생성하게 된다.(덮어쓰기)
  · FileOutputStream(String name)
     : 주어진 이름이 가리키는 파일을 바이트스트림으로 쓰기 위한
       FileOutputStream 객체를 생성한다.
       기존의 파일이 존재할 경우 기본적으로 (default) 그 내용을 지우고
       새로운 파일을 생성하게 된다.(덮어쓰기)
  · FileOutputStream(String name, boolean append)
     : 주어진 이름이 가리키는 파일을 바이트스트림으로 쓰기 위한
       FileOutputStream 객체를 생성한다.
       기존의 파일이 존재할 경우 append 로 설정된 값에 따라(true / false)
       그 내용을 지우고 새로운 파일을 생성하거나(false) 기존의 내용에 추가한다.(true)

○ java.io.FileReader 클래스

  FileReader 클래스는
  파일에 저장된 바이트를 유니코드 문자로 변환하여 읽어들이고,
  파일 쓰기 클래스인 FileWriter 클래스는
  출력할 유니코드 문자열을 시스템에 맞는 디폴트 문자 인코딩 방식으로 변환하여
  파일에 저장하는 역할을 수행한다.

  FileReader 클래스는
  파일에 저장된 문자열을 읽어들이는데 사용되며,
  이 클래스는 InputStreamReader 클래스를 상속한 것으로
  바이트 스트림을 읽어서 그 바이트를 유니코드로 나타내는 정수타입의 값으로
  변환해준다.

  FileReader 클래스 역시 데이터를 읽어들일 소스인 파일과 직접 연결하여 사용되며,
  지정한 파일이 존재하지 않을 경우 FileNotFoundException 을 발생시키게 된다.

  - 생성자 
·FileReader(File file)
  : 주어진 File 객체를 이용하여 FileReader 객체를 생성한다
·FileReader(FileDescriptor fd)
  : 주어진 FileDescriptor 객체를 이용하여 FileReader 객체를 생성한다
·FileReader(String fileName)
  : 주어진 이름의 파일을 열어 FileReader 객체를 생성한다

○ java.io.FileWriter 클래스

  FileWriter 클래스는
  파일 문자 출력스트림으로 출력할 문자를 디폴트 문자 인코딩 바이트로 변환하여
  파일에 저장하고자 할 때 사용한다.
  이 클래스는 OutputStreamWriter 클래스의 서브 클래스로
  유니코드를 바이트로 변환하는 기능을 담당하게 된다.
  FileOutputStream 클래스와 마찬가지로
  파일명이나 File 클래스의 객체를 인수로 넘겨줌으로써
  시스템에 파일을 직접 생성하게 된다.
  기본적으로(default) 해당 파일이 이미 존재할 경우 덮어쓰기 하게 된다.

  - 생성자
·FileWriter(File file)
  : 주어진 File 객체를 이용하여 FileWriter 객체를 생성한다.
·FileWriter(FileDescriptor fd)
  : 주어진 FileDescriptor 객체를 이용하여 FileWriter 객체를 생성한다.
·FileWriter(String fileName)
  : 주어진 이름의 파일을 열어 FileWriter 객체를 생성한다.
·FileWriter(String fileName, boolean append)
  : 주어진 파일을  append 값에 따라(true / false)
        읽기 / 추가 모드로 열어 FileWriter 객체를 생성한다.

※ 파일과 디렉터리 관련(관리) 클래스 → java.io.File 클래스

  File 클래스는 파일 및 디렉터리를 관리할 수 있도록 기능을 제공해주는 클래스로
  파일의 복사 또는 이름 변경 등의 조작을 할 경우 사용될 뿐
  파일의 내용을 입출력하기 위한 메소드를 제공해주지는 않는다.
  자바에서는 모든 데이터의 입출력을 『스.트.림』에 기반하여 수행하기 때문에 
  File 클래스는 내부적으로 이러한 메소드를 구현할 필요가 없는 것이다.
  단, File 클래스의 인스턴스는 변경 불가능하다.
  즉, 한 번 생성되면 File 객체에 의해 표현되는 추상 경로명은 절대 변하지 않는다.

※ 파일 업로드

  웹 브라우저를 통해 파일을 전송하기 위해 폼을 구성할 경우
  - form 태그 안에.. input 태그의 type 속성의 속성값이
    file 인 태그를 통해 파일을 선택할 수 있는 대화창을 제공한다.
  - 이 때, method 의 속성은 post 를 사용해야 하며,
    enctype 속성의 속성값은 『"multipart/form-data"』로 지정한 폼을 전송할 경우
  - 단, 『"multipart/form-data"』로 지정한 폼을 전송할 경우
    request 객체로 얻어낸 파라미터 이름으로 값을 얻어낼 수 없다.
    이 말은 『<input type="file">』로 지정된 파일을
    서버 상의 특정 경로에 업로드 하기 위해서 『특별한 컴포넌트』가
    필요하다는 의미이다.


※ 특별한 컴포넌트 : 『cos.jar』
 
  - 다운로드 URL → http://www.servlets.com/cos
  - 다운로드 파일 → cos-22.05.zip