10년후의 미래는 현재가 말해준다

Spring Conept

들기름왕자 — Sat, 22 May 2010 18:00:41 +0900

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를 관리 해야 한다.

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

들기름왕자 — Mon, 25 Jan 2010 23:49:02 +0900

ㅇ 누구를 위한 책인가 ?
   - 이 책은 자바 언어와 자바 핵심 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. 마지막으로 클라이언트에 적하ㅏㅂ하게 결과를 보여준다.

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

들기름왕자 — Mon, 25 Jan 2010 21:12:44 +0900

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 클래스

찾아보기

06. Java EE 6 - EJB 3.1

들기름왕자 — Sun, 17 Jan 2010 21:29:30 +0900

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)

In this exercise, you are going to build a Web application step by step in which a servlet invokes a method of an EJB. You will see both servlet and EJB beans are included in a single war file.

(1.1) Create a new project

0. Start NetBeans IDE.
1. Create a new Web project.

Figure-1.11

For the Project Name field, enter EJB-in-a-war (or whatever project name of your choice).
Click Next.

Figure-1.12

Click Finish.

Figure-1.13

(1.2) Create a Session bean

1. Create a new Session bean.

Right click project and New->Other. (If you see Session Bean in the pop-up menu, select it.)

Figure-1.21

Figure-1.21a

For the EJB Name field, enter MySessionBean (or whatever name of your choice).
For the Package field, enter server (or whatever package name of your choice).
Click Finish.

Figure-1.22

2. Modify IDE generated MySessionBean.java as shown below. The modification is to add a simple business method called sayHello(..) to the bean.

package server;

import javax.ejb.Stateless;

/**
*
* @author sang
*/
@Stateless
public class MySessionBean {

    // Add business logic below. (Right-click in editor and choose
    // "Insert Code > Add Business Method")
    public String sayHello(String name){
        return "Hello " + name + "!";
    }

}

MySessionBean.java

Figure-1.23

(1.3) Create a Servlet

In this step, you are going to create a servlet, which invokes sayHello() method of the MySessionBean you created above.

1. Create a new Servlet.

Figure-1.31

For the Class Name field, enter HelloServlet (or whatever class name of your choice).
For the package field, enter client (or whatever package name of your choice).
Click Finish.

Figure-1.32

2. Inject MySessionBean into the servlet.

Type @EJB My and observe code completion feature kicks in. (If the code completion does not appear, press CTRL+Space or CTRL+CMD+Backslash on Mac OS X.)
Select MySessionBean (server).
Type client;

Figure-1.33

Observe that you have added the line in bold and red-colored font below.

...
@WebServlet(name="HelloServlet", urlPatterns={"/HelloServlet"})
public class HelloServlet extends HttpServlet {

    @EJB MySessionBean client;

