'BOOK Study/J2EE'에 해당되는 글 43건

  1. 2010/05/22 Spring Conept
  2. 2010/01/25 1. 서문 & 언터프라이즈 환경의 서블릿
  3. 2010/01/25 세번째 자바 이야기 - Professional Java Sservlets 2.3
  4. 2010/01/17 06. Java EE 6 - EJB 3.1
  5. 2010/01/16 05. Java EE 6 - JPA 2.0
  6. 2010/01/14 04. Java EE 6: DI (JSR 330) and CDI (JSR 299)
  7. 2010/01/12 02. Servlet 3.0
  8. 2010/01/11 01. Java EE 6 Overrview & Getting Java EE 6 sample codes
  9. 2010/01/04 [java ee programming] Java EE 6 "1-day" Online Codecamp (on Jan. 12th, 2010)‏
  10. 2010/01/04 14. 패턴과 스트럿츠

Spring Conept

1.     베이직 컨셉

A.     자바-언어

                                 i.         Source à class(메모리에 아직 올라가지 않은 상태)->object(메모리에 올라간 상태)àcompileràDebuggerà IDE(Integrated Development Environment)àWAS(Web Application Server)

B.      JavaBeans

                                 i.         Java를 위한 software component Model

                                ii.         재사용 가능한 Component

                               iii.         User Interface Widget(Property)

C.      EJB(Enterprise Java Beans)

                                 i.         Java 컴포넌트의 사상을 서버로 확장

                                ii.         Transaction, 보안, 분산처리

                               iii.         복잡성 가증

D.     J2EE(Sevlet Container가 처리 해야될 것들)

                                 i.         Java EE WebServices Technologies

                                ii.         Java EE Web Application Technoogies

                               iii.         Java EE Enterprise Application Technologies

                               iv.         Java EE Management and Security Technologies

E.      Java EE Web Services à Container를 만드는 기술

F.      Java EE Web Application Technologes

                                 i.         Java Servlet 3.0

                                ii.         Java Server Faces 2.0

                               iii.         Java Server Pages 2.2

                               iv.         A Standard Tag Library for java server pages(JSTL)

                                v.         Debugging Support for Other Languages 1.0

G.     Java EE Enterprise Application Technologies

                                 i.         Contexts and Dependency Injection for java

                                ii.         Dependency Injection for java 1.0

                               iii.         Bean Valiadation

                               iv.         Enterprise JavaBeans….

H.     Java EE Management and Security Technologies

I.       Servlet Container – JSP만 쓸 수 있게 해놓은 것 : Object 를 관리 하기 위해서  

                                 i.         Java EE Web Service Technologies

                                ii.         Java EE web Application Technologies

                               iii.         Object 관리

                               iv.         Tomcat Regin, SunOne

J.       WAS

                                 i.         Java EE Web Service Technologies

                                ii.         Java EE web Application Technologies

                               iii.         Enterprise Application

                               iv.         Management and Security

                                v.         WebLoginc, JEUS, JBOSS

K.      Spring -> Tomcat + Java EE

2.     Introduction to Spring

A.     Basic Concept

                                 i.         Model1 Architecture – Web 1.0 – 간단 간결  : HTTP -> stateleess 방식-> 다운로드는 빠르지만 업로드는 느린 방식 : 초창기 시스템에 필요한 방식

1.      Browser sends a request to a JSP pages

2.      JSP page communication with a java beans

3.      Java Bean is connected to a database

4.      JSP page responses to the browser

                                ii.         Model2 Architecture – Web 2.0 – servlet->JSP

1.      Browser sends a request to a servlet

2.      Servlet instantiates a java beans the connect

3.      Servlet communicates with a JSP page

4.      JSP page communicates with that java beans

5.      JSP page respond to the browser

                               iii.         MVC design pattern

1.      Model : Maintain Data : Business logic plus one or mere data sources such as a relational database

2.      View display all or a portion of the data

3.      Controller handle events that affect the model or view

                               iv.         Model1 or Model2

                                v.         Model 1:  simple type of web application, quick prototyping Nature of developer task, View and controller being done by the same team who is doing the work

                               vi.         Model 2 : Complex type of web application, Creating an application to be Modified and maintained that Nature of developer task, view and controller being done by different teams who is doing the work

B.      What is Spring?

                                 i.         The most complete lightweight container : Application(able to execute Program), but Framework : library    à WAS에 비해서 가볍다(lightweight).

1.      Automated configuration

2.      Wiring of your application objects à Object를 Spring에서 관리 à 객체간의 이동이 가능하다. (IOC)

3.      Set loosely – coupled components(POJOs) : EJB에 비해서 객체간의 연결이 쉽다.

A.     Ex) WAS APP중 Log기능만 쓰고 싶지만 Run 시키면 10초 정도 걸림. à 이것만을 사용하고 싶지만 Application 을 다 올려야 사용 가능

B.      But Spring는 가능

4.      Deployment in any environment(J2SE or J2EE) – 두 군데 다 돌아감(JUES 뿐만 아니라 Tomcat에서도 사용이 가능하다)

5.      A Common abstraction layer for transaction management : 프로그램이 실행되는 작업 단위 à 트랜잭션의 별도의 특화된 추장적인 레이어가 있다.  *트랜잭션 처리가 중요!!!  Ibatis로 DB처리(Commit, Rollback 처리)

6.      Allowing for pluggable transaction managers

7.      Support is not tied to J2EE environments

A.     JTA(Java Transaction API)

B.      EJB CMT(Container Managed Transaction) : 단점 coupled 이 강하기 때문에  Container가 해준다. à 은행, 금융권에서 많이 사용

                                ii.         A JDBC abstraction layer à coupled 을 줄이기 위해서 사용

1.      Offers a meaningful exception hierarchy à 사용자에게 보여지는 exception 처리가 가능

2.      Simplifies error handling

3.      Greatly reduces the amount of code

                               iii.         Integration with Toplink, JDO, and Ibatis SQL Maps (ORM mapping tool)

1.      DAO implementation support

2.      Support ibatis

3.      Support Hibernate

                               iv.         AOP functionality : 보이는 것만 보는 관점

1.      Aspect oriented programming : 오브젝트 기반의 프로그래밍(tag관련 기법 중 하나)

2.      Fully integrated into Spring configuration management

3.      Adding aspects such as declarative transaction management

                                v.         A flexible MVC web application framework

1.      Built on core Spring functionality

2.      Accommodates multiple view technologies

A.     JSP, Velocity, Tiles, iText, POI

3.      Spring middle tire can easily be combined with a web tire based on any other web MVC framework

A.     Struts, WebWork, Tapestry

C.      Why Spring

                                 i.         EJB의 환상에서 벗어나자

1.      너무 복잡한 Spec

2.      Object들이 기술 종속적이다. (Container에 너무 종속적)

3.      Debugging 및 Test가 너무 힘들다.

                                ii.         Simplify many Java EE tasks

1.      분산 객체를 위한 Spec을 제외한 대부분의 기능이 구현됨

2.      WAS 없이도 구동가능

                               iii.         Avoid tight coupling among classes

1.     Use POJOs(Plain Old Java Objects)

2.      Spring 에 종속된 Object를 만들지 않음

D.     Spring Framework(=lightweight container)

                                 i.         J2SE à Spring Core(IoC==DAO) à Library가 존재

1.      MVC, DAO, ORM, Web Context AOP등 이 있다.

                                ii.         Spring Framework Runtime

1.      Core container (context, core, beans, Expression Language) + AOP + Instrumentation..

                               iii.         Spring을 이용한 Web Application

1.      Servlet Container (Tomcat) à Spring core è iBatisà JTM??!!

2.      생산성 높은 Framework 사용

3.      단점 : 그것만 사용

3.     Spring IoC(Basic Concept, Object Control(Container에서 관리하느냐, User가 관리하느냐의 차이로 EJB와 Spring가 나뉜다), Dependency Injection)

A.     Basic Concept

                                 i.         Application vs Web Application

1.      객체를 프로그래머가 제어할 수 있는가?

2.      Web Application : Container가 필요

3.      Application은 프로그램이 그냥 돌아간다.

                                ii.         Repository

1.      XML : tag를 이용한 방식

2.      Properties : ini 파일을 읽고 쓰는 방식

3.      Spring에서 bean을 관리하는 것(생성, 소멸 등의 관리)은 XML, Property를 통하여 관리한다.

                               iii.         Inversion of Control(IoC) : 메모리에 로드된 메소드를 바꿀 수 있다.?!

1.      제어의 역행?

2.      제어권을 가져온다.

3.      어디서? Container에서..

4.      무엇을 ? POJOs

                               iv.         Dependency Lookup(DL) : 동적으로 Lookup작업을 해준다. Repository를 만들고 à 리소스 등록

1.      의존성 찾기?

2.      Repository에 저장된 Bean을 lookup

3.      EJB에서 많이 사용하던 방식

4.      Container와 Coupling이 일어남

A.     A와 B의 프로그램을 실행시키는데 DB 1,,2를 연결해 놓지만. DB3을 연결시켜도 일반적으로는 A또는 B에서 DB3을 연결하지 못한다.

B.      하지만, Lookup을 통하여 동적으로 실행이 가능하다.

                                v.         Dependency Injection(DI)

1.      의존성 주입?

2.      외부의 존재가 생성시점을 제어한다.

3.      의존성이 객체로 주입

4.      객체 사이의 의존관계를 객체 자신이 아닌 외부의 조립기가 수행

5.      무엇을 ? POJO

A.     어떤 시점에 ADD, UPDATE, DELETE를 해라고 XML파일에 적어놓고 프로그램에 올리면 프로그램은 어떤 상황에서 사용을 하게 되면 동적으로 업데이트된 객체를 사용할 수 있다.

B.      왜? 이렇게 사용하느냐? 이렇게 하지 않으면 메모리에 component를 전체를 다 올려야 하기 때문에 프로그램이 무너진다.

C.      따라서 필요시점에 component를 메모리에 올리고 사용이 완료되면 메모리에서 내리는 방식을 사용함으로써 lightweight container라 한다. (IoC 기법)

6.      Setter Injection : public method(DLImpl dl) à Spring이 값을 넣어준다.

7.      Constructor Injection

8.      Method Injection

9.      IOC ->DL

10.       ->DI -> setter injection, Constructor Injection, Method Injection

4.     Spring AOP(Basic Concept, Aspect Separation, AOP)

A.     Programming Paradigm

                                 i.         Procedure programming

1.      C,Pascal, Cobol

                                ii.         Object Oriented Programming

1.      JAVA, C++, C#

                               iii.         Declarative Programming

1.      HTML, XML  à 프로그램을 할 수 있는 언어로 가능

                               iv.         Aspect Oriented Programming è 돋보기가 있는 부분만 자세하게 보이고 나머지는 안보임. // 관점, 시점, (내가 보고 싶은 곳만 보인다)

1.      JAVA, C#

2.      Aspect Separation

