'Web'에 해당되는 글 10건

  1. 2011.01.21 struts2 interceptor
  2. 2011.01.17 스트러츠2 + 타일즈 설정 2
  3. 2010.11.02 servlet Post방식 1
  4. 2010.11.02 servlet Get방식 테스트
  5. 2010.11.01 스트러츠 셋팅
  6. 2010.02.18 <Spring>
  7. 2010.02.18 <Struts>
  8. 2010.02.18 <Servlet>
  9. 2010.02.18 <Web 개요>
  10. 2010.02.18 <JSP 정리> 1

struts.xml

      <interceptor-ref name="prepare"/>             
      <interceptor-ref name="modelDriven"/>
      <interceptor-ref name="params"/>

prepare인터셉터 : Action에서 Preparable인터페이스를 사용해서 prepare()메소드를 구현하면
                           Action메소드를 호출하기전에 먼저 prepare()메소드를 수행한다.
  * vo객체생성

modelDriven인터셉터 : ModelDriven인터페이스를 구현한 액션클래스의 getModel()메소드를
                                 호출해서 getModel()메소드가 반환하는 객체의 프로퍼티를 밸류 스택에 저장한다.
                                 이 인터셉터는 모델이 널값이 아닌 경우에 스택에 저장한다.
  * form에서 넘어온 데이터를 스택에 저장

params인터셉터 : 모든 파라미터를 밸류 스택에 저장한다.
  * 스택에 있는 데이터를 vo에 넣어줌

Action.java 

 public class UserName implements Preparable, ModelDriven<TestVo>{
    // Preparable과 ModelDriven을 implements한 후
    private TestVo testVo;
    public TestVo getTestVo() {
      return testVo;
    }
    public void setTestVo(TestVo testVo) {
      this.testVo = testVo;
    }

    //Preparable 인터페이스에 반드시 구현해야하는 메소드
    public void prepare(){
      // 여기에 사용자가 폼객체로 사용할 객체 생성
      testVo = new TestVo(); 
    }
    public TestVo getModel(){
      //프로퍼티를 밸류 스택에 저장
      return testVo
    }
    public String execute()  throws Exception{
      return "success";
    }
}

Posted by 미스터네오
,



진행순서
① 사용자로부터 요청이 들어오면 Interceptor를 지나 Action 에서 Business Logic을 수행 후
    action mapping 에의해 result로 결과가 보내지게 된다.
② 이때 result 의 type="tiles" 로 설정하게 되면 Result에서는 web.xml에 설정한 Tiles Listener를 수행하고
    WEB-INF 폴더 아래에 있는(web.xml 파일과 경로가 같은) tiles.xml(tiles의 설정이 들어있는 xml파일을 로딩한다.)
   이름은 어떠한 것이라도 상관 없다
③ 그 결과를 다시 Interceptor에 전달하여 사용자로 결과를 보내주게 된다.

작업순서
1) Tiles Plug-in을 수행하기 위한 Library파일을 설정한다.
    struts 2의 스펙에 있는 다음의 Library파일을 추가 한다.
commons-digester-1.8.jar              :  플러그인을 사용하기 위해서 꼭 필요한, 플러그인을 이용하겠다고 정의해주는 Library
struts2-tiles-plugin-2.0.14.jar           :  아래서부터는 tiles를 사용하기 위한 library 
tiles-api-2.0.4.jar
tiles-core-2.0.4.jar
tiles-jsp-2.0.4.jar

2) web.xml 파일에 Tiles Listener를 설정한다.
<listener>
    <listener-class>
      org.apache.struts2.tiles.StrutsTilesListener 
    </listener-class>
</listener> 

3) Tiles의 설정이 들어있는 tiles.xml파일을 생성(파일의 이름은 아무거나 상관이 없으며 WEB-INF폴더 에 있어야 한다.)
 <?xml version="1.0" encoding="EUC-KR" ?>

<!DOCTYPE tiles-definitions PUBLIC
       "-//Apache Software Foundation//DTD Tiles Configuration 2.0//EN"
       "http://tiles.apache.org/dtds/tiles-config_2_0.dtd">

<tiles-definitions>
    <definition name="index" template="/tiles/classicLayout.jsp">
        <put-attribute name="title"  value="Struts2 Tiles Example"/>
        <put-attribute name="menu"   value="/tiles/menu.jsp"/>
        <put-attribute name="header" value="/tiles/header.jsp"/>
        <put-attribute name="body"   value="/tiles/body.jsp"/>
        <put-attribute name="footer" value="/tiles/footer.jsp"/>
    </definition>
   
    <definition name="menu1" extends="index">
            <put-attribute name="body"   value="/tiles/body-menu1.jsp"/>
    </definition>
 
   <definition name="menu2" extends="index">
        <put-attribute name="body"   value="/tiles/body-menu2.jsp"/>
    </definition>
</tiles-definitions>

template로 설정한 jsp페이지는 기본레이아웃이 되는, 즉 index 파일이라고 말할수 있다.

하위 정의로 부터 menu1일때는 상단에 선언한 index 에서 body부분만 다음과 같은 jsp페이지로 변경하겠다는 뜻이다.

4) action mapping을 수행한다.(tiles.xml이라는 파일에서 action mapping을 수행한다.)

 <struts>
    <package name="tiles" namespace="/tiles" extends="struts-default, tiles-default">
        <action name="index">
            <result type="tiles">index</result>
        </action>
        <action name="menu1">
            <result type="tiles">menu1</result>
        </action>
        <action name="menu2">
            <result type="tiles">menu2</result>
        </action>
    </package>
</struts>
extends="tiles-default" : tiles 에서 기본적으로 사용하는 Interceptor를 수행하겠다는 설정으로 다음의 설정을 꼭해주어야
                                  Tiles를 사용할 수 있다.

만약 주소창에 index.action으로 들어오면 action name="index" 가 수행한다.
그리고는 result type="tiles" 인것을 확인하고 tiles설정이 되어있는 곳으로가 줄쳐진 index라는 곳으로 이동한다.
즉 위의 index는 tiles설정이 들어가 있는 tiles.xml(web.xml과 같은 경로에 있는 tiles설정 파일)로 들어가
definition name="index" 인것을 찾아 들어가 실행 시킨다.

5) jsp의 레이아웃 설정(tiles에서 지원하는 tag library를 통해 jsp페이지 끼워 넣을 수 있다.)
<%@ taglib prefix="tiles"  uri="http://tiles.apache.org/tags-tiles"%>
<tiles:getAsString name="title" />
<tiles:insertAttribute name="header"/>
tiles-difinition 문서에서 이름이 title인것을 찾아 문자 형으로 리턴해 준다.
즉 <put-attribute name="title"  value="Struts2 Tiles Example"/>이기 때문에 결국 화면엔 "Struts2 Tiles Example" 이렇게 출력 된다.
<put-attribute name="header" value="/tiles/header.jsp"/>
이렇게 설정되어 있기 때문에 header.jsp가 입력이 된다.