    /**
     * Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
...

3. Fix imports.

Right click any spot in the editor window and select Fix Imports.

Figure-1.34

4. Call the EJB.

Remove comments on the statements within try{..} block.
Modify the code as shown below. The modification is to invoke sayHello() method of the EJB.

Figure-1.35

NetBeans Tip: You can leverage code-completion feature of the IDE as shown below. When you type client. and press CTRL+SPACE ( CTRL+Space or CTRL+CMD+Backslash on Mac OS X.), observe that sayHello(String name) is one of the selections.

Figure-1.36

(1.4) Build and run the application

1. Change Relative URL of the project. This is so that when you run the application, the Relative URL is automatically attached to the URL.

Figure-1.41

Select Run under Categories on the left.
For the Relative URL field, enter /HelloServlet. The value of the Relative URL is appended to the context path when the application is accessed for the first time.
Click OK.

Figure-1.42

2. Build and run the application.

Figure-1.43

Observe that "Calling EJB Hello Sang Shin!" gets displayed. This verifies that sayHello() method of the EJB is invoked successfully.

Figure-1.44

(1.5) Check the war file

In this step, you are going to see that both EJB and Servlet classes are in the same war file.

1. Verify that a single war file contains both HelloServlet.class and MySessionBean.class.

Select Files tab. The Files window show the files from local file system point of view.
Expand build->web->WEB-INF->classes.
Observe that the MySessionBean EJB is part of the war file.

Figure-1.51

Solution: The solution of this exercise is provided as "ready to build and run" NetBeans project as EJB-in-a-war under <LAB_UNZIPPED_DIRECTORY>/javaee6_ejb3.1/solutions directory.

Summary

In this exercise, you built a Web application in which EJB is used. You observed that you don't need to create EJB module jar file and you don't have to create EAR file. Instead, the war file contains the EJB.

Exercise 2: Singleton

Singletons are POJOs just like our Session beans, and the container is guaranteed to maintain a single shared instance of this Singleton. These Singletons are thread safe and also transactional. Like all other EJB’s, singletons have all the services such as security, remoting, dependency injection, web services, interceptors and so on.

In this exercise, you are going to use a singleton-based counter, which is used as an application-wide counter. You are also going to use @Startup annotation, which provides life-cycle methods.

(2.1) Singleton-based counter: "counter" sample application

1. Open counter NetBeans project (from "Java EE 6 tutorial").

Select File->Open Project (Ctrl+Shift+O, Cmd+Shift+O on a Mac).
Observe that the Open Project dialog box appears.

Browse down to <GlassFish-v3-Installation-Directory>/glassfish/docs/javaee-tutorial/examples/ejb directory. ("Java EE 6 tutorial")
Select counter.
Click Open Project.

Observe that the counter project node appears under Projects tab window.

2. Build and run counter project.

Right-click counter project and select Run.
Browser gets displayed.
Observe that "This page has been accessed 1 time(s)." message gets displayed.

Figure-2.11

Click Refresh button to access the page again.
Observe that the counter has been changed to 2 (from 1).

Figure-2.12

3. Access the application from a different user - the 2nd user. Since the counter is application-wide scope, accessing the page from the second user should increase the counter's value to 3.

Using another instance of the browser, or different type of browser (here Safari is being used), go to http://localhost:8080/counter/

Figure-2.13

Observe that the value of the counter is increased to 3 as expected.

Figure-2.14

4. Access the application from the first user. Now accessing the counter from the first user should increase the counter to 4.

Figure-2.15

Observe that the counter is increased to 4 as expected.

Figure-2.16

(2.2) Study code

Note: We have not covered the "template" concept and "Facelets" of JSF 2.0 yet in this codecamp. Just consider template-client.xhtml and template.xhtml are used to display #{count.hitCount} for now.

1. template-client.xhtml. This is a JSF display page using the template called template.xhtml.

<?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">
    <body>

        This text above will not be displayed.

        <ui:composition template="/template.xhtml">

            This text will not be displayed.

            <ui:define name="title">
                This page has been accessed #{count.hitCount} time(s).
            </ui:define>

            This text will also not be displayed.

            <ui:define name="body">
                Hooray!
            </ui:define>

            This text will not be displayed.

        </ui:composition>

        This text below will also not be displayed.

    </body>
</html>

template-client.xhtml.

2. template.xhtml. This is the template.

template.xhtml.

3. CounterBean.java. Note that CounterBean is a Singleton bean.

package counter.ejb;

import javax.ejb.Singleton;

/**
*
* @author ian
* CounterBean is a simple singleton session bean that records the number
* of hits to a web page.
*/
@Singleton
public class CounterBean {
    private int hits = 1;

    // Increment and return the number of hits
    public int getHits() {
        return hits++;
    }
}

CounterBean.java

4. Counter.java.

package counter.web;

import counter.ejb.CounterBean;
import javax.ejb.EJB;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;

/**
*
* @author ian
*/
@ManagedBean
@SessionScoped
public class Count {
    @EJB
    private CounterBean counterBean;
    private int hitCount;

    public Count() {
        this.hitCount = 0;
    }

    public int getHitCount() {
        hitCount = counterBean.getHits();

        return hitCount;
    }

    public void setHitCount(int newHits) {
        this.hitCount = newHits;
    }
}

Count.java

(2.3) Application Startup/Shutdown callbacks

The introduction of singletons also provides a convenient way for EJB applications to receive callbacks during application initialization or shutdown. By default, the container decides when to instantiate the singleton instance. However, you can force the container to instantiate the singleton instance during application initialization by using the @Startup annotation. This allows the bean to define a @PostConstruct method that is guaranteed to be called at startup time. In addition, any @PreDestroy method for a singleton is guaranteed to be called when the application is shutting down, regardless of whether the singleton was instantiated using lazy instantiation or eager instantiation. In lazy instantiation, the singleton isn't instantiated until it's method's are first needed. In eager instantiation, the singleton is instantiated at startup time whether or not it gets used.

1. Add MyStartupBean.java to the project.

package counter.ejb;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.ejb.Singleton;
import javax.ejb.Startup;

@Singleton
@Startup
public class MyStartupBean {

    @PostConstruct
    private void startup() {
        System.out.println("----startup() method of MyStartupBean is called");
    }