A.     Resource Layer

B.      Bossiness Layer

C.      Presentation Layer

3.      Vertical Separation

A.     Model A

B.      Model B

C.      Model C

B.      AOP

                                 i.         Aspect Oriented Programming

                                ii.         공통의 관심사항을 적용해서 발생하는 의존관계의 복잡성과 코드 중복을 해소해주는 프로그래밍 기법

                              iii.         공통사항과 핵심 로직을 분리

                               iv.         Logging, Exception, Transaction

                                v.         Advice

1.      공통사항이 언제 실행되는지 정의

                               vi.         Joinpoint

1.      Advice를 적용 가능한 시점

                              vii.         PointCut

1.      JoinPoint의 부분집합

2.      실제로 Advice가 적용되는 JoinPoint를 나타낸다.

                             viii.         Weaiving

1.      Advice를 핵심 로직에 적용하는 행위

                               ix.         Aspect

1.      Advice와 Pointcut을 합쳐서 하나의 Aspect라고 한다.

2.      여러객체에 공통으로 적용되는 공통 관심사항

*Aspect를 가지고 Weaiving를 한다

                                x.         Application 이 다양한 관점으로 분해

1.      핵심 관심사

A.     각모듈에서 수행하여야 하는 기본적이고 대표적인 업무

B.      실제 업무 로직

2.      횡단 관심사

3.      여러 개의 모듈에 걸치는 시스템의 부가적인 업무

4.      로깅 사용자인증, 성능관리 등의 기능

5.     AOP는 OOP를 대체하는 것이 아니라

                               xi.         업무 로직에서 직접 호출하는 것이 아니라 Aspect를 활용하여 컴파일 시나 런타임시에 Weaving과정을 거쳐 하나의 시스템으로 조립되는 것이 가능하게 해준다.

1.      클래스(핵심관심사), Aspect(횡단관심사) à AOP Weaver à 시스템

 

 

 

 

Transaction :  POJOà Objectàcomponentàjava beans

*JSP : object를 생성 할 수 없기 때문에 Container를 사용하여 Object를 관리 해야 한다.


저작자 표시

'BOOK Study > J2EE' 카테고리의 다른 글

Spring Conept  (0) 2010/05/22
1. 서문 & 언터프라이즈 환경의 서블릿  (0) 2010/01/25
세번째 자바 이야기 - Professional Java Sservlets 2.3  (0) 2010/01/25
06. Java EE 6 - EJB 3.1  (0) 2010/01/17
05. Java EE 6 - JPA 2.0  (0) 2010/01/16
04. Java EE 6: DI (JSR 330) and CDI (JSR 299)  (0) 2010/01/14
Trackback 0 Comment 0

1. 서문 & 언터프라이즈 환경의 서블릿

ㅇ 누구를 위한 책인가 ?
   - 이 책은 자바 언어와 자바 핵심 API에 익숙한 개발자들을 대상으로 한다.
ㅇ 이책에서 다루고 있는 내용
   - 엔터프라이즈 환경에서 서블릿을 사용하기 적합한 곳과 사용법에 대한 전반적인 개념 설명으로 시작한다. 
   - 2,3장에서는 서블릿 API를 다룬다. 
   - 4장에서는 웹 애플리케이션의 구조와 웹 서버에 배치하는 방법을 알아본다 .
   - 5-7장에서는 서블릿의 강력한 특징 중 일부분인 새션관리, 서블릿 영속성, 필터에 대해서 알아 볼것이다. 
   - 8장에서는 자바 서블릿을 보완하는 기술인 JSP에 대해서 알아 볼것이다. 
   - 9-11장에서는 실제 실행하는 환경에 웹 애플리케이션을 배치할 때 발생되는 문제들에 대해서 알아보게 된다. 디버깅 방법에 대해서 알아보고, 틀래스 로딩과 동기화를 고려하지 않았을때 발생될수 있는 문제점들을 알아볼것이다. 
   - 12,13장에서는 성능과 유지보수에 영향을 줄수 있는 효과적인 웹 애플리케이션 설계 방법에 대해서 알아본다. 좋은 애플리케이션을 만들기 위해 사용되는 여러가지 패턴들에 대해서 알아보고, 웹 애플리케이션의 성능과 확장성을 개선하기 위해 사용하는 테크닉과 도구들에 대해서 알아볼것이다. 
   - 마지막으로 14장에서는 웹서비스의 정보에 접근하는 에이전트로 서블릿을사용하는 방법에 대해서 알아볼것이다.

이책의 소스 코드를 다운로드 하는 방법
http://www.wrox.com/에 접속하여, 검색 기능을 이요하면 이책의 코드를 다운로드 할수 있다.

1, 엔터프라이즈 환경의 서블릿
자바는 분산 프렛폼에서 사용할수 있는 이미 검증된기술이다. 이책을 읽고 있는 독자들은 이미 J2SE에 익숙할거싱다. 이책에서 초점을 맞추어 진행 할 내용은 J2EE이다. 좀더 정확하게 말하자면, J2EE의 한 부분인 자바 서블릿 2.3API에 대해서 자세하게 다룰 것이다.
J2SE를 기반으로 한 J2EE는 엔터프라이즈 애플리케이션개발과 배치에 필요한 API와 서비스들을 제공한다. J2SE와 J2EE의 서비스와 라이브러리를 이용하면 플래폼 독립적인 웹 서기반 애플리케이션 개발을 쉽게 할수 있다. 그리고 J2EE 플렛폼에서는 J2EE애플리케이션이 설치되고 작동될 환경을 서버 벤더가 제공할수 있다.
 - 분산 애플리케이션으로 앤터프라이즈 아키텍처를 구성하는 방법과 웹 애플리케이션이 포함되는 계층에 대해서 알아본다.
 - J2EE아키텍처가 웹 컨테이너와 자바 서블릿을 이용하여 쉽게 웹 개발을 하는 방법과 서블릿 개발자들이 애플리케이션을 개발하면서 필요한 J2EE서비스와 라이브러리에 대해 알아본다.
 - 서블릿 2.4 스펙을 이용하여 자바 서블릿으로 웹 애플리케이션을 개발할때 얻을수 잇는 장점에 대해서 알아본다.
 - 컨테이너 제작 업체와 개발자가 서블릿 스펙을 구현할때 각자의 역할에 대해서 이야기 하며, 서블릿 스펙의 참조 구현 웹 컨테이너 / 서버인 톰캣을 소개한다.
 - 이장의 마무리는 앤터프라이즈 애플리케이션에서 서블릿의 역할, 중요성, 적절함 등에 대해서 알아본다.

ㅇ 네트워크와 프로토콜
모든 시스템은 유선등의 물리적인 네트워크로 서로 연결된다. 이러한 네트워크는 컴퓨터 시스템과 그안에서 작동되는 소프트웨어들 사이에 커뮤니케이션을 위한 연결을 제공한다. 기본적인 네트워크 토폴로지들은 아래 내용과 같다.
 - 스타 토폴로지 : 허브라고 불리는 중심점이 되는 컴퓨터에 연결시키는데 사용된다.
 - 링 토폴로지 : 각각의 컴퓨터들이 막힌 루프형태로 서로 연결되어 있다.
 - 공유된 하나의 통로를 이용하여 시스템 커뮤니케이션을 한다.
이 토폴로지들은 주로 LAN환경에서 사용된다. 이러한 토폴로지들은 가장 일반적인 구조이며, 서로 조합되거나 파생된 형태의 다른 토폴로지도 존재한다.

프로토콜이란 커뮤니케이션을 위한 규칙의 집합이다. 많은 프로토콜들이 공통 표준과 메시지 형식을 지정하여 개발되었기 때문에, 서로 다른 시스템간에 정보와 데이터를 교환할수 있다. 이러한 프로토콜은 특정 서비스를 제공하도록 설계되었으며, 실뢰성있는 네트워킹 서비스를 제공하기 위하여 계층으로 되어 있다.
물리적 단계에서는 하드웨어적인 물리적 연결이 통신하는 컴퓨터들 사이에 놓이게 된다. 그리고, 필수적으로 네트워크 카드와 유무선 연결이 포함된다. 이러한 연결은 컴퓨터간에 전달하는 메시지가 전달될 매체를 제공된다.

네트워크 레이어에서는 컴퓨터간의 커뮤니케이션을 수비게 해주는 이더넷과 같은 프로토콜을 구현하며, 데이터를 프레임이라는 단위로 나누어 네트워크로전송하는것을 다룬다. 또한 데이터 전송크기와 큰 메시지의 분할과 재조립 방법을 결정혐, 네트워크에 문제가 발생하였을때 처리할 방법도 결정하게 된다.
시스템에서 전송된 메시지들은 계층화된 프로토콜에 쌓여서 네트워크에 있는 다른 시스템으로 전송되며, 메시지를 받은 시스템에서는 반대로 메시지의 프로토콜을 제거한다. 논리적으로 각 레이어는 상대 컴퓨터의 동일한 레이어와 통신하게 된다.

TCP/IP
IP는 패킷의 크기를 결정하고 각 패킷이 목적지로 찾아가는 매커니즘을 정의하게 된다. 이 프로토콜은 연결된 컴퓨터의 IP주소를 이용하여 데이터가 네트워크를 통해 목적지로 찾아 갈수 있게 한다. 그리고 데이터의 유실이나 도착 순서가 바뀌는 등의 문제 ㅁ때문에 비교적 신뢰할수 없는 프로ㅗ콜이기도 하다. TCP는 연결성 통신으로 애플리케이션 레이어를 제공한다. 그리고 데이터의 모든 패킷을 받고 정확한 순서로 재조립하기 땜분에 IP와는 다르게 신뢰성이 있다.

HTTP
주로 애플리케이션 레이어의 통신방법으로 제공된다. 웹애플리케이션에서 가장 많이 사용되는 프로토콜은 HTTP이다. 웹 컨테이너와 J2EE 애플리케이션들은 사용자의 요청, 응답 프로토콜로 HTTP를 지원해야 한다. 웹의 가장 일반적인 최상위 프로토콜이기 때문에 HTTP를 사용하는 애플리케이션은 통신하려는 대부분의 서버들과 메시ㅣ지 교환이 가능하다.
HTTP는 송수신 요청을 정의된 형식으로 제공하며, 서로 다른 시스템과 언어로 개발된 애플리케이션들이 통신할수 있는 공통 언어의 역할을 하게 된다.
HTTP는 다른 프로토콜보다 많은 서버와 클라이언트가 사용하룻 이슨 웹의 표준언어이며, 대부분의 웹 서블릿 개발에 사용되는 궁극적인 프로토콜이다.