출처 : http://javastore.tistory.com/

Posted by 미스터네오
,

get방식을 보고 오신 분들은 바로 post방식으로 넘어가면 되지만 이전 글을 안보고 오신 분들은 get방식을 보고 오십시오

post 방식을 바로 시작하겠습니다.


1. 먼저 Web Content마우스 오른쪽 클릭 -> New -> Foder를 생성합니다.


2. 폴더명은 임의로 작성하되 너무 복잡하지 않게 합니다.


3. 폴더를 생성하면 폴더안에 jsp파일을 2개를 작성합니다. 간단하게 input.jsp와 result.jsp를 생성합니다. 생성방법은 폴더생성 방법에서 jsp를 선택하여 생성합니다.


4. 먼저  input.jsp에 <body> 안쪽 부분에 다음과 같이 작성해 줍니다.
 <form action="sevletPost.do" method="post">
  <table>
   <tr>
    <td>당신의 이름은?</td>   
   </tr>
   <tr>
    <td>
     <input type="text" name="name" />
     <input type="submit" name="확인" />
    </td>
   </tr>
  </table>
 </form>


5. result.jsp파일에는 다음과 같이 작성합니다.
 <table>
  <tr>
   <td>
    당신의 이름은 <%request.getAttribute("name"); %>입니다.
   </td>
  </tr>
 </table>


6. 이전에 작성해 놓았던 Servlet클래스 파일르 가서 doPost 메소드 안에 다음과 같이 작성해 줍니다.
  System.out.println("doPost()");
  
  String name = request.getParameter("name");
  request.setAttribute("name", name);
  
  RequestDispatcher dispatcher = request.getRequestDispatcher("/post/result.jsp");
  dispatcher.forward(request, response);


7. 마지막으로 web.xml에 다음과 같이 추가해준다.
  <servlet-mapping>
    <servlet-name>Servlet</servlet-name>
    <url-pattern>/post/sevletPost.do</url-pattern>
  </servlet-mapping>


8. 이제 서버를 내렸다가 다시 켜고 다음과 같은 경로로 들어간다. http://localhost:8080/TestServlet/post/input.jsp 위와 같은 화면이 나온다.

9. 이제 이름을 적고 버튼을 누르면 post방식으로 전송되는데 난 왜 안될까?? 확인해 보니 한글이 깨져서 나간다. 수정하고 다시 해봐야 겠다.

'Web > Servlet 정리' 카테고리의 다른 글

servlet Get방식 테스트  (0) 2010.11.02
<Servlet>  (0) 2010.02.18
Posted by 미스터네오
,

기본적으로 톰캣과 이클립스의 셋팅을 끝낸 후에 작업을 시작하는 것이 좋겠다.

프로젝트도 끝나고 본사로 복귀했지만 기초가 안잡혀 있는 신입이 이번기회를 통해서 다시 공부하는 계기로 삼고 열심히 하자!

시작합니다.

1. 먼저 프로젝트 익스플로러에서 마우스 오른쪽 클리 후에 New -> Other로 갑니다.(화면처럼 Dynamic Web Project가 있는 경우는 직접 선택하여 만듭니다.)


2. 위 화면에서 검색창에 dy라고만 쳐주면 다이나믹 웹 프로젝트가 나오는 걸 확인 할 수 있습니다 선택 후 Next


3. 맨 위에 프로젝트명을 적어주고 자신이 설치한 톰캣버전을 선택 후 Finish


4. 생성된 프로젝트를 마우스 오른쪽으로 클릭하여 위 그림처럼 선택한다.


5. 그림처럼 왼쪽메뉴에서 Java Build Path 선택 -> 위쪽 탭 메뉴에서 Libraries를 선택 -> 톰캣 선택 -> Add External JARs... 버튼 선택한다.


6. 이제 jar파일 선택하라는 창이 뜨는데 자신이 설치한 톰캣의 경로로 가서 lib폴더에 servlet-api.jar파일을 추가해 준다.
    (ex : D:\dev\server\apache-tomcat-6.0.20\lib) 


7. 이제 1번에서 만들었던 프로젝트에서 Java Resources: src를 마우스 오른쪽 클릭 -> New -> Package를 선택한다.


8. 패키지 명은 아무거나 적어주면 좋겠다 하지만 의미있는 프로젝트명으로 만들어 주는것이 좋을듯 싶다.


9. 패키지를 생성하면 위 화면처럼 보이게 된다.


10. 생성된 패키지를 마우스 오른쪽 클릭 -> New -> Servlet 선택(만약 Servlet이 없으면 Other를 선택후 Servlet을 검색)


11. Class 이름을 써 준다. 이때 기본적으로 자바에서 클래스 이름의 첫글자는 대문자로 사용한다. -> Finish


12. 클래스 파일을 생성하게 되면 패키지의 색상이 바뀌고 위 화면처럼 클래스 파일이 생성된다.


13. 그림은 간단한 설명이다.


14. doGet()메서드에 위와같은 코드를 작성해준다.
  System.out.println("doGet()");
  
  response.setContentType("text/html");
  response.setCharacterEncoding("euc-kr");
  
  PrintWriter out = response.getWriter();
  out.write("<HTML><HEAD><TITLE>Get방식</TITLE></HEAD>");
  out.write("<BODY><H1>");
  out.write("Get방식으로 접근하셨습니다.");
  out.write("<H1></BODY></HTML>");
  out.close();


15. 지금까지의 세팅을 모두 저장하고 톰캣에 프로젝트를 추가하여 서버를 실행하자


16. 이제 익스프롤러에서 http://localhost:8080/TestServlet/Servlet 경로를 적어 넣으면 위와같은 화면이 뜬다면 get방식으로 servlet접근이 성공한것이다.


17. 이때 web.xml을 확인해보면 위 그림 처럼 확인 할 수 있는데 경로와 비교해 본다면 어떻게 흘러가는지의 방향을 알 수 있다.

'Web > Servlet 정리' 카테고리의 다른 글

servlet Post방식  (1) 2010.11.02
<Servlet>  (0) 2010.02.18
Posted by 미스터네오
,
프로젝트 사이트 구축을 위해 스트러츠를 사용하기로 하고 세팅을 시작했다.
분명 수업시간에도 헤맸는데 잘 될까 모르겠다 -ㅁ-;

그래도 열심히 해보자~!!

OS : windows2003 server
DB : oracle 9i or 10g(불확실...ㅋ;;)
Tools : eclips

첫번째 스트러츠 관련 파일들을 받는다.
수업시간에 배운걸 활용해서 정리하는 것이기 때문에
다운 받은 파일도 그에 따른다..-ㅁ-;(사실 잘모르니까 따라해야한다..ㄷㄷㄷ;;)

struts-1.3.8-all.zip파일을 받고 압축을 풀어둔다.