    @PreDestroy
    private void shutdown() {
        System.out.println("----shutdown() method of MyStartupBean is called");
    }
}

MyStartupBean.java

Figure-2.31

2. Build and run the application.

Right-click counter project and select Run.
Browser gets displayed.
Observe that "This page has been accessed 1 time(s)." message gets displayed.

Figure-2.32

3. Observe the message "----startup() method of MyStartupBean is called" in the GlassFish v3 Domain system.log.

Figure-2.33

Note: if you do the exercise 2 in sequence, you will see several instances of "----startup() method of MyStartupBean is called"
and "----shutdown() method of MyStartupBean is called" because the project is redeployed before it is run or because you close the browser window inbetween.

4. Undeploy the application.

Figure-2.34

5. Observe the message "----shutdown() method of MyStartupBean is called" in the GlassFish v3 Domain system.log.

Figure-2.35

Summary

In this exercise, you learned how to use @Singleton annotation. You have also used @Startup annotation, which provides life-cycle methods.

Exercise 3: Timer

The Timer feature of EJB 3.1 provides an ability to declaratively create cron-like schedules to trigger EJB methods. All that is needed is to annotate an EJB method with the @Schedule annotation to implement the timer.

(3.1) Open, build, and run "timersession" sample application (from "Java EE 6 tutorial")

1. Open timersession NetBeans project.

Select File->Open Project (Ctrl+Shift+O).
Observe that the Open Project dialog box appears.

Browse down to <GlassFish-v3-Installation-Directory>/glassfish/docs/javaee-tutorial/examples/ejb directory.
Select timersession.
Click Open Project.

Observe that the timersession project node appears under Projects tab window.

2. Build and run timersession project.

Right-click timersession project and select Run.
Browser gets displayed.

Figure-3.11

Figure-3.12

Figure-3.13

Figure-3.14

Observe in the GlassFish log that the Timers are first restored from the Timer Service.
Then an automatic timeout occurs which denotes the scheduling start.
Then the programmatic timeouts comes from the user's actions.
The remaining automatic timeouts occur as long as the application is running.

Figure-3.14a

(3.2) Study code

1. timer-client.xhtml.

<?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:f="http://java.sun.com/jsf/core"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:ui="http://java.sun.com/jsf/facelets">
    <body>
        <ui:composition template="/timer.xhtml">
            <ui:define name="title">
                Timer page
            </ui:define>

            <ui:define name="body">
                <p>The last programmatic timeout was: #{timerManager.lastProgrammaticTimeout}.</p>

                <p>The last automatic timeout was: #{timerManager.lastAutomaticTimeout}</p>

                <p>Set a programmatic timer here.</p>
                <h:form>
                    <h:commandButton value="Set Timer" action="#{timerManager.setTimer}" />
                    <h:commandButton value="Refresh" action="timer-client"/>
                </h:form>
            </ui:define>
        </ui:composition>
    </body>
</html>

2. TimerManager.java.

package timersession.web;

import javax.ejb.EJB;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;
import timersession.ejb.TimerSessionBean;

/**
*
* @author ian
*/
@ManagedBean
@SessionScoped
public class TimerManager {
    private String lastAutomaticTimeout;
    private String lastProgrammaticTimeout;
    @EJB
    private TimerSessionBean timerSession;

    /** Creates a new instance of TimerManager */
    public TimerManager() {
        this.lastProgrammaticTimeout = "never";
        this.lastAutomaticTimeout = "never";
    }

    /**
     * @return the lastTimeout
     */
    public String getLastProgrammaticTimeout() {
        lastProgrammaticTimeout = timerSession.getLastProgrammaticTimeout();

        return lastProgrammaticTimeout;
    }

    /**
     * @param lastTimeout the lastTimeout to set
     */
    public void setLastProgrammaticTimeout(String lastTimeout) {
        this.lastProgrammaticTimeout = lastTimeout;
    }

    public void setTimer() {
        long timeoutDuration = 8000;
        timerSession.setTimer(timeoutDuration);
    }

    /**
     * @return the lastAutomaticTimeout
     */
    public String getLastAutomaticTimeout() {
        lastAutomaticTimeout = timerSession.getLastAutomaticTimeout();

        return lastAutomaticTimeout;
    }

    /**
     * @param lastAutomaticTimeout the lastAutomaticTimeout to set
     */
    public void setLastAutomaticTimeout(String lastAutomaticTimeout) {
        this.lastAutomaticTimeout = lastAutomaticTimeout;
    }
}

3. TimerSessionBean.java

/*
* Copyright 2009 Sun Microsystems, Inc.
* All rights reserved. You may not modify, use,
* reproduce, or distribute this software except in
* compliance with the terms of the License at:
* http://developer.sun.com/berkeley_license.html
*/

package timersession.ejb;

import java.util.Date;
import java.util.logging.Logger;
import javax.annotation.Resource;
import javax.ejb.Schedule;
import javax.ejb.Singleton;
import javax.ejb.Startup;
import javax.ejb.Timeout;
import javax.ejb.Timer;
import javax.ejb.TimerService;

/**
* TimerBean is a singleton session bean that creates a timer and prints out a
* message when a timeout occurs.
* Created March 3, 2009 12:38 PM PST
* @author ian
*/
@Singleton
@Startup
public class TimerSessionBean {
    @Resource
    TimerService timerService;
    private Date lastAutomaticTimeout;
    private Date lastProgrammaticTimeout;
    private Logger logger = Logger.getLogger(
                "com.sun.tutorial.javaee.ejb.timersession.TimerSessionBean");