ㅇ계층화된 아키텍쳐
엔터프라이즈 애플리이케이션 개발 방식이 점점 3계층이상의 다계층 애플리케이션 모델로 많이 변화되고 있다. 애플리케이션을 논리적으로 서로 다른 여러 계층으로 분리 시키는것은 아래와 같은 장점이 있다.
 - 관련된 규칙과 각 계층에 적합한 기능을 모듈로 캡슐화 할수 있으며, 쉬운 유지보수와 개발이 가능하다.
 - 모듈화는 컴포넌트 기반 개발을 통하여 비즈니스, 프리젠테이션 등 로직의 유연성과 재사용성에 도움을 준다.
 - 다른 계층간의 관계와 제공해야 할 서비스들을 미리 정의한다면, 각 개발자들이 자신이 갖고 있는 기술들을 특정 계층에만 초점을 맞추어 개발 할수 있다.

클라이언트 계층 : 데이터와 정보를 사용자에게 설명하거나 보여주는 계층이다.
서버와 중간계층 : 클라이언트가 요청한 데이터나 액션을 처리하여 응답한다. 여기서는 일반적으로 핵심 애플리케이션 로직이 존재하게 된다. 그러나 중간계층은 다시 두개의 계층으로 구분되게 된다.

비즈니스 계층 : 비즈니스 로직을 책임지는 계층이다. 애플리케이션 신뢰도를 위해 비즈니스규칙을 구현하는 것이 중요하다. 

웹 계층(프리젠테이션 계층) : 비즈니스 데이터를 클라이언트에게 보여주기 위해서 재가공하는 계층이다. 클라리언트의 요청을 받아 해당되는 비즈니스 로직이 있는 비즈니스 계층으로 데이터를 포워드 한다.

ㅇ J2EE 플랫폼
자바는 스펙에 따라 표준화도니 많은 서비스와 API가 있기 때문에 개발자가 쉽게 이용할수 있다. 다시말해 표준에 맞는 서버에서 개발한다면, 다른 벤더의 서버에서도 별 다른 어려움 없이 개발된 애플리케이션을 배치 할수 있다는 의미이다.
J2EE 애플리케이션의 자바 기반 클라이언트는 씬 클라이언트의 구조를 이용한다. 씬 클라이언트란 서버와 통신하는 비교적 가벼운 클라이언트 애플리케이션을 의미한다.

ㅇ 웹 컨테이너
웹 애플리케이션을 위한 웹 컴포넌트인 서블릿과 JSP페이지의 실행을 관리하는 자바 실행환경이다. 그리고 웹 서바나 애플리케이션 서벙듸 일부분으로 요청과 응답을 만드는 네트워크 서비스를 제공한다. 웹 컨테이너는 반드시 HTTP를 지원해야 하며, 부가적으로 다른 종류의 프로토콜을 지원할수 있고, 웹 서버의 일부분으로 제작되거나 웹 서버의 플러그인 컴포넌트로 제작될수 도 있다. 웹 컨테이너는 서블릿과 JSP 인스턴스의 라이프 사이클과 실행을 관리한다.

ㅇ EJB 컨테이너
엔터프라이즈 자바빈즈는 비즈니스 규칙과 로직이 있는 비즈니스 컴포넌트이다. EJB에는 두가지 기본적인 종류가 있으며, 구중 하나는 데이터 자체와 강하게 결합되어 데이터 접근과 영속성 관리를 하는 엔티티빈이다. 다른 하나는 세션빈으로 로직을 표현하며, 클라이언트 요청을 처리하거나 데이터 처리 로직을 담당한다.
EJB 컴포넌트는 EJB컨테이너 안에서 실행된다. EJB컴포넌트는 재사용 가능하며 최적화를 위해 인스턴스가 풀링 되고 재활용되도록 설계하였다. EJB컨테이너는 애플리케이션을 위해서 EJB컴포넌트의 실행과 폴링을 관리할 책임이 있다.

ㅇ 자바 서블릿
서블릿은 동적으로 요청을 처리하고 응답을 생성하는 자바 클래스이다. 결국 요청에대해서 동적 HTML 페이지를 응답으로 생성한다는 뜻이다. 그러나, 애플릿이나 자바 애플리케이션에 직렬화된 자바 객체를 응답으로 생성한다는 뜻이다. 그러나, 애플릿이나 자바 애플리케이션에 직렬화된 자바 객체를 응답으로 보낼수 있으며, XML 같은 다른 형태로도 응답의 데이터를 보낼수 있다. 서블릿은 서블릿 컨테이너에서 동작하며 컨테이너가 제공하는 서비스에 접근할수 있다.

ㅇ서블릿 라이프 사이클
1. 컨테이너는 서블릿이 요청을 처리하기 전에 초기화 한다.
2. 서블릿 컴포넌트는 클라이언트 계층의 요청을 받는다. 컨테이너가 실제적으로 요청을 받아 적절한 컴포넌트의 인스턴스와 연결하고, 형식화된 요청과 응답 객체를 컴포넌트에 전달한다.
3. 서블릿은 비즈니스 계층의 로직의 도움을 받거나 직접 데이터베이스나 엔터프라이즈 인포메이션 계층에서 정보를 추출하여 요청을 처리한다.
4. 처리가 끝나면 클라이언트에게 응답을 리턴한다.
5. 최정적으로 컨테이너는 생성된 서블릿 인스턴스를 종료한다.

ㅇ 서블릿 통신
1. 요청/응답 사이클 중에 클라이언트와 하는 통신
2. 컨테이너 호나경에 관한 정보나 JNDI리소스에 접근하기 위해서 서블릿 테이너와 하는 통신
3. 다른 서블릿이나 EJB같은 서버의 다른 리소스와 하는 통신
4. 요청을 처리하기 위해서 데티어베이스나 레거시 시스템, EIS와 하는 통신

일반적으로는 서블릿의 역할은 클라이언트와의 통신이다. 컩테이너와의 통신은 클라이언트에게 리턴하기 위하여 데이터를 만드는 것과 달리 서비스를 제공하는 리소스에 접근한다. 실제로 유용하게 사용하기 위해서 스블릿은 다른 서버 컴포넌트나 데이터베이스 같은 외부 백엔드 리소스와도 통신한다.

ㅇ서블릿-클라이언트 통신
클라이언트와의 통신은 여러 형태로 할수 있짐나, 텍스트기반의 통신을 한다.
HTTP통신에서 일부 또는 모든 정보 파라미터는 요청의 일부분으로 전달된다. 서버의 응답으로 부터 클라이언트에 리턴할수 있는 데이터의 형식은 클라이언트에 따라서 다르다.

ㅇ서블릿의 이점
동적으로 생성되는 페이지가 필요하였고 CGI가 개발되어 이러한 역할을 수행하였다. CGI는 분리된 프로세스로 동작하는 CGI프로그램으로 요청을 넘겨 처리하게 되어 있다. 그러나, CGI 스크립트를 분리된 새로운 프로세스로 실행시키기 위해서는 처리시간이나 서버 리소스가 낭비되고 결국 확장성에 문제가 있게 되었다. 한번 실행된후에는 서버의 리소스나 정보에 접근할수 없다는 단점을 갖고 있다. 그리고 CGI 스크립트는 데이터베이스 커넥션 같은 리소스를 공유하거나 풀링 할수 없기 대문에 성능상의 문제가 있다.
이러한 CGI를 대체하기 위해여 서버 벤더들이 만든 기술이 있다.
CGI와 자바의 가장 분명한 차이는 프로세스 실행방식이다. CGI 스크립트는 개별적인 프로세스로 동작하는 데 비하여 자바 서블릿은 서버 프로세서ㅡ의 일부로 동작하기 때문에, 확실한 성능상의 이익이다. 그리고 서블릿 인스턴스는 각각의 호출 사이에 유지되기 때문에 매번 호출될 때마다 다시 생성할 필요가 없다. 또한 서블릿은 서블릿 컨테이너와 서블릿이 실행되는 실행 환경에 접근할수 잇다. 이것은 서블릿이 데이터베이스 같은 공유자원에 접근할수 있다는 뜻이다.

서블릿은 요청-응답 형식의 모든 CGI서비스를 제공하며, J2SE, API 서블릿 API 전체 J2EE API를 포함하여 여러가지 자바 라이브러리를 사용할수 있다. 그리고 외부 벤더가 제공하는 JDBC 드라이버나 XML 파서 같은 외부의 다른 API들도 사용할수 있으며, 이러한 라이브러리와 API는 플렛폼과 서버에 독립적으로 사용할수 있다.

ㅇ프로토콜의 유연성
 - javax.servlet
 - javax.servlet.http

ㅇJSP 컴포넌트
JSP 는 서블릿 기술을 웹 컨텐츠를 생성하는 일부분으로써 확장한 기술이다. JSP는 directive 태그, scriptlets로 불리는 일반 자바코드와 HTML을 포함할수 있으며 태그와 scrptlet은 동적 컨텐츠를 생성하는데 사용된다. JSP페이지는 최초로 호출할때 서블릿으로 컴파일되어 실행된다.

J2EE Connector아키텍처 있는 표준 아키텍처를 제공한다. 즉, 프로그래머에게 기본 정보 시스템에 접근할수 있는
Connector 아키텍처는 개발자들에게 J2EE와 다양한 EIS접근할수 API를 제공하는 것이다.
J2EE Connector 아키텍처는 엔터프라이즈 정보 시스템과 데이터를 주고 받게 된다. Connector API를 사용하여 엔터프라이즈 정보 시스템에 접근하기 위해서는 데이터베이스를 접근하기위한 JDBC와 유사하게 동작하는 resource adapter가 필요하다.

ㅇ자바 트랜잭션 서비스
JTS는 복잡한 분산 트랜잭션 처리를 위한 API를 제공하고commit과 rollback으로 고수준의 트랜잭션을 제어할수 있게한다. 이러한 트랜잭션 서비스는 여러 데이터베이스를 하나의 트랜잭션으로 관리할 수 있게 한다. 여러 트랜잭션 중에 하나라도 실패한다면 모든 트랜잭션이 rollback 되고 반대로 실패한 트랜잭션이 없으며 전체 트랜잭션이 commit 되게 한다.

ㅇ웹애플리케이션에서 서블릿의 역할
1. 적절한 요청 파라미터를 추출하여 데이터베이스 쿼리를 만든다.
2. 데이터베이스와 연결하고 데이터베이스로부터 결과를 받는다.
3. 마지막으로 클라이언트에 적하ㅏㅂ하게 결과를 보여준다.


저작자 표시

'BOOK Study > J2EE' 카테고리의 다른 글

Spring Conept  (0) 2010/05/22
1. 서문 & 언터프라이즈 환경의 서블릿  (0) 2010/01/25
세번째 자바 이야기 - Professional Java Sservlets 2.3  (0) 2010/01/25
06. Java EE 6 - EJB 3.1  (0) 2010/01/17
05. Java EE 6 - JPA 2.0  (0) 2010/01/16
04. Java EE 6: DI (JSR 330) and CDI (JSR 299)  (0) 2010/01/14
Trackback 0 Comment 0

세번째 자바 이야기 - Professional Java Sservlets 2.3