두번째 단계 이클립스를 실행하여 세팅준비^^
나는 우리 프로젝트가 온라인 서점이기 때문에 프로젝트 이름을 BEANBOOK으로 했다..ㅎ
dynamin web project 로 생성하면 된다~
아까 압축을 푼 파일에서 다음 경로의 모든 파일을 복사한다.[struts-1.3.8-all\struts-1.3.8\lib]
그리고 그 파일들을 아까의 프로젝트 webcontent\WEB-INF\lib에 붙여 넣는다.
잘 붙여넣었는지 꼭 확인해준다~!!

세번째 작업은 아까 푼 압축파일 중에 struts-1.3.8-all\struts-1.3.8\apps 이 폴더에 가면
struts-blank-1.3.8.war 파일이 있는데 이 파일의 압축을 푼다.
그럼 위와 같은 내용이 들어 있는 것을 확인할 수 있다.

WEB-INF폴더안에 web.xml파일이 있는데 파일 내용 중 다음을 복사해서  이클립스에 생성한 프로젝트 안에
webcontent\WEB-INF의 폴더 안의 web.xml 파일에 붙여 넣는다.
그런 다음 이 파일 꼭 저장해주기~^^

다시 압축 푼 파일의 WEB-INF폴더안에 가서 struts-config.xml와 validation.xml파일을 복사해서
프로젝트의 webcontent/WEB-INF폴더 안에 붙여 넣어 준다.
짜자자잔~~ 이렇게 확인하면 되겠다~!!

네번째..본격적 코드를 만져볼 수 있겠다. 우선 struts-config.xml파일을 열어서
<message-resources parameter="MessageResources" />이 코드를 찾아서
<message-resources parameter="java.MessageResources" />요렇게 수정한다.

이에 따라 struts-1.3.8-all\struts-1.3.8\apps\struts-blank-1.3.8\WEB-INF\src\java 안에 있는 MessageResources.properties파일을 복사하여 java Resources:src에 패키지 하나(이름은 java) 생성하여 붙여 넣는다.
이 작업이 끝나면 struts-1.3.8-all\struts-1.3.8\apps\struts-blank-1.3.8 폴더안에
META_INF폴더와 index.jsp파일을 복사해서 Webcontent폴더에 붙여 넣는다. 이미 META_INF폴더가 있기 때문에
중복되었다는 메시지가 나올지도 모른다. 덮어쓰기를 해두면 된다~~
이에 덧붙여 struts-1.3.8-all\struts-1.3.8\apps\struts-blank-1.3.8\pages폴더도 복사해서 같이 붙인다.

대충 스트러츠 세팅은 이것으로 완료다~!!
제대로 되었는지 확인을 하기 위해 인터넷 탐색기 프로그램으로 확인해보자.
(서버에 프로젝트가 추가되었는지도 꼭 확인해주기...^^;)

http://localhost:9090/bb/


요렇게 나온다면 struts설정은 성공~!!

출처 : http://sijung.tistory.com/54

'Web > Struts 정리' 카테고리의 다른 글

<Struts>  (0) 2010.02.18
Posted by 미스터네오
,

<Spring>

Web/Spring 정리 2010. 2. 18. 14:57


1. Spring Framework 기본 개념 정리
  (1) POJO (Plain Old Java Object)
       다른 클래스를 상속받아서 만들어야 하는 클래스가 아닌 순수한 형태의 자바 클래스
  (2) IoC(Inversion of Control)
       제어의 역전이라는 뜻으로 개발자가 직접 객체를 언제 생성하고 없앨지 결정하는 것이 아니라
       컨테이너에게 맡긴다는 뜻이다.
       POJO(Plain Old Java Object) 객체의 생성에서 생명주기의 관리까지를
       IoC Container 에게 담당시킴으로써(XML 이용)  개발에 있어서 편의성과 재사용성의 극대화를 추구하는 개념
  (3) AOP (Aspect Oriented Programming)
       관점 지향 프로그래밍이란 뜻으로 기존의 객체지향언어에 의해 추구된 모듈화에 따라 많아진 중복된
       코드라던지 공통된 처리에 관련한 것들을 관점으로 뽑아내어 공통으로 처리하는 방식

2.  IoC (Inversion of Control)
  (1) Bean 의 관리
       1) Spring 에서 org.springframework.beans.factory.BeanFactory 가 기본 IoC 컨테이너이고,  
           보다 진보된 형태로 ApplicationContext 라는 컨테이너도 같이 지원하고 있다.
       2) IoC 컨테이너에 의해서 Bean 의 생명주기가 관리된다.
       3) 이렇게 관리되는 Bean 은 POJO 타입이고 싱글톤이다.
       4) XML 설정을 통해서 각각의 Bean 들을 묶어주는데, 이런 것을 일컬어 묶기(wiring)라고 한다.
       5) 묶인 Bean 을 원하는 곳에 세팅하는 것을 DI(의존성 주입) 이라고 부른다.
  (2) DI (Dependency Injection)
       의존성 주입이란 뜻으로 객체를 생성해서 필요로 하는 곳에 넣어주는 것을 뜻한다.
       1) Constructor Injection (생성자 주입)
           생성자에 필요 객체를 선언하고 멤버변수(Field)로써 객체를 사용하는 것을 말한다.
           객체 생성시 자동으로 IoC 컨테이너가 관련 객체를 주입시켜준다.
       2) Setter Injection (세터 메소드 이용 주입)
           생성자 주입과 방식은 비슷하나 setter 메소드를 이용한다는 점이 차이점이다.

 ex) 
 public class ExampleBean {
    private AnotherBean beanOne;
    private YetAnotherBean beanTwo;
    private int i;

    public void setBeanOne(AnotherBean beanOne) {
        this.beanOne = beanOne;
    }
    public void setBeanTwo(YetAnotherBean beanTwo) {
        this.beanTwo = beanTwo;
    }
    public void setIntegerProperty(int i) {
        this.i = i;
    }    
}

       3) Method Injection (메소드 주입)
          Singleton(싱글톤 : 오직 하나의 객체만 생성되는 패턴) 객체와 Non-Singleton 객체간의 연결이 
          필요할 경우 사용하는 방식
  (2) DI 를 위한 xml 설정
       1) Constructor Injection

<bean id="foo" class="com.spring.Foo">
    <constructor-arg><ref bean="bar" /></constructor-arg>
</bean>  

       c.f.) 생성자의 인자가 여러개인 경우 type 이나 index 로써 구별해서 넣어주는 것도 가능하다.
       2) Setter Injection 

<bean id="foo" class="com.spring.Foo">
    <property name="bar">
        <ref bean="bar"/>
    </property>
</bean>