    public void setTimer(long intervalDuration) {
        logger.info(
                "Setting a programmatic timeout for " + intervalDuration
                + " milliseconds from now.");

        // Create a single-action timer that expires after a specified duration.
        Timer timer = timerService.createTimer(
                    intervalDuration,
                    "Created new programmatic timer");
    }

    // Designates a method that should receive EJB timer expiration
    @Timeout
    public void programmaticTimeout(Timer timer) {
        this.setLastProgrammaticTimeout(new Date());
        logger.info("Programmatic timeout occurred.");
    }

    // Schedule a timer for automatic creation with a timeout schedule based
    // on a cron-like time expression. The annotated method is used as the
    // timeout callback method.
    //
    // Invoke the method every minute in every hour.
    @Schedule(minute = "*/1", hour = "*")
    public void automaticTimeout() {
        this.setLastAutomaticTimeout(new Date());
        logger.info("Automatic timeout occured");
    }

    /**
     * @return the lastTimeout
     */
    public String getLastProgrammaticTimeout() {
        if (lastProgrammaticTimeout != null) {
            return lastProgrammaticTimeout.toString();
        } else {
            return "never";
        }
    }

    /**
     * @param lastTimeout the lastTimeout to set
     */
    public void setLastProgrammaticTimeout(Date lastTimeout) {
        this.lastProgrammaticTimeout = lastTimeout;
    }

    /**
     * @return the lastAutomaticTimeout
     */
    public String getLastAutomaticTimeout() {
        if (lastAutomaticTimeout != null) {
            return lastAutomaticTimeout.toString();
        } else {
            return "never";
        }
    }

    /**
     * @param lastAutomaticTimeout the lastAutomaticTimeout to set
     */
    public void setLastAutomaticTimeout(Date lastAutomaticTimeout) {
        this.lastAutomaticTimeout = lastAutomaticTimeout;
    }
}

(3.3) Open, build, and run "automatic-timer" sample application (from "glassfish-samples")

1. Open automatic-timer NetBeans project.

Select File->Open Project (Ctrl+Shift+O).
Observe that the Open Project dialog box appears.

Browse down to <GlassFish-v3-Installation-Directory>/glassfish/samples/javaee6/ejb directory.
Select automatic-timer.
Click Open Project.

Observe that the automatic-timer-ejb project node appears under Projects tab window.

2. Build and run automatic-timer-ejb project.

Right-click automatic-timer-ejb project and select Run.
Observe the result in the Output window.

(3.4) Study the code

1. StatelessSession.java

package enterprise.automatic_timer_ejb;

import java.util.List;

import javax.ejb.Remote;

@Remote
public interface StatelessSession {

public List<String> getRecords();

}

2. StatelessSessionBean.java

package enterprise.automatic_timer_ejb;

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

import javax.ejb.Stateless;
import javax.ejb.Schedule;
import javax.ejb.Timer;
import javax.persistence.EntityManager;
import javax.persistence.Query;
import javax.persistence.PersistenceContext;

import enterprise.automatic_timer_ejb.persistence.LogRecord;

@Stateless
public class StatelessSessionBean implements StatelessSession {

    @PersistenceContext EntityManager em;

    @Schedule(second="*/3", minute="*", hour="*", info="Automatic Timer Test")
    public void test_automatic_timer(Timer t) {
        long count = (Long)em.createNamedQuery("LogRecord.countLoggedTimeouts").getSingleResult();

        System.out.println("Call # " + (count + 1));
        if (count > 10) {
            throw new IllegalStateException("Too many timeouts received: " + count);
        } else if (count == 10) {
            LogRecord lr = new LogRecord("Canceling timer " + t.getInfo() + " at " + new Date());
            em.persist(lr);
            t.cancel();
            System.out.println("Done");
        } else {
            LogRecord lr = new LogRecord("" + t.getInfo() + " timeout received at " + new Date());
            em.persist(lr);
        }
    }

    public List<String> getRecords() {
        return (List<String>)em.createNamedQuery("LogRecord.findAllRecords").getResultList();
    }
}

3. LogRecord.java

package enterprise.automatic_timer_ejb.persistence;

import javax.persistence.*;

//name defaults to the unqualified entity class name.
//default access is property.
@Entity
@NamedQueries({
    @NamedQuery(name = "LogRecord.countLoggedTimeouts", query = "select count(l) from LogRecord l where l.record NOT LIKE \"Canceling timer%\""),
    @NamedQuery(name = "LogRecord.findAllRecords", query = "select l.record from LogRecord l")
})
public class LogRecord {

    @Id
    @GeneratedValue
    private int id;
    private String record;

    public LogRecord(String record) {
        setRecord(record);
    }

    public LogRecord() {
    }