C언어를 다 보고 나서 이젠 다음 것을 공부하기 위해 미루고 미루던 Servlet에 대해서 공부하기로 했다.
그래서 책을 고르다 고르다 보니. 옛날책을 고르게 되었다.
우리나라는 Servlet만을 다룬 책이 별로 없어 외국의 번역본을 보기로 했다.
원서를 샀지만. 빠르게 보고 다른것을 봐야 하는 일정때문에 이책을 고르기로 했다. 1,2 장을 보았는데 이책은 정말 쉽게 되어 있었다. Servlet에 기본적으로 쓰이는 문법들을 왜 써야 하는지에 대한 정보가 정말 마음에 들었으며, 요즘 JSP만을 배우는 학생들에게 기본을 배울수 있는 좋은 책이라는것을 알게 해주는 책이다.





이 책이 다루는 내용
  • 서블릿 컨테이너와 서블릿 컨테이너가 제공하는 서비스
  • Tomcat에서 웹 애플리케이션 개발과 배치 방법
  • 서블릿 상태 저장
  • 보안과 컨테이너 인증
  • 서블릿 디버깅
  • 클래스로딩과 동기화가 웹 애플리케이션 동작에 주는 영향
  • 웹 애플리케이션 성능 최적화
  • 웹 서비스 에이전트로 서블릿을 사용하는 방법

     

     

    목 차


    서문

    누구를 위한 책인가?
    이 책에서 다루고 있는 내용
    이 책을 읽기 위해 필요한 것들
    표기 방법
    고객지원
    이 책의 소스 코드를 다운로드하는 방법
    오탈자
    P2P 온라인 포럼


    제 1 장 엔터프라이즈 환경의 서블릿

    엔터프라이즈 아키텍처
    네트워크와 프로토콜
    계층화된 아키텍처
    J2EE 컨테이너 아키텍처
    J2EE 컨테이너 종류
    J2EE 웹 컴포넌트
    자바 서블릿
    JSP 컴포넌트
    다른 J2EE API를 서블릿과 함께 사용하기
    서블릿으로 정보 소스에 접근하기
    J2EE의 메시징
    서블릿 보안과 JAAS
    JNDI
    JAXP
    웹 애플리케이션에서 서블릿의 역할
    전형적인 서블릿 기반 애플리케이션
    요약


    제 2 장 서블릿 2.3 API

    javax.servlet 패키지
    Servlet 인터페이스
    서블릿의 라이프 사이클
    서블릿의 정보 얻기
    GenericServlet 클래스
    라이프 사이클 메소드
    서블릿 환경 메소드
    유틸리티 메소드
    기본 서블릿 만들기
    Tomcat에서 서블릿 컴파일과 실행하기
    요청­응답 사이클
    요청­응답 인터페이스와 래퍼 클래스
    ServletRequest 인터페이스
    ServletResponse 인터페이스
    입출력 스트림
    서블릿­컨테이너 커뮤니케이션
    ServletConfig 인터페이스
    ServletContext 인터페이스
    ServletContext 라이프 사이클 클래스
    부가적인 인터페이스
    스레딩과 SingleThreadModel 인터페이스
    RequestDispatcher 인터페이스
    서블릿 익셉션 클래스
    ServletException 클래스
    UnavailableException 클래스
    Personal Portal 웹 애플리케이션
    Personal Portal 웹 애플리케이션 구현하기
    애플리케이션 실행하기
    요약


    제 3 장 HTTP 서블릿

    애플리케이션 레이어 프로토콜
    HTTP
    HTTP 메소드
    HTTP 헤더
    HTTP 상태 코드
    HTTP 인증
    HTTP와 서블릿
    HttpServlet 클래스
    HTTP 요청과 응답
    HTTP 서블릿 구현하기
    HttpRequestResponseServlet 구현하기
    QuizServlet 구현하기
    서블릿과 커스텀 클라이언트
    애플리케이션 설계하기
    클라이언트 구현하기
    Common 클래스 구현하기
    애플리케이션 구현하기
    요약


    제 4 장 웹 애플리케이션 배치하기

    웹 애플리케이션이란?
    웹 애플리케이션의 구조
    WAR
    ServletContext
    Tomcat에서 컨텍스트 정의하기
    웹 애플리케이션의 라이프 사이클
    디플로이먼트 디스크립터
    디플로이먼트 디스크립터 예제
    서블릿 정의와 매핑
    서블릿 매핑
    서블릿 컨텍스트 초기화 파라미터
    에러 페이지
    환영 페이지
    파일 기반 보안
    태그 순서
    디플로이먼트 디스크립터의 유효성 검사
    예제 웹 애플리케이션 배치하기
    상점 시나리오
    고급 배치 이슈
    JAR 종속성
    클래스 로딩
    요약


    제 5 장 세션 핸들링

    상태 유지 없는 HTTP의 특징
    클라이언트 구분과 상태 추적을 하는 이유
    세션 관리 방법
    URL 다시 쓰기를 이용한 세션 트래킹
    쿠키를 사용하는 세션 트래킹
    숨긴 폼 필드를 사용해서 세션 트래킹하기
    서블릿 API를 사용하여 세션 관리하기
    HttpSession 인터페이스
    세션 관리 구현하기
    세션 라이프 사이클 이벤트 감지하기
    고급 세션 핸들링
    요약


    제 6 장 서블릿 영속성과 리소스

    영속적인 리소스
    데이터베이스
    네이밍과 디렉토리 서비스
    XML
    서블릿 초기화와 환경설정
    초기화 파라미터
    서블릿 XML 환경설정
    JDNI로 리소스 바인딩하기
    JNDI 지원의 특징
    표준 리소스 바인딩
    데이터 소스 바인딩
    내장 데이터 소스 바인딩
    커스텀 데이터 소스 바인딩
    영속적인 리소스 접근하기
    DAO 패턴
    인증 애플리케이션 프레임워크
    JDBC를 사용해서 리소스 접근하기
    LDAP을 사용해서 리소스 접근하기
    서블릿 영속성
    서블릿 상태 저장하기
    세션 상태 저장하기
    요약


    제 7 장 필터

    필터란 무엇인가?
    새로운 기능 프로토타이핑하기
    새로운 기능 추가하기
    필터 이해하기
    필터의 논리적 관점
    필터의 물리적 관점
    필터 설정하기
    필터 정의하기
    필터 매핑하기
    필터 연결하기
    필터 사용하기
    필터 로그
    XSLT 전환 필터
    필터 연결하기
    필터 설계하기
    요약


    제 8 장 JSP

    JSP 기본
    JSP 스크립트 엘리먼트
    선언문
    스크립릿
    표현식
    JSP 내장 객체
    디렉티브
    page 디렉티브
    include 디렉티브
    JSP 액션
    jsp:include 액션
    jsp:forward 액션
    jsp:param 액션
    JSP 대출 계산기
    JSP 페이지에서 자바빈즈 사용하기
    서블릿과 JSP 함께 사용하기
    데이터베이스 생성하기
    시스템 아키텍처
    아이템 목록 만들기
    아이템 삭제하기
    아이템 편집하기
    아이템 수정하기
    새로운 아이템 추가하기
    애플리케이션 배치, 실행하기
    요약


    제 9 장 보안과 컨테이너 인증

    서버측 자바 2 보안 모델
    서버측 정책 파일
    서버측 정책 파일 사용하기
    SSL
    SSL 동작 모델
    Tomcat 4에서 SSL 사용하기
    서블릿 2.3 보안
    보안 접근과 J2EE 비즈니스 로직
    Tomcat 4의 보안
    컨테이너 관리 보안
    선언을 이용한 보안 사용하기
    MemoryRealm 사용하기
    다이제스트된 패스워드 사용하기
    FORM 기반 인증
    JDBCRealm 사용하기
    다중 인증 요청
    싱글 사인 온
    프로그래밍을 이용한 보안
    요약


    제 10 장 서블릿 디버깅 방법

    서블릿 디버깅 이슈
    디버깅 방법
    디버깅 툴
    이벤트 중심 디버깅
    필터로 디버깅하기
    디버깅 필터 구현하기
    디버깅 필터 사용하기
    이벤트 리스너로 디버깅하기
    디버깅 리스너 구현하기
    디버깅 리스너 사용하기
    JPDA로 디버깅하기
    JDPA 디버거 구현하기
    디버그 모드로 서버 실행하기
    JPDA 디버거 사용하기
    JPDA 디버거 출력
    디버깅 결과 시각화하기
    디버깅 결과 시각화 예제
    디버깅 방법 선택하기
    J2SE 1.4의 발전된 로그 기술
    실시간 UML 역공학
    요약


    제 11 장 클래스 로딩과 동기화

    클래스 로딩
    서블릿 컨테이너의 클래스 로딩
    배치 구조
    클래스와 다른 리소스의 위치
    Tomcat 4의 클래스 로딩 우선순위
    클래스 로딩이 애플리케이션에 주는 영향
    사용자 추적 애플리케이션
    서블릿 로딩과 리로딩
    스레드와 동기화
    뱅킹 애플리케이션
    단일 스레드 서블릿 사용하기
    서블릿 풀링
    다중 스레드 서블릿
    세션과 컨텍스트 변수를 사용하는 서블릿
    요약


    제 12 장 웹 애플리케이션 설계와 서블릿 패턴

    좋은 애플리케이션 설계의 중요성
    유지보수성
    재사용성
    확장성
    J2EE 웹 애플리케이션 설계
    모델 1 아키텍처 소개
    모델 2 아키텍처 소개
    디자인 원칙 문서화
    디자인 패턴 사용하기
    J2EE 패턴
    패턴을 사용하는 이유
    웹 기반 토론 포럼 만들기
    비즈니스 도메인 내의 엔티티
    토론 포럼의 클래스 모델
    모델 1 아키텍처를 사용하여 포럼 구축하기
    토론 주제 보기
    로그인 페이지
    로그인 처리
    응답 보기
    새로 응답 추가하기
    신규 응답 처리하기
    기존 응답 삭제하기
    애플리케이션의 페이지 흐름
    애플리케이션 리팩토링
    모델 2 아키텍처를 사용하여 포럼 구축하기
    Front Controller 패턴
    응답 보기
    로그인 처리
    새로 응답 추가하기
    신규 응답 처리하기
    기존 응답 삭제하기
    Intercepting Filter 패턴 사용하기
    View Helper 패턴
    Service to Worker 패턴 사용하기
    요약


    제 13 장 성능과 확장성

    좋은 코딩 방법
    아키텍처 고려사항
    비즈니스 로직 핸들링
    데이터 접근하기
    데이터 캐시하기
    세션 관리
    비동기 커뮤니케이션 사용하기
    로드 밸런싱과 클러스터링
    분석 툴
    스트레스 테스트 툴
    프로파일링 툴
    커스텀 성능 모니터링 툴
    모니터 프레임워크 클래스
    예제 사용하기
    요약


    제 14 장 웹 서비스와 서블릿 에이전트

    웹 서비스
    웹 서비스 동작 방식
    SOAP
    웹 서비스 사용하기
    SOAP 요청
    SOAP 응답
    에러 응답
    Apache SOAP
    웹 서비스 배치하기
    Apache Axis
    서블릿 에이전트
    정보 수집
    SOAP 서비스 사용하기
    정보 캐시하기
    집합과 복합
    집합 예제
    샘플링 애플리케이션
    디자인 고려사항
    현재와 미래의 도전자들
    WSDL
    UDDI
    웹 서비스 스택
    트랜잭션과 웹 서비스
    ACID
    XAML과 XLANG
    요약


    부록 A 톰캣 4.0 설치하기

    Tomcat 4.0 설치하기
    용어 정리
    기본 Tomcat 설치
    Tomcat 실행하기
    Tomcat 4.0 디렉토리 구조
    Tomcat 4.0 환경설정
    도움 얻기


    부록 B HTTP 레퍼런스

    HTTP 버전
    HTTP 트랜잭션
    HTTP 클라이언트 요청
    HTTP 서버 응답
    HTTP 헤더
    MIME 타입
    상태 코드
    추가 정보


    부록 C 서블릿 2.3 API 레퍼런스

    javax.servlet
    javax.servlet 인터페이스
    javax.servlet 클래스
    javax.servlet 익셉션
    javax.servlet.http
    javax.servlet.http 인터페이스
    javax.servlet.http 클래스


    찾아보기
    • 저작자 표시

    'BOOK Study > J2EE' 카테고리의 다른 글

    Spring Conept  (0) 2010/05/22
    1. 서문 & 언터프라이즈 환경의 서블릿  (0) 2010/01/25
    세번째 자바 이야기 - Professional Java Sservlets 2.3  (0) 2010/01/25
    06. Java EE 6 - EJB 3.1  (0) 2010/01/17
    05. Java EE 6 - JPA 2.0  (0) 2010/01/16
    04. Java EE 6: DI (JSR 330) and CDI (JSR 299)  (0) 2010/01/14
    Trackback 0 Comment 0

    06. Java EE 6 - EJB 3.1

    Lab Exercises

    For the sake of the simplicity of the lab, most exercises are provided in the form of "ready-to-open-and-run" NetBeans projects.  (Many of them are borrowed from "glassfish-samples" and "Java EE 6 tutorial".)  Please feel free to create them from scratch if you want to. 

    It is strongly encouraged, leveraging what is provided in this lab, you do your own experimentation meaning creating/adding your own code as much as you can. 

    If you have written some code that might help everyone else, please feel free to share them on this codecamp email alias or directly send them to the instructors.  Your name will be recognized in this lab if your sample code is chosen to be included.  For the tasks that need to be done, please see the "Things to be done" section above.)

  • Exercise 1: EJB in a war packaging (step by step) (20 minutes)
  • Exercise 2: Singleton (20 minutes)
  • Exercise 3: Timer (20 minutes)
  • Exercise 4: Asynchronous method invocation (30 minutes)
  • Exercise 5: EJB embedded (30 minutes)
  • Exercise 6: EJB with REST (30 minutes)
  • Homework Exercise
      Before you start this lab, you have to get sample applications from "glassfish-samples" and "Java EE tutorial" as described in LAB-4530: Java EE 6 - Examples.

    Exercise 1: EJB in a war packaging (step by step)

    더보기



    Exercise 2: Singleton

    더보기


    Exercise 3: Timer

    더보기

                                                                                                                          

    Exercise 4: Asynchronous method invocation using @Asynchronous

    더보기

     

    Exercise 5: EJB Embedded (Building Embeddable EJB app step by step)

    더보기





    Exercise 6: EJB and RESTful service

    더보기


    Homework Exercise


    1. The homework #1 is to modify EJB-in-a-war project you did in Exercise 1 above as following.   (You might want to create a new project by copying my_ejb3.1 project.  You can name the newly copied project in any way you want.  Here it is referred to as my_ejb3.1.)
    • Exercise point: EJB in a war packaging
      • Add another stateless bean called YourSessionBean with the following two methods.
        • add(int x, int y)
        • multiply(int x, int y)
      • From the HelloServlet, call these two methods using x value 10 and y value 6 and display the result
      • Exercise point: Singleton
        • Create a Singleton EJB which has the following two variables, which are used as a total values of the addition and multiplication
          • int total_addition
          • int total_multiplication
      • Exercise point: Timer
        • Use timer to display the value of total_addition and total_multiplication every hour of the day at the GlassFish v3 server log. (Basically use System.out.println(..) method.)
      2. The homework #2 is to create my_ejb3.1_embedded project as following.
      • Exercise point: EJB embedded
        • Create Java SE application in which the add(..) and multiply(..) methods are tested
      3. Send the following files to javaee6-homeworks@sun.com with Subject as homework_javaee6_ejb3.1.
      • Zip file of the the my_ejb3.1 and my_ejb3.1_embedded NetBeans projects.  (Someone else should be able to open and runthem as NetBeans projects.)  You can use your favorite zip utility or you can use "jar" utility that comes with JDK as following.
        • cd <parent directory that contains my_ejb3.1 directory> (assuming you named your project as my_ejb3.1)
        • jar cvf my_ejb3.1.zip my_ejb3.1 (my_ejb3.1 should contain nbproject directory)
      Please reduce the size of the zip file by right clicking the project and then selecting Clean before zipping the file.
      • Captured output screen  - name it as homework_javaee6_ejb3.1.gif or homework_javaee6_ejb3.1_embedded.jpg (or homework_javaee6_ejb3.1.<whatever graphics format>) and as homework_javaee6_ejb3.1_embedded.gif or homework_javaee6_ejb3.1_embedded.jpg (or homework_javaee6_ejb3.1_embedded.<whatever graphics format>)
        • Any screen capture that shows that your program is working is good enough. 



      4534_javaee6_ejb3.1.zip
      Session4EJB31.pdf
      my_ejb3.1.zip



      • 저작자 표시

      'BOOK Study > J2EE' 카테고리의 다른 글

      1. 서문 & 언터프라이즈 환경의 서블릿  (0) 2010/01/25
      세번째 자바 이야기 - Professional Java Sservlets 2.3  (0) 2010/01/25
      06. Java EE 6 - EJB 3.1  (0) 2010/01/17
      05. Java EE 6 - JPA 2.0  (0) 2010/01/16
      04. Java EE 6: DI (JSR 330) and CDI (JSR 299)  (0) 2010/01/14
      02. Servlet 3.0  (0) 2010/01/12
      Trackback 0 Comment 0

      05. Java EE 6 - JPA 2.0

      Lab Exercises


      For the sake of the simplicity of the lab, most exercises are provided in the form of "ready-to-open-and-run" NetBeans projects.  (Many of them are borrowed from "glassfish-samples" and "Java EE 6 tutorial".)  Please feel free to create them from scratch if you want to. 

      It is strongly encouraged, leveraging what is provided in this lab, you do your own experimentation meaning creating/adding your own code as much as you can. 

      If you have written some code that might help everyone else, please feel free to share them on this codecamp email alias or directly send them to the instructors.  Your name will be recognized in this lab if your sample code is chosen to be included.  For the tasks that need to be done, please see the "Things to be done" section above.)

      Before you start this lab, you have to get sample applications from "glassfish-samples" and "Java EE tutorial" as described in LAB-4530: Java EE 6 - Examples.

      Exercise 0: Build standalone JPA application step by step

      더보기

      Exercise 1: Mapping with @ElementCollection

      더보기


       

      (1.3) Collection of Embeddable

      더보기



       


      (1.5) Multi-level Embeddables

      더보기


       


      (1.7) Embeddable with its own relationship

      더보기


       


      Exercise 2: Mapping with @OrderColumn

      더보기



       

      (2.3) @OrderColumn with one-to-many Unidirectional relationship

      더보기



       


      (2.5) @OrderColumn with one-to-many Bidirectional relationship

      더보기


       


      Exercise 3: Map key

      더보기



       


      (3.3) @MapKeyClass

      더보기


       


      Exercise 4: JPQL Impovements

      더보기



       


      (4.3) CASE

      더보기


      Exercise 5: Criteria API (without using Metamodel)

      더보기


       

      (5.3) Criteria API with "orderBy" method

      더보기


       



      (5.5) Criteria API with relationship traversal

      더보기


       

      (5.7) Criteria API with inner join

      더보기

                                                                                                                             


      Exercise 6: Criteria API (using Metamodel)

      더보기

                                                                                                                       




      (6.3) Open, build, and run "jpa2.0_criteria_where_metamodel2_Root_getModel" sample application

      더보기

          Exercise 7: Locking

          더보기

                                                                                                                                 


          Exercise 8: Caching API

          더보기

          Exercise 9: Build and run "order" sample application (from "Java EE 6 tutorial")

          더보기


           

          Exercise 10: Build and run "roster" sample application (from "Java EE 6 tutorial")

          더보기


          Homework Exercise


          The homework is revised since the original homework indeed has a flaw.  The code snippets are shown as hints.  The structure of the homework project is quite similar to the jpa2.0_mapping_collection_embeddables_relation project.

          1. The homework is to build a standalone JPA application called my_jpa2.0 project as following. 
          • Exercise point: Mapping with @ElementCollection
            • School entity class have schoolname field, which is String type, and district field, which is District class.  See a snippet of the School class below.
          ...
          @Entity
          public class School implements Serializable {

              @Id
              @GeneratedValue
              @Column(name = "SCHOOL_ID")
              private int id;
              private String schoolname;

              private District district;

            • The District class is Embeddable type and has a set of Student's.  It also has districtname field, which is String type. See a snippet of District class below.
          ...
          @Embeddable
          public class District implements Serializable{

              private String districtname;
           
              @OneToMany(cascade=CascadeType.ALL, mappedBy="school")
              private Set<Student> students;
          ...

            • The Student class is an entity class and  has studentname field, which is String type, and grade field, which is double type.  See a snippet of Student class below.
          ...
          @Entity
          @Table(name = "STUDENT_TABLE")
          public class Student implements Serializable {

              @Id
              @Column(name = "STUDENT_ID")
              @GeneratedValue
              private int id;
              private String studentname;
              private double grade;

              // Bi-directional one-to-many relationship
              @ManyToOne(optional = true)
              private School school;
          ...
            • In the Main.java, as samples, add at least 3 schools.  Each district of corresponding school has at least 2 students.
            • Exercise point: Criteria  API
              • In the Main.java, perform both JPQL and Criteria API as following.  Metamodel class does not have to be used.
                • Get all schools who have students whose grade is 3.0 or above
            2. Send the following files to javaee6-homeworks@sun.com with Subject as homework_javaee6_jpa2.0.
            • Zip file of the the my_jpa2.0 NetBeans project.  (Someone else should be able to open and run it as a NetBeans project.)  You can use your favorite zip utility or you can use "jar" utility that comes with JDK as following.
              • cd <parent directory that contains my_jpa2.0 directory> (assuming you named your project as my_jpa2.0)
              • jar cvf my_jpa2.0.zip my_jpa2.0 (my_jpa2.0 should contain nbproject directory)
            Please reduce the size of the zip file by right clicking the project and then selecting Clean before zipping the file.
            • Captured output screen  - name it as homework_javaee6_jpa2.0.gif or homework_javaee6_jpa2.0.jpg (or homework_javaee6_jpa2.0.<whatever graphics format>)
              • Any screen capture that shows that your program is working is good enough. 


            my_jpa2.0.zip
            Session7Java_Persistence_2_0.pdf
            derbyclient.jar
            4537_javaee6_jpa2.0.zip


            저작자 표시

            'BOOK Study > J2EE' 카테고리의 다른 글

            세번째 자바 이야기 - Professional Java Sservlets 2.3  (0) 2010/01/25
            06. Java EE 6 - EJB 3.1  (0) 2010/01/17
            05. Java EE 6 - JPA 2.0  (0) 2010/01/16
            04. Java EE 6: DI (JSR 330) and CDI (JSR 299)  (0) 2010/01/14
            02. Servlet 3.0  (0) 2010/01/12
            01. Java EE 6 Overrview & Getting Java EE 6 sample codes  (0) 2010/01/11
            Trackback 0 Comment 0

            04. Java EE 6: DI (JSR 330) and CDI (JSR 299)


            Lab Exercises


            For the sake of the simplicity of the lab, most exercises are provided in the form of "ready-to-open-and-run" NetBeans projects.  (Many of them are borrowed from "glassfish-samples" and "Java EE 6 tutorial".)  Please feel free to create them from scratch if you want to. 

            It is strongly encouraged, leveraging what is provided in this lab, you do your own experimentation meaning creating/adding your own code as much as you can. 

            If you have written some code that might help everyone else, please feel free to share them on this codecamp email alias or directly send them to the instructors.  Your name will be recognized in this lab if your sample code is chosen to be included.  For the tasks that need to be done, please see the "Things to be done" section above.)
              Before you start this lab, you have to get sample applications from "glassfish-samples" and "Java EE tutorial" as described in LAB-4530: Java EE 6 - Examples.

            Exercise 1: @Inject simple usages

            더보기


            Exercise 2: @Inject usage with @Qualifier

            더보기


            Exercise 3: Scope


            더보기


            Exercise 4: Producer Methods

            더보기

            Exercise 5: Managed Bean with Lifecycle methods

            더보기

            Exercise 6: Build and run "weld-servlet" sample application

            더보기


            Exercise 7: Build and run "weld-guess" sample application

            더보기

            Exercise 8: Event

            더보기


             

            Homework Exercise


            1. The first part of homework is to modify inject_qualifier project you worked on in Exercise 2 above as following.  (You might want to create a new project by copying inject_qualifier project.  You can name the newly copied project in any way you want.  Here it is referred to as my_inject_qualifier.)
            • Goal: Exercising qualifier
              • Define another qualifier called @SemiFormal.
              • Define SemiFormalGreeting class with @SemiFormal annotation
              • Modify HelloServlet class to inject @SemiFormal greeting object.
            2. The second part of homework is to modify inject_scope_conversation project you worked on in Exercise 3 above as following.  (You might want to create a new project by copying inject_scope_conversation project.  You can name the newly copied project in any way you want.  Here it is referred to as my_inject_scope_conversation.)  - If you already submitted homework or would use to use a single project as a base as in the original homework, that is perfectly fine as well.
            • Goal: Exercising scope
              • Create a bean called my_application_scope_bean with application scope, which has a field called my_application_scope_counter.  Use the my_application_scope_counter to keep track of how many times the Say Hello button was clicked.
              • Display the value of my_application_scope_counter.
              • Create another bean called my_conversation_scope_bean with conversation scope, which has a field called my_conversation_scope_counter.  Now every time my_application_scope_counter hits multiple of 5, for example, 5, 10, 15, ..., start a conversation.  Every time my_application_scope_counter hits multiple of 5 plus 4, for example, 9, 14, 19, ..., stop the conversation.
              • The my_conversation_scope_counter gets incremented each time the Say Hello button is clicked but starting from a new random number whenever a new coversation scope gets started.
              • Display the value of my_conversation_scope_counter.
            • Goal: Exercising event handling
              • Every time my_application_scope_bean hits the prime numbers up to 20, fire a event.  The event handler should display a message "Prime number x is hit!". This message can be displayed either HTML response message or system log.
            Hint: Given that we have not covered how to use JSF/Facelets yet, the following hint shows how to display things in the index.xhtml file - make sure you copy resources directory and template.xhtml as well as seen in inject_scope_conversation project.  The "Prime number x is hit!" can be printed out on system log through sysem.out.println(...);

            <?xml version='1.0' encoding='UTF-8' ?>
            <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
                "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
            <html xmlns="http://www.w3.org/1999/xhtml"
                  xmlns:ui="http://java.sun.com/jsf/facelets"
                  xmlns:h="http://java.sun.com/jsf/html">
                <ui:composition template="/template.xhtml">

                    <ui:define name="title">Simple Greeting</ui:define>
                    <ui:define name="head">Simple Greeting</ui:define>
                    <ui:define name="content">
                        <h:form id="greetme">
                            <p><h:outputLabel value="Enter your name: " for="name"/>
                                <h:inputText id="name" value="#{printer.name}"/></p>
                            <p><h:commandButton value="Say Hello" action="#{printer.createSalutation}"/></p>
                            <p><h:commandButton value="Start conversation" action="#{printer.startConversation}"/></p>
                            <p><h:commandButton value="End conversation" action="#{printer.endConversation}"/></p>
                            <p><h:outputText value="printer.salutation = #{printer.salutation}"/> </p>
                            <p><h:outputText value="printer.old_salutation = #{printer.old_salutation}"/> </p>
                            <p><h:outputText value="myConversationStatus.conversationSattus = #{myConversationStatus.conversationSattus}"/> </p>
                            <p><h:outputText value="my_application_scope_bean.my_application_scope_counter = #{my_application_scope_bean.my_application_scope_counter}"/> </p>
                            <p><h:outputText value="my_conversation_scope_bean.my_conversation_scope_counter = #{my_conversation_scope_bean.my_conversation_scope_counter}"/> </p>
                        </h:form>
                    </ui:define>

                </ui:composition>
            </html>


            2. Send the following files to javaee6-homeworks@sun.com with Subject as homework_javaee6_injection.
            • Zip files of the the my_inject_qualifier and my_inject_scope_conversation NetBeans projects.  (Someone else should be able to open and run them as NetBeans projects.)  You can use your favorite zip utility or you can use "jar" utility that comes with JDK as following.
              • cd <parent directory that contains my_inject_qualifier directory> (assuming you named your project as my_inject_qualifier)
              • jar cvf my_inject_qualifier.zip my_inject_qualifier (my_inject_qualifier should contain nbproject directory)
            • Captured output screens  - name it as homework_javaee6_injection1.gif orhomework_javaee6_injection1.jpg (or homework_javaee6_injection1.<whatver graphics format>) for the first part and homework_javaee6_injection2.gif orhomework_javaee6_injection2.jpg (or homework_javaee6_injection2.<whatver graphics format>)
              • Any screen capture that shows that your program is working is good enough.

            homework_javaee6_injection1.zip
            homework_javaee6_injection2.zip
            4531_javaee6_injection.zip
            Session10-ContextDependencyAndInjection.pdf
             



             

            저작자 표시

            'BOOK Study > J2EE' 카테고리의 다른 글

            06. Java EE 6 - EJB 3.1  (0) 2010/01/17
            05. Java EE 6 - JPA 2.0  (0) 2010/01/16
            04. Java EE 6: DI (JSR 330) and CDI (JSR 299)  (0) 2010/01/14
            02. Servlet 3.0  (0) 2010/01/12
            01. Java EE 6 Overrview & Getting Java EE 6 sample codes  (0) 2010/01/11
            [java ee programming] Java EE 6 "1-day" Online Codecamp (on Jan. 12th, 2010)‏  (0) 2010/01/04
            Trackback 0 Comment 0

            02. Servlet 3.0

            Java Servlet 3.0 (JSR 315), which is part of Java EE 6, is a major revision of the Java Servlet technology, a widely accepted technology for building dynamic content for web-based applications, and includes changes to enable easy pluggability of popular open-source frameworks or libraries, ease of development leveraging annotation and making web.xml optional, support for async processing, which enables writing Comet applications in portable fashion, security enhancements, and other minor updates to the existing APIs.

            In this lab, you are going exercise all the newly introduced features of Servlet 3.0.
            Expected duration: 210 minutes (excluding homework)




            Software Needed


            Before you begin, you need to install JDK 6 and NetBeans IDE 6.8.  You also need to download and unzip the hands-on lab zip file below.
            • 4532_javaee6_servlet3.0.zip (download)
              • It contains this document and the lab contents
              • Download it and unzip in a directory of your choice

            OS platforms you can use

            • Windows
            • Solaris x86, Solaris Sparc
            • Linux
            • Mac OS X

            Lab Exercises


            For the sake of the simplicity of the lab, most exercises are provided in the form of "ready-to-open-and-run" NetBeans projects.  (Many of them are borrowed from "glassfish-samples" and "Java EE 6 tutorial".)  Please feel free to create them from scratch if you want to. 

            It is strongly encouraged, leveraging what is provided in this lab, you do your own experimentation meaning creating/adding your own code as much as you can. 

            If you have written some code that might help everyone else, please feel free to share them on this codecamp email alias or directly send them to the instructors.  Your name will be recognized in this lab if your sample code is chosen to be included.  For the tasks that need to be done, please see the "Things to be done" section above.)


            Exercise 1: Annotation

            더보기



            Exercise 2: Dynamic registration

            더보기


             

            Exercise 3: Pluggability of 3rd-party frameworks/libraries

            더보기



             

            Exercise 4: Resources in bundled jar

            더보기


             

             

            Exercise 5: Asynch. Servlet

            더보기


             

             

            Exercise 6: File upload support

            더보기


             




            Exercise 7: Build and run "sessioncookieconfig-war" sample application

            더보기





            Exercise 8: Security

            더보기


            Mandatory Homework Exercise (for people who are taking "Java EE 6 Codecamp")


            1. The homework is to modify helloservlet project as following.  The helloservlet project is provided under <LAB_UNZIPPED_DIRECTORY>/javaee6_servlet3.0/samples directory. (You might want to create a new project by copying helloservlet project.  You can name the newly copied project in any way you want.  Here it is referred to as myhelloservlet.)
            • Goal: exercising annotations
              • Remove web.xml.
              • Use @WebServlet annotation for the GreetingServlet.
              • Use dynamic registration for the ResponseServlet.
            • Goal: exercising 3rd party library/framework pluggability
              • Create a library called mywebfragment1 with its own web-fragment.xml.
              • Define a filter in which "myfiltermessage" attribute in the request scope is appended with a value "mymessage1".  The filter configuration should be specified in the web-fragment.xml.
              • Create another library called mywebfragment2 without web-fragment.xml.  The filter configuration should be configured with @WebFilter annotation.
            2. Send the following files to javaee6-homeworks@sun.com with Subject as homework_javaee6_servlet3.0.
            • Zip file of the the myhelloservlet NetBeans project.  (Someone else should be able to open and run it as a NetBeans project.)  You can use your favorite zip utility or you can use "jar" utility that comes with JDK as following.
              • cd <parent directory that contains myhelloservlet directory> (assuming you named your project as myhelloservlet)
              • jar cvf myhelloservlet.zip myhelloservlet (myhelloservlet should contain nbproject directory)
            Or you can install Project Packager NetBeans plug-in (from http://plugins.netbeans.org/PluginPortal/faces/PluginDetailPage.jsp?pluginid=3742).  You can then export your project as a zip file - the build and dist directories are removed automatically to make the smaller zip file. If you set up SMTP, you can even e-mail your zipped project to someone.
            • Captured output screen  - name it as homework_javaee6_servlet3.0.gif or homework_javaee6_servlet3.0.jpg (or homework_javaee6_servlet3.0.<whatever graphics format>)
              • Any screen capture that shows that your program is working is good enough. 

                                                                                                                                return to the top

            Optional Homework Exercise (for people who are taking "Java EE 6 Codecamp")


            You don't need to submit optional homework exercise unless you want to.

            1. The homework is to modify async-request-war project as following.   (You might want to create a new project by copying async-request-war project.  You can name the newly copied project in any way you want.  Here it is referred to as my-async-request-war.)
            • Add a "Quit chatting" button, when pressed, to close a chatting session.
            • Add a "Restart chatting" button, when pressed, to restart a chatting session

            2. Send the following files to javaee6-homeworks@sun.com with Subject as homework_javaee6_servlet3.0-optional.
            • Zip file of the the my-async-request-war NetBeans project.  (Someone else should be able to open and run it as a NetBeans project.)  You can use your favorite zip utility or you can use "jar" utility that comes with JDK as following.
              • cd <parent directory that contains my-async-request-war directory> (assuming you named your project as my-async-request-war)
              • jar cvf my-async-request-war.zip my-async-request-war (my-async-request-war should contain nbproject directory)
            저작자 표시

            'BOOK Study > J2EE' 카테고리의 다른 글

            05. Java EE 6 - JPA 2.0  (0) 2010/01/16
            04. Java EE 6: DI (JSR 330) and CDI (JSR 299)  (0) 2010/01/14
            02. Servlet 3.0  (0) 2010/01/12
            01. Java EE 6 Overrview & Getting Java EE 6 sample codes  (0) 2010/01/11
            [java ee programming] Java EE 6 "1-day" Online Codecamp (on Jan. 12th, 2010)‏  (0) 2010/01/04
            14. 패턴과 스트럿츠  (0) 2010/01/04
            Trackback 0 Comment 0

            01. Java EE 6 Overrview & Getting Java EE 6 sample codes

             

             

            Lab Exercises



            Exercise 1: Get "glassfish-samples" examples from GlassFish v3 Update center

            더보기


             

            Exercise 2: Check out "Java EE 6 Tutorial" examples from GlassFish v3 update center

            더보기

             

            Exercise 3: Check out "glassfish-samples" examples

            더보기






             

            Homework Exercise (for people who are taking Sang Shin's "Java EE Programming online course")


            저작자 표시

            'BOOK Study > J2EE' 카테고리의 다른 글

            04. Java EE 6: DI (JSR 330) and CDI (JSR 299)  (0) 2010/01/14
            02. Servlet 3.0  (0) 2010/01/12
            01. Java EE 6 Overrview & Getting Java EE 6 sample codes  (0) 2010/01/11
            [java ee programming] Java EE 6 "1-day" Online Codecamp (on Jan. 12th, 2010)‏  (0) 2010/01/04
            14. 패턴과 스트럿츠  (0) 2010/01/04
            13. 필터와 랩퍼  (0) 2010/01/03
            Trackback 0 Comment 0

            [java ee programming] Java EE 6 "1-day" Online Codecamp (on Jan. 12th, 2010)‏

            (My apology if you receive this multiple times.)

            Java EE 6 "1-day" Online Codecamp (on Jan. 12th, 2010)
            ======================================================

            Alexis, Antonio, and myself (Sang Shin) would like invite
            each one of you to the free Java EE 6 "1-day" (24 hour
            duration) online codecamp, which is scheduled to occur
            on Jan. 12th (Tuesday) 2010.

            What is online codecamp? Well, you write lots of code
            in this 24-hour period. For more detailed information
            on "What is it like to attend the online codecamp?",
            please see the codecamp website below.

            http://www.javapassion.com/courses/javaee6codecamp.html

            For registration, all you have to do is to send a blank
            email to "subscription" email address below. (You might have to
            have a Google account before registration.)

            javaee6-codecamp+subscribe@googlegroups.com

            All future announcements on this codecamp will be made through
            the codecamp website and the codecamp email alias.

            Please feel free to forward this email to anyone who might
            be interested. Thank you very much. We are looking forward
            to seeing you (virtually) all.

            -Alexis Moussine-Pouchkine, Antonio Goncalves, Sang Shin

            --
            ---------------------------------------------------------------
            Sang Shin, sangshinpassion@gmail.com, sang.shin@sun.com
            http://www.javapassion.com/SangShinSchedule.html
            (Life is worth living... with Passion!)
            ---------------------------------------------------------------
            "Groovy/Grails Programming" course starts from Jan. 30th, 2010
            http://www.javapassion.com/groovyandgrails/
            "Ajax and Web 2.0 Programming" course started from Sep. 7th, 2009
            http://www.javapassion.com/ajaxcodecamp/
            "Advanced Java EE Programming" course started from Oct. 1st, 2009
            http://www.javapassion.com/javaee_advanced/
            저작자 표시

            'BOOK Study > J2EE' 카테고리의 다른 글

            02. Servlet 3.0  (0) 2010/01/12
            01. Java EE 6 Overrview & Getting Java EE 6 sample codes  (0) 2010/01/11
            [java ee programming] Java EE 6 "1-day" Online Codecamp (on Jan. 12th, 2010)‏  (0) 2010/01/04
            14. 패턴과 스트럿츠  (0) 2010/01/04
            13. 필터와 랩퍼  (0) 2010/01/03
            12. 웹 애플리케이션 보안  (0) 2010/01/03
            Trackback 0 Comment 0

            14. 패턴과 스트럿츠

            엔트프아이즈 디자인 패턴

            성능과 다수의 "~성"
            가장 중요한 3가지 비기능적인 요구사항 입니다.
            1. 성능
            2. 모듈화
            3. 유연성, 유지보수성, 확장성

            우선 용어부터 정의하죠
            ㅇ 인터페이스를 사용하라
            인터페이스란 두 객체간의 일종의 계약이라고 말할수 있습니다. 하나의 ㅋ르래스가 어떤 인터페이스를 구현했다면 다음과 같은 의미가 있죠 내가 만든 객체는 당신이 하는 얘기를 이해할수 있어요. 인터페이스가 가지는 또 하나 장점으로 다형성을 들수 있습니다. 다수의 클래스가 한개의 인터페이스를 동시에 구현한 경우 동일 인터페이스라면 어떤 클래스도 호출할수 있지요 예를들어 웹 컨테이너는 Servlet 인터페이스를 구현한 어떤 컴포넌트도 사용할수 있는 것처럼요

            ㅇ관심영역의 분리 및 응집성
            소프트웨어의 특정 기능만 특화시켜 컴포넌트화 하면 개발하기도 쉽고 유지보수 하기 편하며, 재사용성도 높일수 있지요 고나심 영역을 분리하게 되면 자연스럽게 응집도는 높아지기 마련이죠 응집도란 하나의 클래스가 하나의 단위 작업 목적에 얼마나 충실한가 하는정도를 나타냅니다.

            ㅇ복잡성을 숨겨라
            복잡성을 숨긴다는것 관심 영역의 분리는 사실 같은 문제기도 합니다. 예를 들어 시스템이 검색 서비스를 사용해야 하는 경우, 실제 구현 부분을 하나의 컴포넌트로 구현하여 다른 모든 컴포넌트들이 이를 사용하게 하는 방식이 최선일겁니다.

            디자인 원식, 이어서
            느슨한 결합도
            객체지향 시스템은 그 본성상 객체 간 대화로 이루어져 있습니다. 이 대화에 인터페이스를 이요하면 두개의 클래스가 서로 대화하기 위하여 서로간의 알아야 할것의 수를 줄여줍니다.

            원격 프록시
            웹사이트가 커져감에 따라 하나의 거대한 서버, 즉 사이즈를 늘리기 보다 새로운 서버를 도입하여 문제를 푸는 것이 현실입니다. 이것이 가능하려면 서로 다른 서버 위에 서로 다른 힙 영역에서 돌아가는 자바 객체들이 서로 통신해야 한다는 말입니다.

            선언적인 제어를 많이 사용하라
            애플리케이션을 선언적으로 제어하는 방식은 J2EE컨테이너의 막강한 능력이라고 말할수 있습니다. 선언적인 제어는 애플리케이션 배포 서술자에서 대부분 이루어 집니다.

            원격 모델 컴포넌트를 지원하기 위한 패턴
            클라이언트가 곡개 정보를 요구할때
            1. 고객정보에 대한 요청을 접수 받으면 컴트롤러는 레거시 데이터베이스에 대하여 JDBC호출을 하는 고객관리 서비스 컴포넌트를 호출합니다. 그 다음 Customer 빈을 만들어 데이터베이스로 부터 읽어온 고객정보를 설정합니다.
            2. 컨트롤러는 request 객체에 속성으로 Customer 빈참조를 추가합니다.
            3. 컨트롤러는 이제 뷰인 JSP로 요청을 넘깁니다. JSP는 request 객체에 들어있는 Customer빈에 대한 참조를 사용할수 있게 됐죠
            4. JSP는 EL을 사용하여 Customer빈의 프로퍼티 정보를 뽑아내어 페이지를 완성합니다.

            RMI에 대해 조금만 살펴보죠
            서버측 RMI 사용을 위한 4단계
            1. 원격 인터페이스를 만듭니다 getCustData()와 같은 메소드 규약을 정의하는 곳입니다. 스텁과 실제 모델서비스가 이 인터페이스를 구현합니다.
            2. 원격 구현을 생성합니다. 원격 구현이 무엇이냐 하면 모델 서버상에 존재하는 실제 모델 객체를 말합니다. 여기엔 JNDI나 RMI 레지스트리와 같은 곳에 모델을 등록하는 코드가 포함됩니다.
            3. 스텁과 스켈레톤을 생성하니다. RMI는 프록시를 생성하는 rmic라는 컴파일러를 제공하무로 이를 이용하면 됩니다.
            4. 모델 서비스를 시작합니다.

            비즈니스 티어 패턴 : 한눈에 살펴보기
            지금까지 살펴본 비즈니스 티어 패턴을 요역하여 하나의 다이어그램으로 만들어 봤습니다. 여기에는 비즈니스 델리케이트, 서비스 로케이터, 트랜스퍼 오브젝트가 모두 들어있스니다.
            A6 단계 리뷰
            1. 서비스를 JNDI에 등록합니다.
            2. 비즈니스 델리게이트와 서비스 로케이터를 사용하여, JNDI에서 고객관리 스탭을 얻습니다.
            3. 비즈니스 델리케이트와 스탭을 사용하여  Customer 빈을 얻습니다. 여기서 Customer 빈은 트랜스퍼 오브젝트이죠. 이 스텁 참조를 컨트롤러로 리턴합니다.
            4. request 에 빈 참조를 추가합니다.
            5. 컨트롤러는 요청을 JSP로 넘깁니다. JSP는 request객체에서 Customer 트랜스퍼 오브젝트 참조를 얻습니다.
            6. JPS는 원래 요청한 의도대로 필요한Customer 트랜스퍼 오브젝트의 프로퍼티 정보를 EL로 추출하여 페이지를 완성합니다.

            MVC 패턴
            컨트롤러 :  request에서 사용자가 입력한 정보를 추출하여, 이것이 모델ㅔ 어떤 작용을 하라는 건지 파악합니다. 모델에게 자신의 데이터를 수정하라고 지시하던지, 뷰가 사용할수있게 모델정보를 request에 추가하든지 한다음 요청을 JSP로 넘기죠
            모델 : 실제 비즈니스 정보 및 비즈니스 로직이 들어있죠 즉 정보를 수정/접근하는 규칙을 알고 있다는 말입니다. 장바구니 안에 들어있는 컨텐츠는 MVC에서 모델의 한 종류죠 이부분이 데이터베이스와 대화하는 애플리케이션입니다.
            뷰 : 프리젠테이션의 역할을 담당하죠. 컨트롤러로 부터 모델 종보를 넘겨받습니다.

            MVC 컨트롤러를 한번 보죠
            일반 MVC 컨트롤러 의사 코드
            public class ControllerServlet extends HttpServlet{
            public void doPost(request, response){
            Stirng c= req.getparameter("startDate");
            //request 파라미터를 다루는 부분
            // 모델을 다루는 부분
            //뷰를 다루는 부분
            }
            }


            ---------------------------------------------------------------비즈니스 델리게이트 특징
            웹 애플리케이션 모델 컴포넌트가 원격인 호나경에 웹 티어 컨트롤러를 보호하려면 비즈니스 델리게이트를 사용하세요
            ㅇ 프록시로 행동함, 원격 서비스의 인터페이스 구현
            ㅇ 원격 서비스와 통신을 초기화 함
            ㅇ 통신시 상세사항 및 예외사항을 처리함
            ㅇ 요청을 해석하여, 이를 비즈니스 서비스로 넘겨줌
            ㅇ 응답을 해석하고, 이를 컨트롤러 컴포넌트로 넘겨줌.
            ㅇ 상세한 원격 컴퓨넌트 검색 및 통신을 처리함으로 해서 컨트롤러를 더욱 응집성 있는 컴포넌트로 만들어 줌

            ---------------------------------------------------------------비즈니스 델리게이트 원칙
            ㅇ 비즈니스 델리게이트 다음에 기초를 둠 :
             - 복잡성을 숨김
             - 인터페이스로 코딩
             - 느슨한 결함
             - 관심영역 분리
            ㅇ 비즈니스 티어 변경으로 인하여 웹 티어가 영향을 받는 것을 최소화
            ㅇ 두 티어간 결합 정도를 낮춤
            ㅇ 애플리케이션에 새로운 계층을 하나 추가함으로 해서 복잡도를 높이는 결과
            ㅇ 비즈니스 델리게이트 메소드 호출은 네트워크 트래픽을 최소화하기위해 큰 단위 호출이 바람직함


            서비스 로케이터
            레지스트리 검색을 위한 서비스 로케이터 패턴을 사용합니다. 이를 사용하면 JNDI 검색을 해야 하는 모든 컴포넌트를 아주 단순하게 유지 할수 있습니다.
            ---------------------------------------------------------------서비스 로케이터 특징
            ㅇ Initialcontext 객체를 얻습니다.
            ㅇ 레지스트리 검색을 수행함
            ㅇ 상세한 통신 사항이나 예외사항을 처리함
            ㅇ 한번 읽은 객체 참조는 캐시 해 두어 성능을 향상시킴
            ㅇ 다음과 같은 다양한 레시스트리와 작업함 : JNDI, RMI, UDDI,COS 네이밍
            ---------------------------------------------------------------서비스 로케이터 원리
            ㅇ 서비스 로케이ㅓ는 다음에 기초를 둠
             - 복잡성을 숨긴다.
             - 관심 영역의 분리
            ㅇ 원격 컴포넌트가 위치를 바꾸거나 컨테이너를 바꿀경우 웹 티어에 미치는 영향을 최소화함
            ㅇ 티어 간 결합 정도를 낮춤


            트랜스퍼 오브젝트
            잘게 나누어진 원격 컴포넌트를 대신하는 지역 클래스를 제공하여 네트워크 트래픽을 감소하는데 트랜스퍼 오브젝트를 사용하세요
            ---------------------------------------------------------------전송 객체 기능
            ㅇ 원격 엔티티에 대한 지역 대표 객체를 제공함
            ㅇ 네트워크 트래픽을 최소화
            ㅇ 자바 빈 명명법을 따름으로 해서 기타 객체들이 쉽게 접근할수 있도록 함
            ㅇ 네트워크를 가로질러 전송될수 있도록 직력화된 객체로 구현함
            ㅇ 일반적으로 뷰 컴포넌트에서 쉽게 접근할수 있도록 만듦


            인터셉팅 필터
            서블릿으로 보내지는 요청을 수정하기 위하여 또는 사용자에게 보낼 응답을 수정하기 위하여 인터셉팅 필터를 사용하세요
            ---------------------------------------------------------------인터셉팅 필터 기능
            ㅇ 서블릿에 도착하기 전 요청을 낚아채서 수정할수 있습니다.
            ㅇ 응답이 클라이언트로 넘가가기 전 이를 낚아채서 수정할수 있습니다.
            ㅇ 필터는 DD를 사용하여 선언적으로 배포할수 있습니다.
            ㅇ 컨테이너가 필터 생명주기를 관리합니다.
            ㅇ 필터는 컨테이너 콜백 메소드를 구현해야 합니다.
            ---------------------------------------------------------------인터셉팅 필터 원칙
            ㅇ 인터셉팅 필터는 다음에 기초를 둠 :
             - 응집력
             - 느슨한 결합
             - 선언적인 제어 능력
            ㅇ 선언적으로 필터를 설정할수 있기에 임시로 사용하거나 아니면 영구적으로 사용토록 쉽게 설정 가능함
            ㅇ 선언적으로 필터를 설정할수 있기에 순서대로 실행되는것도 쉽게 수정할수 있음


            모델 뷰 컨트롤러(MVC)
            애플리케이션을 논리적인 구조로 만드렁 세가지 기본 유형, 모델, 뷰, 컨트롤러로 코드를 관리하는데 MVC패턴을 사용하세요 이 방식은 각 컴포넌트의 응집성과 재사용성을 높입니다. 특히 모델 컴포넌트가 그러하죠
            ---------------------------------------------------------------모델, 뷰, 컨트롤러 특징
            ㅇ 컨트롤러와 모델과는 독립적으로 뷰를 수정할수 잇습니다.
            ㅇ 모델 컴포넌트는 뷰와 컨트롤러 컴포넌트로부터 데이터 구조와 같은 내부적인 상세한 사항을 숨깁니다.
            ㅇ 모델에 인터페이스를 가능한 한 사용하면, GUI또는 J2ME와 같은 영역에서도 재사용 가능합니다.
            ㅇ 컨트롤러에서 모델 코드부분을 분리하면 원격 비즈니스 컴포넌트 사용으로 옮겨가는 것이 수월해집니다.
            ---------------------------------------------------------------모델, 뷰, 컨트롤러 원칙
            ㅇ 모델, 뷰, 컨트롤러는 다음에 기초를 둠
             - 관심 영역의 분리
             - 느슨한 결합
            ㅇ 개별 컴포넌트의 응집력이 높아집니다.
            ㅇ 애플리케이션 전체 복잡도는 높아집니다.
            ㅇ 수정사항이 애플리케이션의 다른 영역에 최소한의 영향만 줍니다.


            프론트 컨트롤러
            일반적이며, 반복적인 요청 처리 부분을 하나의 컴포넌트화 하는데 프론트 컨트롤러를 사용하세요 이 패턴을 사용하면 애플리케이션 컨트롤러는 훨씬 응집력이 있으며, 덜 복잡한 모습을 보일것입니다.
            ---------------------------------------------------------------프론트 컨트롤러 특징
            ㅇ 웹 애플리케이션의 초기 요청 처리 작업을 하나의 컴포넌트로 집중화함
            ㅇ 다른 패턴과 프론트 컨트롤러를 함께 사용하면 프리젠테이션 티어 디스패칭 작업을 선언적으로 할수 있으므로 컴포넌트간 결합도를 낮추는 역할을 함
            ㅇ 프론트 컨트롤러의 단점은 스트럿츠와 비교해보면 너무 빈약하다는 것입니다. 프론트 컴트롤러 패턴에서 부터 출발하여 제대로 된 애플리케이션을 만들다 보면, 스트럿츠에 이미 구현된 것들을 재작성하고 있다는 것을 알수 있을것입니다.
            ---------------------------------------------------------------프론트 컨트롤러 원칙
            ㅇ 프론트 컨트롤러는 다음에 기초를 둠 :
             - 복잡성을 숨긴다.
             - 관심 영역의 분리
             - 느슨한 결합
            ㅇ 애플리케이션 컨트롤러 컴포넌트 응집성을 높입니다.
            ㅇ 애플리케이션 복잡성을 낮춥니다.
            ㅇ 기반 구조의 코드 유지보수성을 좋게 합니다.


            저작자 표시

            'BOOK Study > J2EE' 카테고리의 다른 글

            01. Java EE 6 Overrview & Getting Java EE 6 sample codes  (0) 2010/01/11
            [java ee programming] Java EE 6 "1-day" Online Codecamp (on Jan. 12th, 2010)‏  (0) 2010/01/04
            14. 패턴과 스트럿츠  (0) 2010/01/04
            13. 필터와 랩퍼  (0) 2010/01/03
            12. 웹 애플리케이션 보안  (0) 2010/01/03
            11. 웹 애플리케이션 배포  (0) 2010/01/03
            Trackback 0 Comment 0