3. AOP (Aspect Oriented Programming)
  (1) 용어 정리
       1) Aspect
           관점이란 뜻으로 트랜젝션, 보안, 로깅 처럼 공통적으로 쓰이는 부분들에 개입하는 것을 모듈화한 것
       2) Join point
           클래스의 객체 생성 시점, 메소드 호출 시점, Exception 발생 시점 등 AOP가 개입되는 시점을 말한다.
       3) Advice
          특정한 join point에서 interceptor 형태로써 다양한 기능을 제공하는 것을 뜻한다.
          <1> Before advice : 메소드 호출전의 기능 제공
          <2> After returning advice : 모든 메소드 실행이 다 끝나고 난 뒤 기능 제공(익셉션 발생하지 않음)
          <3> After throwing advice : 익셉션이 던져졌을때 기능 제공
          <4> After (finally) advice : 익셉션 발생이 됐던 안됐던 간에 기능 제공
          <5> Around advice : 가장 강력한 advice 로써 메소드 시작부터 마지막까지 두루 기능을 제공하는 것이 가능
       4) Pointcut
           정규 표현식이나 AspectJ의 문법 등으로 실제로 적용되는 join point 를 선언하는 것을 뜻한다.
       5) Weaving
           실제 aspect 객체와 대상 객체를 컴파일시나, 로딩시나, 실행시에 합쳐주는 것을 뜻한다.
       6) Target
           실제 advice를 받는 객체로써 대상을 뜻한다.
  (2) Spring AOP
       1) Spring 에서 지원하는 AOP로써 proxy 기반이다. AspectJ 라는 AOP 툴이 있지만, Spring AOP 만으로도
           Bean에게 거는 AOP 기능은 충분히 활용 가능하다. 단, 메소드의 실행에 관해서만 Pointcut 을 걸 수 있다.
       2) Advice 작성을 위한 Advice interface
          <1> MethodBeforeAdvice : 메소드 실행 전
          <2> AfterReturningAdvice : 메소드 실행 후
          <3> ThrowsAdvice : 메소드 실행 중 익셉션 발생시
          <4> MethodInterceptor : 메소드 실행 전, 후 예외 발생시점에 적용
       3) AOP XML 설정
          <1> Annotation 을 이용한 @AspectJ 방식 (Spring 개발팀 추천)
               a. 설정 파일(applicationContext.xml등)에 다음의 구문을 먼저 추가한다.

             b. aspectjweaver.jar, aspectjrt.jar 파일 두개를 lib 에 추가한다.
             c. class 선언부 위에 @Aspect 를 추가한다.
             d. 메소드위에 @Pointcut("execution()") 을 추가한다.(메소드는 private void 의 가명 메소드)
    ※ Pointcut execution 설정방법

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern)
         throws-pattern?)       (?는 생략가능)

            형식 execution(제한자? 리턴타입 패키지? 메소드명(파라미터) throws선언?)
    
             e. Pointcut 의 종류 : execution, within, bean 등 스프링 레퍼런스 문서 참조
             f. Advice 의 종류 : @Before, @AfterReturning, @AfterThrowing, @After, @Around
                                       @Around 사용시 첫번째 인자로 ProceedingJoinPoint 가 있어야 하며 proceed() 메소드가
                                       호출되어야 한다. 그리고 return type 도 Object 로 맞추거나 void 로 맞춰준다.
         <2> XML 스키마를 이용한 설정방식
             a. 위의 <1> 의 a처럼 schema 설정이 잡혀있어야 한다.
             b. xml 설정을 잡는다.
                  <aop:config> : 이 태그 안에 설정을 잡아준다.
                  <aop:aspect> : POJO 방식의 빈으로 aspect 를 설정할때 사용한다.
                  <aop:pointcut>,<aop:advisor> : Spring API 인터페이스를 상속 받아서 만들 경우 사용한다.
                  ※ <aop:aspect> 안쪽의 advice 태그 종류
                   <aop:before>, <aop:after-returning>, <aop:after-throwing>, <aop:after>, <aop:around>
             c. 관련 Bean을 만들어 주는데 Spring API 인터페이스를 이용한 경우 다음과 같은 interface를 이용할 수 있다.
                  - MethodBeforeAdvice
                  - AfterReturningAdvice
                  - ThrowsAdvice
                  - MethodInterceptor : around 와 같은 기능

4.  Spring MVC
  (1) 구성요소
       1) DispatcherServlet : 클라이언트 요청을 받아서, 컨트롤러에 요청을 전달하고 컨트롤러가 리턴한
                                       결과 값을  View 에 전달하여 응답을 생성한다. (Struts 의 ActionServlet)
       2) HandlerMapping : 클라이언트 요청 URL 을 어떤 컨트롤러가 처리할지를 결정한다. (struts-config.xml 의 역할)
       3) Controller : 요청을 처리하고 결과를 리턴한다 (Struts 의 Action)
       4) ModelAndView : 컨트롤러가 처리한 결과 정보 및 뷰에 관련한 정보를 담는 객체 (struts의 forward 기능 포함)
       5) ViewResolver : 컨트롤러 처리 결과를 생성할 뷰를 결정
       6) View : 컨트롤러 처리 결과 화면을 생성하는 객체
  (2) 기본적인 Spring MVC 설정 잡기
       1) web.xml 에 DispatcherServlet 의 설정을 잡는다. (여기서 잡은 이름-servlet.xml 파일이 설정파일이 된다)
       2) HandlerMapping 을 이용 URL 과 Bean의 name 속성을 같은 것으로 설정한다.

   <bean id="beanName" class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" />

       c.f.) 만약 이 설정을 넣지 않으면 자동으로 이 HandlerMapping 이 적용된다.
       3) Spring 설정 파일에 name에 URL 을 입력하고 class에 Controller 를 지정한 뒤 작성한다.
       4) Controller 에서는 ModelAndView 객체를 생성해서 직접 갈 곳을 지정해준다.
  (3) HandlerMapping 구현 클래스
       1) SimpleUrlHandlerMapping : 패턴과 컨트롤러 이름을 비교하여, URL 이 패턴에 매칭될 경우 지정 컨트롤러 사용
       2) BeanNameUrlHandlerMapping(default) : URL 과 일치하는 bean 이름의 컨트롤러 사용
       3) ControllerClassNameHandlerMapping : URL 과 매칭되는 클래스 이름을 갖는 빈을 컨트롤러 사용
       4) DefaultAnnotationHandlerMapping : @RequestMapping 어노테이션을 이용 컨트롤러 사용
           참고1) web.xml에 <url-pattern> 을 '/path/*'  같이 설정을 할 경우 전체 경로를 다 사용하고 싶으면
                   HandlerMapping  설정시 <property name="alwaysUseFullPath" value="true" /> 를 넣어 설정을 잡는다.
           참고2) 복수개의 HandlerMapping 구현시 property 로 order 를 넣어서 순서를 정해줄 수도 있다.
  (4) Controller 구현 클래스
       1) Controller, AbstractController : 단순 처리용
       2) AbstractCommandController : 요청 파라미터를 객체에 자동으로 저장해 주고 검증기능 제공한다.
       3) SimpleFormController : 폼을 출력하고 폼에 입력한 데이터를 처리할때 사용
       4) AbstractWizardFormController : 여러 페이지에 걸쳐 데이터 입력시 사용
       5) ParameterizableViewController, UrlFilenameViewController : 단순히 뷰로 바로 전달할때 사용
       6) MultiActionController : 비슷한 로직을 수행하는 기능들을 하나의 컨트롤러로 구현할때 사용
  (5) ViewResolver 구현 클래스
       1) InteralResourceViewResolver(default) : JSP 나 tiles 연동 위한 View 객체를 리턴
       2) VelocityViewResolver : Velocity 연동을 위한 View 객체를 리턴
       3) BeanNameViewResolver : 뷰 이름과 똑같은 이름의 Bean 객체를 View 로 이용
       4) ResourceBundleViewResolver : 뷰 이름과 View 객체간 매핑 정보를 특정 자원 파일에 저장해서 사용 
       5) XmlViewResolver : 뷰 이름과 View 객체간 매핑 정보를 XML 파일에 저장해서 사용
  (6) Validator 와 Errors
       1) Validator 인터페이스를 상속받은 클래스로써 command(form)에 들어오는 값들에 대한 검증이 가능하다
       2) 주요 메소드 (Validator 인터페이스를 상속받는 클래스에서 구현해야 하는 메소드)
          <1> boolean supports(Class clazz) : 인자값으로 들어오는 클래스가 검증대상인지 확인하는 메소드
          <2> void validate(Object target, Errors errors) : 실제 검증 메소드 (target 은 command 객체이다)
                a. ValidationUtils 클래스를 통해서 데이터의 검증을 한다. 혹은 Errors 를 이용해 에러를 저장한다.
                b. 이렇게 저장된 오류는 jsp 화면에서 <form:errors> 를 이용해 오류를 보여주는 것이 가능하다.
                c. Errors 에는 전체적인 오류를 저장하기 위한 reject 메소드와 특정 필드에 대한 오류를 저장하기 위한
                    rejectValue 메소드가 있다.
       3) command 가 쓰이는 Controller xml 설정에 프로퍼티로써 validator 를 적용시켜야 한다.
          ex) <property name="validator" ref="reboardValidator"></property>
  (7) HandlerInterceptor
       컨트롤러에서 요청을 처리하기 전이나 후에 뭔가를 수행하고 싶을때 사용한다.
       1) 주요 메소드
          <1> boolean preHandle() : 컨트롤러에서 요청이 처리되기 전 실행
          <2> void postHandle() : 컨트롤러가 요청을 처리한 후에 실행
          <3> void afterCompletion() : 응답이 완전히 끝난 뒤 실행되는 메소드
       2) 사용방식
          HandlerInterceptor 를 상속받거나 원하는 메소드만 구현할 수 있는 
          HandlerInterceptorAdaptor 를 상속받은 클래스를 xml 에서 HandlerMapping 설정에 
          <property name="interceptors"> 로 등록할 수 있다.