    public String getRecord() {
        return record;
    }
    public void setRecord(String record) {
        this.record = record;
    }


}

Summary

In this exercise, you have learned the Timer feature of EJB 3.1, which provides an ability to declaratively create cron-like schedules to trigger EJB methods.

Exercise 4: Asynchronous method invocation using @Asynchronous

In previous version of EJB, the only way to accomplish asynchronous processing was by using Message Driven Beans. Even though writing MDBs was very trivial, configuring all the necessary server resources like connection factories, topics and queues made it a little bit of a chore, especially since all I needed was an asynchronous method invocation.

With EJB 3.1 these issues are easily solved by a simple annotation placed on the Session Bean: @Asynchronous. Under normal circumstances, a Session bean method call blocks the client for the duration of that call. With this annotation in place, the container returns control to the client and executes the method on a separate thread.

The Session bean method call which is annotated with the @ Asynchronous annotation can return a java.util.Future object that allows the client to retrieve a result value, check for exceptions, or attempt to cancel an in-progress invocation.

(4.1) Asynchronous method

In this exercise, a method, which performs a potentially long-ruuning database operration, in ItemEJB is called with @Asynchronous. The method returns void.

1. Open ejb3.1_asynch NetBeans project (from "Lab samples").

Select File->Open Project (Ctrl+Shift+O).
Observe that the Open Project dialog box appears.

Browse down to <LAB_UNZIPPED_DIRECTORY>/javaee6_ejb3.1/samples directory directory.
Select ejb3.1_asynch.
Click Open Project.

Observe that the ejb3.1_asynch project node appears under Projects tab window.

2. Build and run ejb3.1_asynch project.

Right-click ejb3.1_asynch project and select Run.
Browser gets displayed.

For the Title field, enter Life is good! (or whatever book title of your choice).
Click Submit Query button.

Figure-4.11

Observe that the name of the Book title gets displayed.

Figure-4.12

(4.2) Study code

1. index.html.

<html>
<head><title>Create a Book</title></head>
<body>
<h1>Create a new book</h1>
<hr/>
<form action="BookServlet">
    <table border="0">
        <tr>
            <td>Title :</td>
            <td><input type="text" name="title"/></td>
        </tr>
    </table>

    <input type="submit" name="Create a book"/>

</form>
<hr/>

</body>
</html>

2. BookServlet.java.

package mypackage;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;
import javax.ejb.EJB;

@WebServlet(loadOnStartup = 1, urlPatterns = "/BookServlet")
public class BookServlet extends HttpServlet {

    // Inject ItemEJB instance
    @EJB
    private ItemEJB itemEJB;

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        // Creates an instance of book
        Book book = new Book();
        book.setTitle(request.getParameter("title"));

        // Call EJB method asynchronously
        itemEJB.createBookAsynch(book);
        try {
            // Sleep for 2000 ms to give async. thread to finish the task
            Thread.sleep(2000);

            response.setContentType("text/html");
            PrintWriter out = response.getWriter();

            // Displays the books
            out.println("<h1>====== All books ======</h1>");
            //List<Book> books = em.createNamedQuery("findAllBooks").getResultList();
            List<Book> books = itemEJB.findAllBooks();
            for (int i = 0; i < books.size(); i++) {
                Book b = books.get(i);
                out.println("Book title: " + b.getTitle() + "<br/>");
            }
        } catch (Exception ie) {
        }

    }
}

BookServlet.java

3. ItemEJB.java

package mypackage;

import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import java.util.List;
import java.util.concurrent.Future;
import javax.ejb.AsyncResult;
import javax.ejb.Asynchronous;

@Stateless
public class ItemEJB {

    @PersistenceContext
    private EntityManager em;

    public Book createBook(Book book) {
        em.persist(book);
        return book;
    }

    @Asynchronous
    public void createBookAsynch(Book book) {
        em.persist(book);
    }

    @Asynchronous
    public Future<Book> createBookAsynchUsingFuture(Book book) {
        em.persist(book);
        return new AsyncResult<Book>(book);
    }

    public List<Book> findAllBooks() {
        return em.createNamedQuery("findAllBooks").getResultList();
    }
}

ItemEJB.java

4. Book.java

package mypackage;

import javax.persistence.*;

@Entity
@NamedQueries({
    @NamedQuery(name = "findAllBooks", query = "SELECT b FROM Book b")
})
public class Book {

    @Id
    @GeneratedValue
    private Long id;
    private String title;

    public Long getId() {
        return id;
    }

    public String getTitle() {
        return title;
    }

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

Book.java

(4.3) Open, build, and run "ejb3.1_asynch_using_Future" sample application (from "Hands-on lab samples")

In this exercise, a method, which performs a potentially long-ruuning database operration, in ItemEJB is called with @Asynchronous. The method returns Future object.

1. Open ejb3.1_asynch_using_Future NetBeans project.

Select File->Open Project (Ctrl+Shift+O).
Observe that the Open Project dialog box appears.

Browse down to Browse down to <LAB_UNZIPPED_DIRECTORY>/javaee6_ejb3.1/samples directory.
Select ejb3.1_asynch_using_Future.
Click Open Project.

Observe that the ejb3.1_asynch_using_Future project node appears under Projects tab window.

2. Build and run ejb3.1_asynch_using_Future project.

Right-click ejb3.1_asynch_using_Future project and select Run.
Browser gets displayed.

For the Title field, enter Life is good! (or whatever book title of your choice).
Click Submit Query button.

Figure-4.31

Figure-4.32

(4.4) Study code

1. BookServlet.java

package mypackage;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.concurrent.Future;
import javax.ejb.EJB;

@WebServlet(loadOnStartup = 1, urlPatterns = "/BookServlet")
public class BookServlet extends HttpServlet {

    // Inject ItemEJB instance
    @EJB
    private ItemEJB itemEJB;

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        // Creates an instance of book
        Book book = new Book();
        book.setTitle(request.getParameter("title"));

        // Call EJB method asynchronously
        Future<Book> future = itemEJB.createBookAsynchUsingFuture(book);
        try {
            // Sleep for 2000 ms to give async. thread to finish the task
            Thread.sleep(2000);

            response.setContentType("text/html");
            PrintWriter out = response.getWriter();

            // Display the newly created book
            out.println("<h1>====== Book that has been created asynchronously</h1>");
            Book b = future.get();
            out.println("Book title: " + b.getTitle() + "<br/>");

        } catch (Exception ie) {
        }
    }
}

BookServlet.java

2. ItemEJB.java.

ItemEJB.java

Summary

In this exercise, you have learned how to use @Asynchronous annotation to invoke a EJB method in asynchronous manner.

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

Testing EJBs was a herculean task all these years. It isn’t anymore with the timely and useful innovation of the embeddable container. The embeddable container allows you to use JPA and EJB 3.1 outside a container including testing.

In this exercise, you are going to build a standalone Java SE application in which you are going to test EJB-based application logic step by step.

(5.1) Create a new "Java Application" (Java SE) project

1. Create a new Java Application project.

Figure-5.11

Figure-5.12

2. Give a name to the project.