5. transaction (트랜젝션)
  (1) ACID : 트랜젝션에서 추구했던 기본 4요소
       1) Atomicity : 원자성  모든 작업이 하나의 단위로 이루어져야 한다 (다 수행되던가 없던일 하던가)
       2) Consistency : 일관성  DB가 트랜젝션 작업중 일관된 데이터를 유지해야 한다
       3) Isolation : 독립성   다른 트랜젝션과 독립적으로 작업이 수행되어야 한다.
       4) Durability : 내구성  일단 커밋된 데이터는 계속해서 유지되어야 한다. 시스템 오류라 할지라도...
  (2) 프로그램적인 트랜젝션
       1) TransactionTemplate을 사용하거나 PlatformTransactionManager를 직접 상속받아서 쓰는 방법이 있다.
       2) RuntimeException 이 던져지면 rollback 이 된다. (그 외의 exception 은 기본적으로 무시)
  (3) 선언적인 트랜젝션
       1) Propagation (트랜젝션의 전파)
          <1> PROPAGATION_REQUIRED : 이미 있는 트랜젝션이 있다면 그걸 쓰고, 없다면 새로 만들어 낸다.
          <2> PROPAGATION_MANDATORY : 이미 있는 트랜젝션이 있다면 그걸 쓰고, 없다면 
                TransactionRequiredException 을 발생시킨다.
          <3> PROPAGATION_REQUIRES_NEW : 이미 있는 트랜젝션을 잠시 멈추고 
                새로운 트랜젝션을 만들어서 수행한다. 새로운 트랜젝션 종료후 기존 트랜젝션이 계속 실행된다.
          <4> PROPAGATION_NESTED : 트랜젝션은 하나만 쓰지만 중간에 savepoint 를 저장하는 방식을 말한다.
                (JDBC 매니져 방식에서만 적용 가능 Hibernate 나 JDO 같은 ORM 에서는 사용불가)
          <5> PROPAGATION_SUPPORTS : 트랜젝션이 없어도 되지만 트랜젝션이 실행되는 중에는 적용을 받는다
                ex) 일일 이체 한도액이 100만원이라고 한다면
                1. 50만원을 이체하는 트랜젝션이 시작
                2. 70만원을 이체하는 SUPPORTS 트랜젝션 시작
                3. 이체한도를 넘기는 결과가 되어 2번의 과정은 롤백이 된다.
                4. 50만원만 이체가 된다.
          <6> PROPAGATION_NOT_SUPPORTED : 트랜젝션이 필요없기 때문에 기존 트랜젝션이 있을 경우
                기존 트랜젝션을 멈추었다가 메소드 실행이 끝난 뒤 트랜젝션을 다시 시작한다.
          <7> PROPAGATION_NEVER : 이미 트랜젝션이 있다면 익셉션을 던져서 메소드 실행을 중지한다.
       2) Isolation (독립성) : 문서 참고
          독립성이 증가하면 동시성은 감소하고, 데이터의 일관성은 증가한다.
          <1> READ_UNCOMMITTED : 트랜젝션 중 다른 트랜젝션에 의한 커밋되지 않은 데이터도 읽어들일 수 있다.
          <2> READ_COMMITTED : 커밋된 데이터만 읽을 수 있다. 
                (다른 트랜젝션에 의한 커밋으로 일어난 변화는 읽어들인다)
          <3> REPEATABLE_READ : 트랜젝션 진행중에는 어떠한 변화점도 읽어들일 수 없다.
                (다른 트랜젝션에 의한 커밋도 상관없이 못 읽어들인다)
          <4> SERIALIZABLE : DB에 하나의 트랜젝션만 허용하는 것으로 하나의 트랜젝션이 실행중에
                 다른 트랜젝션이 접근한다면 잠시 중지했다가 기존 트랜젝션이 끝나고 나면 다시 시작한다.
           단, 오라클은 트랜젝션이 중지했다가 시작되는 것이 아니라 ORA-08177 오류를 발생시킨다.
          <5> DEFAULT : DB가 사용하는 isolation 정책 따름
   ※ 문제점 정리
       - Dirty read : 어떤 트랜잭션 T1이 다른 트랜잭션 T2가 아직 커밋하지 않은 데이타를 읽었는데 
                         T2가 롤백 되는 경우. T1이 읽은 데이타는 dirty.
       - Nonrepeatable read : 어떤 트랜잭션 T1이 계속 해서 같은 데이터를 읽어들이는데 그 사이에 
                         다른 트랜잭션 T2가 데이타를 수정하면 T1은 같은 데이터를 얻을 수 없게 된다.
       - Phantom read : 어떤 트랜잭션 T1이 계속 데이터를 읽어들이는데 그 사이 다른 트랜잭션 T2가 
                                새로운 데이타를 추가하면 T1은 전혀 새로운 데이터를 읽어들이게 된다. 마치 귀신처럼.
   