For the Project Name field, enter ejb3.1_embedded.
Uncheck Create Main Class. (We don't need to create Main class.)
Click Finish.

Figure-5.13

(5.2) Add EJB beans

In this step, you are going to add a simple Book entity class and ItemBook Stateless bean class.

1. Add Book entity class.

Right click project and select New->Entity Class. (If you don't see Entity class from the pop-up menu, select Other, select Persistence on the left.)

Figure-5.21

For the Class Name field, enter Book.
For the Package field, enter mypackage.
Click Finish.

Figure-5.22

2. Modify the IDE generated Book.java as shown below.

package mypackage;

import java.io.Serializable;
import javax.persistence.*;

@Entity
@NamedQueries({
    @NamedQuery(name = "findAllBooks", query = "SELECT b FROM Book b")
})
public class Book implements Serializable {

    @Id
    @GeneratedValue
    private Long id;
    private String title;

    public Long getId() {
        return id;
    }

    public String getTitle() {
        return title;
    }

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

Figure-5.23

3. Create ItemEJB Stateless bean.

Figure-5.24

For the Class Name field, enter ItemEJB.
Click Finish.

Figure-5.25

4. Modify IDE generated ItemEJB.java as shown below.

package mypackage;

import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import java.util.List;

@Stateless
public class ItemEJB {

    @PersistenceContext
    private EntityManager em;

    public Book createBook(Book book) {
        em.persist(book);
        return book;
    }

    public List<Book> findAllBooks() {
        return em.createNamedQuery("findAllBooks").getResultList();
    }

}

Figure-5.26

return to top of exercise

(5.3) Add libraries

In this step you are going add the following library jar files.

From the <GlassFish-v3-Installation-Directory>/glassfish/modules directory.

gf-ejb-connector.jar
glassfish-api.jar
javax.ejb.jar
javax.persistence.jar

From <GlassFish-v3-Installation-Directory>/glassfish/modules/endorsed directory

javax.annotation.jar

From the <GlassFish-v3-Installation-Directory>/glassfish/lib/embedded directory.

glassfish-embedded-static-shell.jar

1. Add jar files from <GlassFish-v3-Installation-Directory>/glassfish/modules directory.

Figure-5.31

Figure-5.32

Figure-5.33

2. Add library files from <GlassFish-v3-Installation-Directory>/glassfish/modules/endorsed directory

Figure-5.34

3. Add library files from <GlassFish-v3-Installation-Directory>/glassfish/lib/embedded directory.

Figure-5.35

4. Verify that the library files are added.

Figure-5.36

return to top of exercise

(5.4) Create persistence unit

1. Create persistence unit.

Figure-5.41

2. Set the values of the persistence unit.

For the Persistence Unit Name field, take the value given by the IDE.
For the Database Connection field, select jdbc:derby://localhost:1527/sample [app on APP].
For the Table Generation Strategy, select Drop and Create.
Click Finish.

Figure-5.42

3. Add entity class to the persistence unit.

Click Add Class button for the Include Entity Classes section.

Figure-5.43

Select mypackage.Book.
Click OK.

Figure-5.44

4. Change Transaction Type to JTA.

Select XML tab.
Change the value of the transaction-type attribute to JTA.

Figure-5.45

(5.5) Add testing code

In this step, you are going to add testing code in which EJBContainer gets created, EJB are deployed and tested.

1. Create ItemEJBTest.java.

Right click Test Packages and select New->Java Class.

Figure-5.51

For the Class Name field, enter ItemEJBTest.
For the Package field, enter testpackage.
Click Finish.

Figure-5.52

2. Modify IDE generated code with the one below.

package testpackage;

import mypackage.Book;
import javax.ejb.embeddable.EJBContainer;
import javax.naming.Context;
import mypackage.ItemEJB;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;

public class ItemEJBTest {

    private static EJBContainer ec;
    private static Context ctx;

    @BeforeClass
    public static void initContainer() throws Exception {
        System.out.println("----Creating EJBContainer...");
        ec = EJBContainer.createEJBContainer();
        ctx = ec.getContext();
    }

    @AfterClass
    public static void closeContainer() throws Exception {
        if (ec != null) {
            System.out.println("----Closing EJBContainer...");
            ec.close();
        }
    }

    @Test
    public void createBook() throws Exception {
        System.out.println("----Looking up EJB...");
        ItemEJB itemEJB = (ItemEJB) ctx.lookup("java:global/classes/ItemEJB");
        // ItemEJB itemEJB = new ItemEJB();

        // Counts all the books in the database
        int nbBooks = itemEJB.findAllBooks().size();

        // Creates a new book
        Book book = new Book();
        book.setTitle("Passion");

        // Persists the book to the database
        System.out.println("----Creating a book...");
        book = itemEJB.createBook(book);
        assertNotNull("ID should not be null", book.getId());

        // Checks that there is an extra book in the database
        assertEquals("Should have an extra book", itemEJB.findAllBooks().size(), nbBooks + 1);
    }
}

Figure-5.53

(5.6) Build a jar file that contains EJB

1. Do the clean build.

Figure-5.61

2. Verify that the build was successful.

Figure-5.62

(5.7) Run the testing

1. Right click ItemEJBTest.java under Test Packages->testpackages and select either Run File or Test File.

Figure-5.71

2. Observe the debugging messages from the testing.

Figure-5.72

3. Observe the testing result.

If you don't see the Testing Results window, select Window from the top-level menu and select Output->Test Results.

Figure-5.73

Observe that the test passed.

Figure-5.74

Observe the debugging messages.

Figure-5.75

Solution: The solution is available as "ready to open and build" NetBeans project as ejb3.1_embedded under <LAB_UNZIPPED_DIRECTORY>/javaee6_ejb3.1/solution directory.

(5.8) Use APP_NAME JNDI name

1. Modify the ItemEJBTest.java as shown below.

package testpackage;

import java.util.HashMap;
import java.util.Map;
import mypackage.Book;
import javax.ejb.embeddable.EJBContainer;
import javax.naming.Context;
import mypackage.ItemEJB;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;

public class ItemEJBTest {

    private static EJBContainer ec;
    private static Context ctx;

    @BeforeClass
    public static void initContainer() throws Exception {
        System.out.println("----Creating EJBContainer...");
        Map<String, Object> map = new HashMap<String, Object>();
        map.put(EJBContainer.APP_NAME, "myapp");
        ec = EJBContainer.createEJBContainer(map);
        ctx = ec.getContext();
    }

    @AfterClass
    public static void closeContainer() throws Exception {
        if (ec != null) {
            System.out.println("----Closing EJBContainer...");
            ec.close();
        }
    }

    @Test
    public void createBook() throws Exception {
        System.out.println("----Looking up EJB...");
        ItemEJB itemEJB = (ItemEJB) ctx.lookup("java:global/myapp/ItemEJB");
        // ItemEJB itemEJB = new ItemEJB();

        // Counts all the books in the database
        int nbBooks = itemEJB.findAllBooks().size();

        // Creates a new book
        Book book = new Book();
        book.setTitle("Passion");

        // Persists the book to the database
        System.out.println("----Creating a book...");
        book = itemEJB.createBook(book);
        assertNotNull("ID should not be null", book.getId());

        // Checks that there is an extra book in the database
        assertEquals("Should have an extra book", itemEJB.findAllBooks().size(), nbBooks + 1);
    }
}

2. Do the clean build.

Figure-5.81

3. Run the testing.

Observe that the testing is successful.

Solution: The solution is available as "ready to open and build" NetBeans project as ejb3.1_embedded_jndi_APP_NAME under <LAB_UNZIPPED_DIRECTORY>/javaee6_ejb3.1/solutions directory.

Summary

In this exercise, you have learned how to test EJB through "Embeddable EJB container" feature of EJB 3.1, in which EJB container can be created programmatically and EJB are deployed and tested.

Exercise 6: EJB and RESTful service

In JAX-RS 1.1, EJB can be exposed as RESTful web service.

(6.1) Verify a simple EJB application is working

In this step, you are going to verify a simple EJB application is working as expected. We are going to expose Session bean as RESTful services.

1. Open ejb3.1_rest_base NetBeans project (from "Lab samples").

Select File->Open Project (Ctrl+Shift+O).
Observe that the Open Project dialog box appears.

Browse down to <LAB_UNZIPPED_DIRECTORY>/javaee6_ejb3.1/samples directory directory.
Select ejb3.1_rest_base.
Click Open Project.

Observe that the ejb3.1_rest_base project node appears under Projects tab window.

2. Build and run ejb3.1_rest_base project.

Right-click ejb3.1_rest_base project and select Run.
Browser gets displayed.

Figure-6.11

Observe that the newly created book title is displayed. This verifies the sample app is a working EJB application.

Figure-6.12

(6.2) Make the Session bean as RESTful service

1. Modify ItemEJB.java as shown below. The code fragments that need to be added are highlighted in bold and red-colored font.

package mypackage;

import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import java.util.List;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;

@Stateless
@Path("/items")
public class ItemEJB {

    @PersistenceContext
    private EntityManager em;

    public Book createBook(Book book) {
        em.persist(book);
        return book;
    }

    @GET
    @Path("{bookKey}")
    @Produces({"application/xml", "application/json"})
    public Book getBook(@PathParam("bookKey") String key) {
        Book theBook = em.find(Book.class, new Long(key));
        return theBook;
    }

    @GET
    public List<Book> findAllBooks() {
        return em.createNamedQuery("findAllBooks").getResultList();
    }
}

Figure-6.21

2. Modify Book.java as shown below.

package mypackage;

import java.io.Serializable;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlRootElement;

@Entity
@NamedQueries({
    @NamedQuery(name = "findAllBooks", query = "SELECT b FROM Book b")
})
@XmlRootElement
public class Book implements Serializable {

    @Id
    @GeneratedValue
    private Long id;
    private String title;

    public Long getId() {
        return id;
    }

    public String getTitle() {
        return title;
    }

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

Figure-6.22

3. Build and run the application and add two Book items into Book table.

Figure-6.23

Figure-6.24

Figure-6.25

Figure-6.26

4. Verify that the BOOK table has two entries.

5. Test the ItemEJB RESTful web service.

Observe that the browser gets displayed.

6. Access ItemEJB as RESTful web services using browser.

From your browser, go to http://localhost:8080/ejb3.1_rest_base/resources/items
Observe that the two books you added are displayed in XML format.

Figure-6.27

Trouble-shooting: If you are using Safari over MacOS, the response might not be prorperly formated in XML. Please use Firefox instead..

From your browser, go to http://localhost:8080/ejb3.1_rest_base/resources/items/1
Observe that the book item whose ID is 1 is displayed in XML format.

Figure-6.28

(6.3) Use "Curl" utility

0. Install "Curl" utility only if you are running Windows or OpenSolaris. For MacOS or other Linux OS'es, "Curl" utility comes with the OS. Reinstallation of "Curl" might cause some mal-functioning behavior on Mac OS X or other Linux OS'es.

From your browser, go to http://curl.haxx.se/
Download and install it.

1. Retrieve the response in JSON format.
The command to type in the terminal is highlighted in red color, the answer in blue color.

curl -H "Accept:application/json" http://localhost:8080/ejb3.1_rest_base/resources/items
{"book":[{"title":"Life is passion!"},{"title":"2nd book title"}]}

Figure-6.31

2. Retrieve the response in XML format
The command to type in the terminal is highlighted in red color, the answer in blue color.

curl -H "Accept:application/xml" http://localhost:8080/ejb3.1_rest_base/resources/items
<?xml version="1.0" encoding="UTF-8" standalone="yes"?><books><book><title>Life is passion!</title></book><book><title>2nd book title</title></book></books>

Figure-6.32

Solution: The solution is available as "ready to open and build" NetBeans project as ejb3.1_rest under <LAB_UNZIPPED_DIRECTORY>/javaee6_ejb3.1/solutions directory. (You will have to use ejb3.1_rest rather than ejb3.1_rest_base as application context.)

(6.4) Use @ApplicationPath annotation

1. Add ApplicationConfig.java. Note that the value of the Application path is et to resources1.

package mypackage;

@javax.ws.rs.ApplicationPath("resources1")
public class ApplicationConfig extends javax.ws.rs.core.Application {

}

Figure-6.41

2. Build and run the application and add two Book items into Book table.

3. Now observe that you can use resources1 application path.

Figure-6.42

Figure-6.43

Summary

In this exercise, you have learned how to use JAX-RS annotations to expose EJB as RESTful web 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