Posted by 미스터네오
,

<Struts>

Web/Struts 정리 2010. 2. 18. 14:23


1. struts 설정
   (1) lib(jar 파일들) : /WEB-INF/lib 폴더에 다운 받은 struts.jar 파일들을 넣는다.
   (2) web.xml : ActionServlet 에 대한 설정을 잡는다.
   (3) validation.xml : Validator Framework를 사용하기 위한 설정파일
   (4) struts-config.xml : struts 와 관련된 모든 설정이 있는 파일
   (5) MessageResources.properties
  다국어 지원 파일, 파일명 끝에 _[언어명](M~~_ko.properties)을 붙임으로써 struts가 자동으로 클라이언트의 언어를
  인식해서 그 언어에 맞는 메시지를 보여주기 위해서 사용한다. 단, 한글을 넣어줄때에는 아스키코드(유니코드)값으로
  변환해야 하는데 이때 native2ascii 프로그램을 이용한다.

2. 주요 클래스
   (1) ActionServlet (struts 에서 기본제공 servlet)
        : MVC에서 Controller 역할의 핵심.
   (2) Action (Business logic)
        : Controller 역할, 데이터를 가공하거나 처리하는 일
   (3) ActionForm (Beans)
        : Client 에서 들어오는 폼 데이터를 저장하는 클래스, reset 을 통해서 null 처리 및 초기화를 담당,
          사용자의 입력 값에 대한 데이터 유효성 체크도 담당(Validator Framework)
   (4) struts-config.xml
        : 실행되는 모든 요청에 대한 정보가 담겨져 있는 xml 파일, 어떤 기능이 수행되는지, 어떤 경로로 이동이
          되는지 설정.
          <form-bean>(ActionForm 지정), <action>(요청 주소와 응답경로) 가 주요 태그

3. Struts Framwork


4. Struts class diagram

'Web > Struts 정리' 카테고리의 다른 글

스트러츠 셋팅  (0) 2010.11.01
Posted by 미스터네오
,

<Servlet>

Web/Servlet 정리 2010. 2. 18. 14:21


<<<<<<<<<<<<<<<<<<<<< Servlet >>>>>>>>>>>>>>>>>>>>>>>>
웹서버의 컨테이너는 서블릿을 로딩한다. 그 뒤 사용자의 요청을 받아서 Request, Response 객체를 만들어낸다. service() 메소드를 호출해서 서비스를 제공하는 방식이 서블릿의 서비스 방식이다.

1. 서블릿의 라이프사이클 (life cycle)
   (1) init() : 첫번째 사용자 요청시 실행 but <load-on-startup> web.xml 에 설정하면 서버구동시에 실행된다.
   (2) service() : 클라이언트의 전송방식에 따라 doGet 혹은 doPost등을 실행하며 멀티쓰레드 환경으로 구축되어있다.
   (3) destroy() : 서버가 중지될때에 실행

2. 서블릿의 주요메소드
   (1) service() : 사용자의 요청에 실행되는 메소드, 구현하지 않는다.
   (2) doGet() : 전송방식이 GET방식일때 호출(요청주소에 파라미터값들이 붙어서 요청되는 방식)
   (3) doPost() : 전송방식이 POST 방식일때 호출(request의 body부분에 파라미터값들이 들어온다.)

3. 한글처리 : han.HanServlet 참고
   (1) request(요청) : 파라미터값을 ISO-8859-1 로 쪼개고(decoding) EUC-KR(encoding)로 변환한다.
                              (GET or POST) request.setCharacterEncoding("euc-kr") (POST)
   (2) response(응답) : response.setCharacterEncoding("euc-kr") 일반적으로 JSP에서 해결

4. 영역별 객체
   (1) ServletContext (창고, 파라미터 저장)
        : 웹 어플리케이션 전체에 있는 모든 Servlet에 영향을 끼칠 수 있는 객체이다.(only one 하나만 존재한다)
   (2) ServletConfig (파라미터 저장)
        : Servlet 마다 존재하는 객체이다.
   (3) HttpSession (창고)
        : 사용자가 웹브라우져로 접속해서 웹브라우져를 끌때까지 존재하는 객체이다.
   (4) HttpServletRequest (창고, client 에서 넘어오는 파라미터 저장)
        : 사용자의 요청이 들어오면 생성되고 응답이 끝나면 사라지는 객체이다.

5. 흐름의 이동
   (1) forward : 원래는 요청된 주소의 Servlet이 요청에 대해 응답을 해야하지만, forward 를 통해서
                      웹 어플리케이션내의 다른 자원(jsp or url)으로 이동시키는 방식을 말한다.
        - 주소는 요청한 그대로 유지된다.
        - 동일 웹 어플리케이션 내의 자원으로만 이동된다.
   (2) redirect : 원래 요청한 주소를 다른 주소로 redirect(재방향) 시켜주는 것으로 첫번째 받은 요청에 서버는
                      301상태정보와 새로운 URL 을 가지고 클라이언트에게 응답하고, 다시 클라이언트(웹브라우져)가
                      새로 받은 URL을 요청하고 거기에 따른 응답이 이뤄지는 방식을 말한다.
        - 주소는 완전히 다른 것으로 바뀐다.
        - 동일 웹 어플리케이션이 아니더라도 얼마든지 이동이 가능하다
        - 첫번째 요청된 request는 사라진다.(2번의 요청과 응답)

6. HTTP 상태(status) 코드 정리
   (1) 1XX : Informational
        리퀘스트 요청을 받아서 처리하는 중
   (2) 2XX : Success
        리퀘스트가 잘 받아졌다는 정보
   (3) 3XX : Redirection
        리퀘스트를 처리하는데 다른 과정이 한번 더 일어나야 한다는 정보
   (4) 4XX : User-Agent Error
        리퀘스트에 잘못된 문법, 잘못된 요청이 있다는 정보
   (5) 5XX : Server Error
        서버상에서 익셉션이 발생했다는 정보
   (6) 대표적 코드들
      <1> 200 : 모든 요청이 잘 받아졌고, 응답도 잘 됐다는 정보
      <2> 401 : 권한이 부족한 경우
      <3> 404 : 요청한 URI 정보가 없는 경우
      <4> 405 : 요청한 메소드 방식의 처리가 불가능한 경우
      <5> 500 : 서버에서 익셉션 발생

7. Servlet Filter
   (1) Servlet이 실행되기 전, 중간에 request, response를 가로채서 처리하는 방식
        : Servlet의 로직을 고치지 않아도 특정한 패턴(URL-Pattern)으로 들어오는 요청과 응답에 대해서 독립적으로
           처리할 수 있기 때문에 유지보수 측면에서 뛰어나다.
   (2) Filter 생명주기
        init() -> doFilter() -> destroy()
   (3) 설정방법
        <1> web.xml에 <filter> <filter-mapping> 추가
        <2> javax.servlet.Filter interface 를 상속받는 클래스 작성
        <3> doFilter() 메소드 작성 : chain.doFilter() 호출

8. JNDI 방식으로 DataSource 등록하기 (DBCP)
   Tech 문서 : http://kr.sun.com/developers/techtips/enter_12_24.html

   tomcat.apache.org 홈페이지 document 6.0 -> jdbc 설정
  (1) context.xml 변경
       <WatchedResource>WEB-INF/web.xml</WatchedResource> 밑에다가 제공되는 소스를 붙여넣는다.
       context.xml에 등록을 하면 서버에 속한 모든 프로젝트에서 접근이 가능하다.

 <Resource name="jdbc/myoracle" auth="Container" type="javax.sql.DataSource"  
                 driverClassName="oracle.jdbc.OracleDriver" url="jdbc:oracle:thin:@localhost:1521:JAVA"
                  username="scott" password="javac" maxActive="20" maxIdle="10" maxWait="-1"/>

       server.xml에서의 등록방법
  하단의 프로젝트 지정 부분 사이에 저 소스를 끼워넣어주어도 된다.
  (2) web.xml 변경
  (3) java source 변경
 http://tomcat.apache.org/tomcat-6.0-doc/jndi-datasource-examples-howto.html

'Web > Servlet 정리' 카테고리의 다른 글

servlet Post방식  (1) 2010.11.02
servlet Get방식 테스트  (0) 2010.11.02
Posted by 미스터네오
,

<Web 개요>

Web/Web 개요 2010. 2. 18. 14:11

1. History of Web
   CGI(Common Gateway Interface) -> Servlet(사용자들의 요청에 응답을 다양하게 할 수 있는 컨테이너)
   -> JSP -> ...
 
2. Web 처리방식
   클라이언트(웹브라우져) -요청(request)-> 서버(server)-응답(response)-> 클라이언트

3. 서비스를 제공하는 Web Application(A/S 센터) Deploy(배포) 구조
                                Root(최상위 폴터)
                                          |
    html img css js      WEB-INF(web.xml)
                                                          |    |          |
                                                  classes  lib(jar)  tld

4. DD(Deployment Descriptor) : web.xml
   -> 웹 어플리케이션을 서버에 deploy 할때 사용되는 배치 기술서

Posted by 미스터네오
,

<JSP 정리>

Web/JSP 정리 2010. 2. 18. 13:55

<<<<<<<<<<<<<<<<<<<<< JSP(Java Server Pages)>>>>>>>>>>>>>>>>>>>
1. 장점

   (1) 서블릿보다 만들기 쉽고, 빠르다
   (2) 디자인(HTML/JS/CSS)과 로직(JAVA)을 분리시킬 수 있다. 즉, 디자이너와 프로그래머의 일을 분업화할 수 있다.
   (3) 프로그래머가 직접 코딩한 Servlet 보다 최적화된 Servlet을 생성시켜 효율적인 코드를 생산한다.
   (4) Java Beans 사용이 쉽다.
   (5) 웹 어플리케이션상에서 변수의 유효범위(scope) 설정이 간편

2. JSP를 이루는 구성인자
   (1) 지시어 (directive)
       <1> 형태 : <%@ 지시어 %>
       <2> 종류 : page, include, taglib ...
              [1] page - contentType(내용물 형식 MIME Type 입력)
                   "text/html; charset=euc-kr"
                    - import(자바 import 동일) "java.sql.*, java.io.*"
                    - errorPage(익셉션 발생시 갈 페이지 지정)
                   "/error/error.jsp"
                    - isErrorPage (현재 jsp를 에러페이지 지정)
                       false(기본값)| true(exception 사용가능)
              [2] include (한 페이지에 다른 페이지를 포함)
              [3] taglib (커스텀 태그를 사용시)
   (2) 스크립팅 원소
       <1> 기능 : JSP 페이지에서 자바코드를 직접 사용할 수 있게 해주는 기능 제공
       <2> 종류 및 형태
              [1] 선언(declaration) <%! 자바코드 %> : 메소드,멤버변수 선언
              [2] 스크립트릿(scriptlet) <% 자바코드 %> : 자바코드 실행
              [3] 식(expression) <%= 자바코드 %> : 화면에 문자를 표시
   (3) JSP 액션 (JSP 태그)
       <1> 정의 : JSP에서 표준으로 정의된 태그
       <2> 형태 : <jsp:태그명>
       <3> 종류 : useBean, setProperty, getProperty, include, forward ...
              [1] useBean : Bean 객체를 생성해서 특정 영역에서 사용
                    - id : 변수명이자 scope(영역)에서 저장될때 이름
                    - class : 실제 만들어질 클래스의 명 ex) dept.DeptService
                    - scope : 객체가 영향을 끼치는 범위 page < request < session < application
                    참고) useBean 태그 바디부(<jsp:useBean>바디</jsp:useBean>에 있는 내용은 Bean 객체가
                            처음으로 만들어질때만 실행된다
              [2] setProperty : Bean 객체에 특정 프로퍼티에 값을 세팅
                   - name(*) : 변수명(useBean의 id)
                   - property(*) : Bean 객체 안의 프로퍼티명(멤버변수명)
                   - param : html의 input 태그 이름같은것들(파라미터명)
                   - value : 직접 값을 세팅
              [3] getProperty : Bean 객체에서 프로퍼티의 값을 가져온다.
                   - name(*)
                   - property(*)
                     c.f.) <%=bean.getProperty()%> 와 같다
              [4] forward : 특정 페이지로 요청을 전달(다른 페이지로 이동)
                   - page : 웹어플리케이션내의 특정 자원의 주소
              [5] include : 특정 페이지를 현재 페이지에 포함
                   (참고) 변수의 범위 설정 (scope 설정)
                   - page : 하나의 jsp 페이지내에서만 유효
                   - request : 하나의 요청에 대한 응답 jsp 페이지(들)에 유효
                   - session : 사용자에 대해 유효(웹브라우져 단위)
                   - application : 하나의 웹 어플리케이션 전체 유효

3. Java Beans
   (1) Beans 의 정의
        - 넓은 의미 : 자바 컴포넌트(기능덩어리)
        - 좁은 의미 : 자바 컴포넌트 중에서 Beans 규약에 맞는 컴포넌트
   (2) Beans 규약
       <1> 기본 생성자 (default constructor) 존재해야한다.
       <2> 속성(property)을 지정(private)
              - 속성이름은 html의 <input> 태그의 이름과 같아야 한다.
       <3> 속성을 세팅하거나 접근할 수 있는 get/set메소드(public)
              - 첫번째 문자는 대문자로 ex) getName, setName
   (3) 종류
       <1> 비주얼 컴포넌트 빈즈(JSP와 상관없음)              ex) TextField, Button
       <2> 데이터 빈즈 (Data Beans) : 데이터를 담아두는 객체를 만드는 컴포넌트
       <3> 서비스 빈즈 (연산이나 서비스 기능 Beans, Worker 빈즈)

4. JSP 디폴트 객체 (9개)
   (1) 정의 : 객체를 따로 생성하지 않고 스크립트릿(<%%>) 사이에서 사용 가능한 객체들을 의미
   (2) 종류
       <1> application -- ServletContext
              -> Web Application 전체의 정보를 가지는 객체
       <2> config    -- ServletConfig
              -> 서블릿/JSP의 구성정보를 가지는 객체
       <3> session   -- HttpSession
              -> 현재 사용자의 세션정보를 가지는 객체
       <4> request   -- HttpServletRequest
              -> 클라이언트의 요청정보를 가지는 객체
       <5> response  -- HttpServletResponse
              -> 클라이언트에게 줄 응답정보를 가지는 객체
       <6> page      -- Object(this)
              -> JSP 현재 페이지 자신을 의미하는 객체
       <7> pageContext -- PageContext(Custom Tag에서 봅니다)
              -> 다른 디폴트 객체들을 자바단에서 접근할 수 있는 방법을 가지는 객체
       <8> out        -- JspWriter
              -> 클라이언트의 브라우져에 연결된 출력 객체
       <9> exception  -- JspException
              -> 에러처리 관련 객체

5. JSP의 라이프 사이클
   jspInit() --> _jspService() --> jspDestroy()

6. EL (Expression Language)
   (1) 스크립팅을 전혀 쓰지 않을 수 있는 최신 기술
   (2) 내장객체 ${map.name}
       <1> pageScope
       <2> requestScope
       <3> sessionScope
       <4> applicationScope
       <5> param   HTTP의 파라미터들 Map
       <6> paramValues  하나의(name이 같은) 파라미터의 값들 Map
       <7> header   헤더정보들 Map 
       <8> headerValues 하나의 헤더의 정보들 Map
       <9> cookie   쿠키들 Map
       <10> initParam  컨텍스트의 초기화 파라미터들 Map
       <11> pageContext jsp 내장객체 (Map 아니다)
   (3) 도트(.) 연산자 사용의 특징
       <1> .의 왼쪽은 Map 이나 Beans 타입이어야 한다.
       <2> .의 오른쪽 항상 Map 의 키값이나 Beans 의 프로퍼티명이다.
   (4) [] 연산자 사용의 특징 (${list["value"]})
       <1> []의 왼쪽은 Map, Beans, 배열, List 타입이 올 수 있다.
       <2> []안의 값은 문자열일 경우 키값, 프로퍼티명, 인덱스가 온다.
       <3> []안의 값이 숫자인 경우는 그냥 인덱스로 인식되는데, 문자여도 숫자형식이면 괜찮다.
       <4> []안은 계속해서 중첩이 가능하다. ${list[list2[0]]}
  (5) EL은 연산자들을 사용할 수 있다.
       <1> 산술연산자 : + - * /(div) %(mod)
       <2> 논리연산자 : &&(and) ||(or) !(not)
       <3> 관계연산자 : ==(eq) !=(ne) <(lt) >(gt) <=(le) >=(ge)
  (6) 예약어들 : true, false, null, instanceof(향후 사용 예정), empty(null 혹은 "" 비었는지 체크)

7. JSTL (JSP Standard Tag Library)
  (1) 설치 : apache -> jakarta -> taglib 에서 다운로드 standard
      <1> jstl.jar, standard.jar 파일을 톰캣의 lib 폴더나 쓰고싶은 어플리케이션의 WEB-INF/lib 폴더에 넣어준다.
      <2> (1.0) *.tld 파일들을 WEB-INF/tld 폴더에 넣는다.
      <3> (1.0) web.xml에 설정을 잡는다.

 <jsp-config>
     <taglib>
        <taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>
        <taglib-location>/WEB-INF/tld/c.tld</taglib-location>
     </taglib>
     <taglib>
        <taglib-uri>http://java.sun.com/jsp/jstl/fmt</taglib-uri>
        <taglib-location>/WEB-INF/tld/fmt.tld</taglib-location>
     </taglib>
 </jsp-config>

  x, sql 도 있다. 
  (2) 코어 라이브러리
      <1> 수식 : catch, out, remove, set
      <2> 제어흐름 : choose, when, otherwise, forEach, forTokens, if
      <3> URL 관리 : import, param, redirect, url

8. 보안
  (1) 보안의 4요소
      <1> 인증(Authentication) : ID와 패스워드를 확인하여 인증된 사용자인지 검증하는 작업
      <2> 인가(Authorization) : 접근 가능한 자원인지를 판단하고 확인하는 작업
      <3> 비밀보장(Confidentiality) : 인증된 사용자만이 특정한 자원에 접근할 수 있다는 개념
      <4> 데이터무결성(Data Integrity) : 전송되는 데이터가 안전하다는 개념(암호화된 데이터 전송)
  (2) 실제 Tomcat 에서 적용방식 (web.xml, server.xml)
      <1> Authentication (인증 : 사용자 검증)
             a. BASIC : 기본적인 인증방식, 데이터를 BASE64 인코딩화
             b. DIGEST : 전송 데이터의 암호화
             c. FORM : jsp 의 form 을 통해서 인증하도록 설정

<form method="post" action="j_security_check">
     <input type="text" name="j_username" />
     <input type="password" name="j_password" />
</form>

             d. CLIENT-CERT : 클라이언트 컴퓨터의 인증서로 인증하는 방식   ex) web.xml

<login-config>
     <auth-method>BASIC</auth-method>
</login-config>

      <2> Authorization (인가 : 인증된 사용자만 자원에 접근 가능)
             <auth-constraint> 를 이용해서 role 정보를 추가해주면 해당 role의 유저만 resource 에 접근할 수 있게 된다.
             web.xml security-constraint 태그 참조
      <3> 데이터 무결성과 비밀보장

  <user-data-constraint>
   <transport-guarantee>CONFIDENTIAL</transport-guarantee>
  </user-data-constraint>

  web.xml 에 설정을 잡고, 서버별 SSL(Secure Socket Layer)
  관련 설정을 잡아줘야 하고, 인증키를 가지고 있어야 한다.
  인증키에는 JKS(Java KeyStore), PKCS11 or PKCS12(인터넷 표준 혹은 Microsoft key-manager) 가 쓰인다.

Posted by 미스터네오
,