1. 웹로직 관련 환경설정
1) 서블릿과 JSP를 실행하기 전의 환경설정
1> startWeblogic.cmd 파일 수정
2> 환경변수 설정
3> 서블릿과 jsp를 저장하기 위한 디렉토리
생성
4> web.xml, weblogic.xml 파일 수정
1> startWeblogic.cmd 파일 수정
- 서버설치및 configuration 설정이 완료되었다면
c:\bea\user_projects\domain 디렉토리 아래에
mydomain 디렉토리가 생성된 것을 확인할 수
있다.
- mydomain디렉토리를 보면 여러가지 파일들이
있는데 그 중에서 중요한 파일은
-------------+---------------------------
setEnv.cmd | 도스창에서 작업하기 전에
| 환경 설정을 하기 위한
| 배치 파일
-------------+---------------------------
startWelogic.| mydomain 환경설정을 이용해서
cmd | 웹로직 서버를 실행하기위한
| 배치파일
-------------+---------------------------
config.xml | mydomain에 대한 환경 설정
| 파일
-------------+---------------------------
- 이 중에서 startWeblogic.cmd 파일은 웹로직
서버를 실행하기 위한 배치파일로서,
실행할 때 반영되는 중요한 환경변수 값이
있다.
이 중에서 PRODUCTION_MODE 값을 false로
설정해주자.
[이유: 서블릿이나 jsp가 변경되었을 경우,
웹로직 서버를 재시작할 경우에만
변경된 내용이 적용된다.
따라서 개발시에는 false로 주었다가
개발이 완료된 시점에 true값으로
지정해주는 것이 좋다]
- 위의 파일을 수정했다면 실행중인 서버를 중지시키고
재시작해야 함.
2> 환경변수 설정
- 시작->제어판->시스템->고급->환경변수에서
path, classpath, java_home 을 수정한다.
- path --> C:\bea\jdk142_05\bin;C:\bea\user_projects\domains\mydomain
- classpath : weblogic.jar 파일을 클래스패스에
추가한다.
--> .;C:\bea\weblogic81\server\lib\weblogic.jar
- JAVA_HOME --> C:\bea\jdk142_05
3> 서블릿과 jsp를 저장하기 위한 디렉토리 생성
-C:\bea\user_projects\domains\mydomain\applications\
디렉토리 및에 폴더를 하나 만든다.
폴더 이름은 myroot 로 하자.
- 새로 만든 컨텍스트 myroot의 구조는 아래와 같아야
한다.
../applications/
|
+---myroot
|
+--WEB-INF :반드시 대문자
|
+--classes : 반드시 소문자
+--lib
+--web.xml
+--weblogic.xml
2. JDBC 관련 설정
1) ConnectionPool 설정
2) DataSource 설정
DataSource란?
- 데이터소스는 jdbc2.0 스펙에서 도입되었으며,
데이터 소스는 커넥션 객체를 위한 팩토리(공장)
로 사용되는 것이다.
- 웹로직 서버에서 데이터베이스를 이용한 프로그램
을 하려면, 커넥션 풀과 데이터 소스를 JNDI
(Java Naming and Directory Interface) 네이밍
서비스에 등록한 후 사용해야 한다.
cf> JNDI란?
- Java Naming and Directory Interface
- 명명 및 디렉토리 서비스에 접근하기 위한
API
- 많은 기능을 지원하는 API지만, EJB에선
bind하고 lookup하는 기능만 알면 된다.
- 서버에 JNDI 드라이버만 있으면, 여러
다른 서비스와 함께 사용할 수 있다.
- JNDI의 무분별한 사용은 과부하가 발생할
수 있으므로 사용시 주의해야 함
..JSP의 경우 init()메소드 안에서 lookup
해주는 것이 좋다.
커넥션풀과 데이터소스를 JNDI에 등록한다는 것은
사용자가 나중에 커넥션을 만들 때 데이터 소스
객체를 new 연산자를 이용해서 만드는 것이 아니라,
이미 웹로직 서버에 만들어놓은 객체를 가져다
사용한다는 것을 의미
즉 데이터베이스의 커넥션에 대한 관리를 서버 차원
에서 관리해줌으로써 더 안정적으로 사용할 수 있다.
1) Connection Pool 을 사용할 경우의 장점
- db연결에 대한 아이디, 암호 등을 코드에 넣을
필요가 없고 서버에서 설정만 해주면 된다.
- 커넥션 수에 제한을 걸 수 있어 좀 더 안정적
으로 db를 운용할 수 있다.
- 클라이언트 소스 코드를 수정하지 않고, db시스템
의 정보를 변경할 수 있다.
- 기존 db가 아닌 다른 db를 이용할 경우 커넥션풀을
관리하는 서버 설정 변경만으로 간단히 해결 가능
- 설정 절차
웹로직 콘솔-> 왼쪽 트리에서 Services 선택
-> JDBC-> Connection pools 선택-> 오른 메뉴
에서 설정
3.< EJB의 개요 >///////////////////////////////////
1. 정의 : Enterprise Java Beans의 약자로써 신뢰성이
요구되는 기업용 Component단위로
Application을 제작하기 위해 SUN에서 표준화
시킨 아키텍쳐이다.
2. 목적 : 신뢰성있는 N-tier프로젝트를 쉽고 빠르게
개발하기 위함이다.
3. WAS서버
(1) 개념 : SUN의 J2EE스펙에 맞추어 가동되어지는
서버
(2) 종류 : Weblogic (bea사), Webspear(IBM사),
제우스(tmax사)
cf) 표준서버 : J2EE서버[Sun Java System
Application Server] (sun사)
는 실제 서비스로는 운영되지
못하도록 라이센스가 체결
4. JNDI(Java Naming & Directory Interface)
(1) 개념 : Naming Server를 이용해서 객체를
등록/삭제/검색/갱신 기능을 제공하는 자바의 스펙으로
EJB에서 채택하고 있는 서비스
(2) 사용 방법
<1> JNDI네이밍 서버에 객체 등록하기
<2> 네이밍 서버에 등록된 객체를 찾아 사용하기
<3> 네이밍 서버에 등록된 객체 갱신하기
///////////////////// EJBean //////////////////////////
cf)의문
(1) Why EJB Bean을 사용해야 하는 가?
트랜젝션, 패일오버(Failover), 보안, 스레드 처리를 자동으로 처리해
주기 때문에 개발자가 이런 부분을 신경쓰지 않고
비지니스로직 개발에만 전념할 수 있기
때문에, 신뢰성있는 프로그램을 짧은 기간안에
제작할 수 있다.
(2) How EJB Bean을 개발해야 하는 가?
EJB 명세(Spec/규칙)에 따른 재료(코딩)을
컨테이너에 제공하면 된다.
5. Session Bean
(1)개념 : 비지니스 로직(ex:입금, 출금, 가입, 해지)
을 처리하는 기능을 가진 Bean
(2)종류
<1> 무상태 세션 빈(Stateless Session Bean)
ex) 일반적인 은행직원,
컴퓨터상의 계산/통계 작업
[1] 무상태세션빈 추가 명세
- 홈 인터페이스에서 인자가 없는
create() 포함되어야
- 빈 클래스는 인자가 없는 ejbCreate()
포함해야
- javax.ejb.SessionSynchronizaion
인터페이스를 구현하면 안된다.
[2] 예제
HelloWorld, Guestbook
<2> 상태유지 세션 빈(Stateful Session Bean)
ex) 고객 수와 같은 은행직원, 컴퓨터상의 장바구니
[1] 상태유지세션빈 추가 명세
- 홈 인터페이스의 create()에 인자가 들어 감.
- 빈 클래스의 ejbCreate()와 인자를 매핑시킴.
[2] 예제
Sum
(3)재료
<1> 원격인터페이스
[1] 설명 : 비지니스 메소드을 정의
[2] 명세
- public
- javax.ejb.EJBObject 나 javax.ejb.EJBLocalObject을 상속
- 메소드에서 사용하는 인자나 리턴타입은 RMI/IIOP형식에 맞게
- 메소드는 throws java.rmi.RemoteException을 잡아준다.
- 메소드는 ejb로 시작할 수 없다.
- 메소드는 final이나 abstract 또는 static으로 선언할 수 없다.
ex) HelloWorld.java
<2> 홈인터페이스
[1] 설명 : 세션빈객체를
생성/검색/삭제 메소드를 선언
[2] 명세
- public
- javax.ejb.EJBHome 나 javax.ejb.EJBLocalHome을 상속
- create()의 인자수와 형식은 빈클래스의 ejbCreate()와
인자수/형식이 일치해야 한다
- create()의 인자수와 리턴타입은 RMI/IIOP형식
- create()의 리턴타입은 원격인터페이스 형식
- create()는 throws javax.ejb.CreateException,
java.rmi.RemoteException을 잡아준다.
ex) HelloWorldHome.java
<3> 빈 클래스
[1] 설명 : 비지니스 메소드를 구현하기
위한 재료, 실제 구현은 컨테이너가 한다.
[2] 명세
- public
- javax.ejb.SessionBean 인터페이스를 상속/구현
- abstract 나 final 클래스는 안됨
- 하나 이상의 ejbCreate()포함해야
- 홈인터페이스의 create()와 같은 수의 ejbCreate()를
포함해야하고, 인자의 갯수와 형식도 일치해야
- 기본(default)생성자를 포함하면 좋다.
- finalize()를 포함해서는 안됨
- 원격인터페이스에서 선언한 비지니스메소드를 구현해야
[3] ejbCreate()의 명세
- 항상 ejbCreate()로 시작해야 한다.
- 항상 public으로
- final이나 abstract로 선언할 수 없다.
- 리턴타입은 항상 void 이어야 한다.
- 인자는 RMI/IIOP에 적합한 타입이야 한다.
ex) HelloWorldBean.java
<4> 배치디스크립터(xml) - Bean을 컨테이너에 배치하기위한 배치정보
(4) 순서
<1> 원격인터페이스/홈인터페이스/빈클래스 제작/컴파일
(주의 : 컴파일시엔 Weblogic의 JDK javac.exe를 이용해야 함)
<2> 배치디스크립터 생성 (by WeblogicBuilder)
<3> 아카에브(jar, war 압축)
<4> 배치 (Container내부적으로 rmic --> ejbc)
<5> 클라이언트 프로그램
[1] 웹 클라이언트 프로그램 제작/(war압축)/배치/실행
- helloworld.jsp
- WEB-INF
- lib (helloworld.jar)
- web.wml
- weblogic.wml
[2] 어플리케이션 클라이언트 프로그램 제작/실행
- HelloWorldClient.java
/////////////////////////////////////////
원격인터페이스에서 정의한 비즈니스 메소드{
트랜잭션, 보안
스레드, 자원관리에 대한 처리를 자동으로
해주는 코드, EJB 클래스가 구현한 비즈니스
메소드 호출
}////////////////////////////////////////////
(5) 무상태 세션빈(Stateless Session Bean)의 상태도
+-----------------------+
| 존재하지 않는 상태 |
+-----------------------+
| ▲
newInstance() | |
setSessionContext() | | ejbRemove()
ejbCreate() | |
| |
▼ |
+-----------------------+
|Pool에 준비되어 있는 |------비즈니스 메소드 호출
|상태(준비상태) |<--------------+
+-----------------------+
<1> Client에 의한 Bean의 요청에서 출발
-client가 홈의 create() 메소드를 호출
-세션빈이 없을 경우
|
+---새로운 instance를 생성
+---setSessionContext()
+---ejbCreate() 를 호출
<2> Client의 비즈니스 메소드 호출 종료
- Bean을 Pool로 이둉
<3> Client에 의한 Bean 요청
- Pool에 대기하고 있던 객체가 새로운 클라이언트
요청에 응답한다.
<4> EJB컨테이너는 세션빈을 더이상 사용하지 않는다고 판단되면,
해당 세션빈을 삭제하는데, 삭제하기 전에 ejbRemove()
메소드를 호출한다.
...그렇지만 무상태세션빈의 경우 과부하를 줄이기 위해
create() 메소드나 remove()메소드를 호출했다고 해서
그 때마다 객체를 생성하거나 삭제하는 것이 아니라,
객체 풀에서 세션빈을 저장해놓고 사용하고 있다.
(6) 유상태 세션빈의 상태도
+---------------+ time out
|존재하지 않는 | ◀-------------------+
|상태 | |
+---------------+ |
create(args) | ▲ |
1. newInstance | | Remove 또는 Time out |
2. setSessionContext() | | ejbRemove() |
3. ejbCreate(args) | | |
| | |
▼ |
+---------------+ ejbPassivate() +----------+
|준비상태 |-------------▶ |Passivate |
| |◀------------ | |
+---------------+ ejbActivate() +----------+
| |
Biz method수행
1> client가 홈 인터페이스의 create()메소드를 호출함으로써
유상태 세션빈이 생성된다.
2> 컨테이너는 create()메소드가 호출되면, Bean Instance를 생성
하고, setSessionContext()와 ejbCreate()메소드를 호출한다.
3> EJB Object 의 Remote Reference를 Client에게 반환하며,
메소드 준비상태가 되어 활성화가 된다.
...유상태 세션빈은 특정 client에게 독점적으로 할당되기 때문
에 client가 Biz method를 수행할 때, 무상태 세션빈처럼
Pool로부터 존재하고 있는 빈 인스턴스를 가져오거나,
반환하지 않는다.
4> 만약 Bean instance가 비활성화 상태에 있다면 컨테이너에 의해
활성화 된 후 메소드 호출에 응답한다.
...Passive상태로 가기 전에 ejbPassivate()가 호출되고,
다시 사용자가 호출할 때 자동적으로 ejbActivate()가
호출된다.
※ 유상태 세션빈은 각각의 클라이언트별로 새로운 instance가 생성되기
때문에 클라이언트 수가 증가하면 시스템 성능에 미치는 영향이 크다.
따라서 EJB컨테이너는 LRU(Least Recently Used) 알고리즘에 의해
장시간 요청이 없는 클라이언트의 유상태 세션빈을 2차 저장소에
저장하게 된다. 이와 같은 상태를 비활성화(Passive) 상태라고 하고,
2차 저장소에 저장된 인스턴스에게 클라이언트 요청이 들어오면,
컨테이너는 Bean instance를 다시 메모리에 로드하여 요청을 수행하게
하고, 이와 같은 상태를 Activate 상태라고 한다.
////////////////////////////////////////////////////////////////
(6) Entity Bean
(1)개념 : 영속성(persistence)을 유지해야 할 데이터를 표현하기
위한 Bean 즉, DataBase에 내용을 객체화 시킨 Bean으로
DB table에 데이터를 추가/수정/삭제/조회 작업을 할 수
있는 기능을 가지고 있다.
(2)특징 : 세션빈보다 수명이 길고, 여러 사용자에 의해 공유된다.
(3)장/단점
<1>쓸때 장점:분산트랜젝션을 지원하기때문에 안정성있는
프로그램
<2>쓸때 단점:JDBC를 직접이용하는 것보다 느리다.
(4)종류
<1> CMP(Container-Managed Persistence) Bean
- 개발자가 JDBC코드를 작성하지 않고, 배치 디스크립터의
테이블 관계 설정만으로 컨테이너가 객체를 데이터베이스로
부터 읽거나 저장하는 기능
- SQL대신에 EJB-QL을 이용
(사용이유 : 특정 데이터베이스에 종속되지 않는 SQL작성가능)
ex) Video
<2> BMP(Bean-Managed Persistence) Bean
- 개발자가 직접 JDBC를 이용해서 직접 Bean을 제작
- SQL을 이용
(사용이유 : 특정 데이터베이스에 종속적인 SQL문을
이용하거나 복잡한 SQL문 사용 가능)
ex) Student
(5)재료
<1> 원격 인터페이스
[1] 설명 : 엔티티빈의 필드값을 "변경"(DB table자료 수정)할 때
사용하는 것으로 클라이언트가 사용할 메소드를 정의
[2] 명세
- public
- 빈클래스의 메소드와 매칭(인자의 형식/개수 일치)
- return type은 RMI/IIOP에 적합
- 항상 throws java.rmi.RemoteException 기술
- primary key값을 리턴하는 메소드의 반환타입은
레퍼런스형으로 해준다.
<2> 홈 인터페이스
[1] 설명 : DB table에 새로운 정보를 "추가/삭제/조회"할 때 사용
하는 것으로 그에 해당하는 메소드를 정의해 준다.
cf) 엔티티빈의 홈인터페이스 메소드
- createXXX() : DB table에 insert문을 수행
- remove() : DB table에 delete문을 수행
- finder() : DB table에 select문을 수행
- home() : DB 핸들링 이외의 작업 수행
[2] 명세
1. createXXX()명세
- 반환타입은 반드시 원격인터페이스 형식
- 빈클래스의 ejbCreateXXX()와 인자형식/개수 매칭
- throws javax.rmi.RemoteException,
javax.ejb.CreateException처리할 수 있음.
2. remove()
- home.remove() --> bean.ejbRemove() 호출
- 인자값은 Primary key가 되어야 한다.
3. finder() 명세
- findByPrimaryKey() 반드시 존재해야 하고,
인자는 반드시 레퍼런스타입이어야 한다.
- return type은 원격인터페이스 형식이거나
여러 개일 경우, java.util.Collection,
java.util.Set(중복허용X)형식 반환한다.
- 빈클래스의 ejbFindXXX()와 인자형식/개수 매칭
- throws FinderException, RemoteException등을 기술한다.
4. home() 명세
- 엔티티빈의 데이터와 연관되지 않는 작업을 할 때 사용
- create, remove, find로 시작되서는 안됨
- return type이 RMI/IIOP에 적합한 형식이야 한다.
<3> 빈 클래스
[1] 설명 : 인터페이스와 홈인터페이스에 맞에 Bean을 구현하기
위한 code를 상세기술하는 클래스
[2] 명세
- public abstract 이여야 한다.
- public 기본생성자가 있으면 좋다.(option)
- finalize 메소드를 정의해서는 안된다.
- javax.ejb.EntityBean인터페이스를 상속받아 구현한다.
- 비지니스메소드을 abstract 으로 정의한다.
- abstract get/set 메소드를 정의한다.
- ejbCreateXXX()/ejbPostCreateXXX()/ejbHomeXXX()구현해야..
- CMP에서는 ejbFinder()는 구현하지 않는다.
- ejbSelectXXX()를 abstract 메소드로 구현한다.
1. ejbCreate() 명세
- ejbCreate 접두어로 시작해야 한다.
- public
- final이나 static으로 선언할 수 없다.
- return type은 엔티티빈의 주키 형식이다.
- 홈인터페이스의 createXXX()의 인자형식/갯수가 일치 작성
- 인자형식은 RMI/IIOP형식에 적합해야 한다.
- throws javax.ejb.CreateException을 기술해야 한다.
- CMP2.0의 경우 java.rmi.RemoteException기술하면 안된다.
2. ejbPostCreate() 명세
- ejbCreateXXX()와 같은 수의 ejbPostCreateXXX()가 존재해야
- ejbPostCreate 접두어로 시작해야 한다.
- public
- final이나 static으로 선언할 수 없다.
- return type은 void 이어야 한다.
- ejbCreateXXX()의 인자형식/갯수가 일치 작성
- 인자형식은 RMI/IIOP형식에 적합해야 한다.
- throws javax.ejb.CreateException을 기술해야 한다.
- CMP2.0의 경우 java.rmi.RemoteException기술하면 안된다.
3. ejbHomeXXX() 명세
- 0개 이상 포함할 수 있다.
- ejbHome 접두어로 시작해야 한다.
- public
- static으로 선언할 수 없다.
- 홈인터페이스에서 정의한 home()의 인자형식/갯수가 일치
- java.rmi.RemoteException기술하면 안된다.
4. ejbSelectXXX() 명세
- ejbSelect 접두어로 시작해야 한다.
- public abstract 으로 선언해야 한다.
- throws javax.ejb.FinderException을 기술해야 한다.
- 모든 select()는 배치디스크립터의 query원소(EJB-QL)와
연관관계를 맺어야 한다.
5. 비지니스 메소드의 명세
- ejb 접두어로 시작해서는 안된다.
- public
- final이나 static으로 선언할 수 없다.
- 원격인터페이스에서 정의한 메소드와 일치할 경우에는
인자형식/갯수가 일치해야 한다.
- CMP2.0의 경우 java.rmi.RemoteException기술하면 안된다.
<4> 기본키(Primarykey) 클래스
- RMI/IIOP에 적합한 형식
- hashCode(), equals(Object obj)를 구현해야 한다.
cf) 오라클 데이터베이스 경우
varchar2 --> java.lang.String
number --> java.lang.Integer 또는 java.lang.Double
만약, 하나의 DB table에 두개 이상의 primary key컬럼이
존재할 경우에는 사용자정의주클래스를 작성해야 한다.
(6)순서
<1> DB table 생성
<2> 원격인터페이스, 홈인터페이스, 빈클래스, 기본키클래스 제작/컴파일
<3> 배치디스크립터 파일 생성 (by WeblogicBuilder)
<4> 압축/배치
<5> 클라이언트 프로그램 작성/실행
9. CMP Entity Bean에서 EJB-QL
(1) 개념 : CMP에서 SELECT-SQL를 대치할 수 있는 Query Language
(2) 장점 : 특정 데이터베이스에 비종속적인 Component 제작가능
(3) 단점 : 특정 데이터베이스에 최적화된 SQL문이나 복잡한 SELECT문에
적용하기가 어렵다.
(4) 구성
<1> SELECT절 : 선택할 객체의 형식이나 값을 지정
<2> FROM절 : 도메인 이름(엔티티빈 이름) 지정
<3> WHERE절 : 조건을 지정
cf)
1. WHERE절의 연산자
- 산술 : +, -, *, /
- 비교 : =, >, >=, <, <=, <>
- 논리 : NOT, AND, OR
- BETWEEN : BETWEEN 값1 AND 값2
- IN : IN(...)
- LIKE : %, _
- NULL비교 : IS NULL
- EMPTY비교 : IS EMPTY
- MEMBER : MEMBER OF
2. 인자값
- ?1, ?2, ?3
(5) EJB-QL의 예
<1> SELECT OBJECT(o) FROM STUDENT AS o
<2> SELECT OBJECT(o) FROM STUDENT o WHERE o.grade >(?1*5)
<3> SELECT OBJECT(o) FROM STUDENT o WHERE o.grade<80
<4> SELECT OBJECT(o) FROM STUDENT o WHERE
o.grade>=70 AND o.grade<80
<5> SELECT OBJECT(o) FROM STUDENT o WHERE
o.grade BETWEEN 70 AND 80
<6> SELECT OBJECT(o) FROM STUDENT o WHERE
o.grade IN(80,90,95)
<7> SELECT o.grade FROM STUDENT o WHERE o.name LIKE '김%'
<8> SELECT OBJECT(o) FROM STUDENT o WHERE o.name IS NULL
<9> SELECT OBJECT(o) FROM STUDENT o WHERE o.name IS EMPTY
<10> SELECT OBJECT(o) FROM STUDENT o TEACHER t WHERE
o MEMBER OF t.studentid
-> 선생Table이 가지고 있는 필드 중 studentid값을 포함한
학생row들을 찾아라
ex) StudentCMP
(ear로 제작/실행
-> http://211.169.219.10:7001/webClient_studentcmp.war/)
//////////////////////////////////////
(6) EntityBean의 상태도
+---------------+
|존재하지 않는 |
|상태 |
+---------------+
| ▲ ejbLoad()호출
1. newInstance | | unSetEntityContext() ejbStore()호출
2. setEntityContext() | | +---+
| | | |
| | ejbCreate() | |
▼ ejbPostCreate() | ▼
+---------------+ ejbActivate() +----------+
|비활성화 상태 |-------------▶ | 준비상태 |
|Passivate(Pool)|◀------------- | Ready |
+---------------+ ejbPassivate() +----------+
ejbRemove()
<1> EJB Container는 Entity Bean을 만든 후 setEntityContext()
를 통해 EntityContext를 Entity Bean에 할당한다.
그리고 엔티티빈은 Pool에 저장된다.
이 때 모든 Entity Bean은 식별성을 가지지 않는다.
<2> 클라이언트가 Entity Bean의 finder 메소드나 create 메소드
를 호출하여 Entity Bean을 Ready(준비) 상태로 만들고,
이 때 ejbCreate(), ejbPostCreate() 또는 ejbFindXXX()
메소드가 호출된다. 이때 준비상태의 빈들은 식별성(Primary
Key객체)을 갖게된다.
<3> 클라이언트는 엔티티빈의 데이터 관련 Biz 메소드를 호출하고,
컨테이너는 이 Entity Bean의 상태를 DB에 저장하기 위해
ejbLoad()와 ejbStore()를 주기적으로 호출한다.
<4> 컨테이너가 엔티티빈을 Pool로 Passivate(비활성화) 시킬
때 ejbPassivate()를 호출하고, 반대로 Activate(활성화)
되면 ejbActivate()를 호출한다.
<5> Pool에 있는 Entity Bean이 삭제(remove)될 경우, DB에 해당
하는 Row가 삭제되며, Entity Bean 의 unsetEntityContext()
가 호출된다.
(7) BMP 방식의 메소드와 기능
--------------------+--------------------------------------
ejbCreateXXX() |테이블에 새로운 Row를 추가. insert문 수행
--------------------+--------------------------------------
ejbFindByPrimaryKey(|pk키 클래스를 인자로 받아 찾은 결과가
|있을 경우 pk키 클래스를 그대로 반환
--------------------+--------------------------------------
ejbFindByXXX() | 홈인터페이스에서 정의한 사용자 정의
| find 메소드와 매핑되는 메소드
| pk클래스나 여러 개의 pk클래스 정보를
| 포함하는 java.util.Collection을 반환
--------------------+--------------------------------------
ejbLoad() | 테이블 내용으로 엔티티 빈을 동기화할
| 때 사용. 테이블에서 pk 필드 값으로
| select 한후, select결과로 필드값을
| 읽어온 값으로 수정한다.
--------------------+--------------------------------------
ejbStore() | 엔티티빈의 내용이 변경될 경우, 엔티티
| 빈에 포함된 필드 값으로 테이블 내용을
| 갱신한다. 이 때 pk 키값을 제외한 나머지
| 값으로 테이블 내용을 갱신한다.
| update문 사용
--------------------+--------------------------------------
ejbRemove() | pk필드에 해당하는 row를 테이블에서 삭제
| delete문을 사용
--------------------+--------------------------------------
10. Session Bean과 Entity Bean의 연동
(1) 연동 구조
웹브라우져 <---> JSP <---> SessionBean <---> EntityBean <---> DB
(2) EJB에서 DB 핸들링 방법
<1> SessionBean에서 직접 JDBC를 이용
<2> BMP EntityBean에서 JDBC를 이용
<3> CMP EntityBean을 이용(EJB-SQL)
(3) 순서
<1> Local Entity Bean을 제작/배치
- 먼저 Remote Entity Bean 작성 후
- Remote Entity Bean을 이용하는 Client프로그램을 제작해서
- 그 Client프로그램으로 올바르게 작성되었는 지 테스팅 후
- Local Entity Bean으로 바꾸어 준다.
<2> Session Bean 제작 --StudentDAO를 수정
-원격인터페이스
-홈인터페이스
-StudentDAOBean implements SessionBean
<3> Session Bean을 이용하는 Client 프로그램 제작/배치
ex) 게시판 (평가)
/////////////////////////////////////////////////////////////////
11. 애플리케이션 모듈 디플로이 하기
(1) 순서
1> ejb모듈을 jar로 묶는다.
2> web모듈을 war로 묶는다.
3> jar와 war를 ear로 묶는다.
4> 웹로직 빌더로 ear파일을 선택한 후 OPEN
->ear파일에서 mystudent.war파일을 선택
-> Context Path 탭을 선택하여 컨텍스트명을 입력
-> 저장
5> htt://localhost:7001/console 에서
Deployments->Application선택->mystudent.ear을 찾아서
디플로이->Success나오면 웹브라우저를 열어서
http://localhost:7001/컨텍스트명/bmp/insert.jsp
하여 테스트...
1> EJB Module
- Remote
- Home
- Bean
- Meta-INF
|-ejb-jar.xml
|-weblogic-ejb-jar.xml
|_weblogic-cmp-rdbms-jar.xml[CMP일 경우]
...... jar로 묶는다.
ex)student.jar
2> Web Module
- myroot
+--WEB-INF
| +--classes
| +--lib
| +--src
| +web.xml
| +weblogic.xml
|
|---JSP파일
+---HTML 파일
+---이미지 파일...
...........war 로 묶는다.
ex) myroot.war
확장자는 war지만 실질적으로는 jar명령어로 묶어준다.
ex)명령어
jar cvf myroot.war *.*
<주의> myroot디렉토리 아래서 war파일을 만들어야 한다.
myroot 디렉토리를 포함해서 압축할 경우
제대로 배포하거나 설치할 수 없다.
3> Application Module
war파일과 jar파일을 ear파일로 묶어서...
명령어 역시->
도스창> jar cvf student.ear student.jar myroot.war
-웹로직에서 Deploy시 Application Module로 디플로이한다.
//////////////////////////////////////////////////////////////////
12. 톰켓과 웹로직의 연동
(1) 사용 이유 : html이나 단순한 JSP/sevlet페이지는
tomcat으로 서비스 하는 것이 더 효율적이기때문에
(2) 순서
<1> tomcat서버를 설치한다.
<2> 웹로직 C:\SOO\EJB\bea\weblogic81\server\lib 하위의
ojdbc14.jar와 weblogic.jar를 tomcat의 자동클래스패스
디렉토리인 C:\SOO\JSP\Tomcat5.5\common\lib 하위에 복사한다.
<3> tomcat 종료 후 다시 켠다.
<4> 테스트용 jsp를 작성한다.
*주의 - 다른 서버에 있는 객체를 호출하므로 ctx를 다음과 같이*
java.util.Properties h = new java.util.Properties();
h.put(javax.naming.Context.INITIAL_CONTEXT_FACTORY,
"weblogic.jndi.WLInitialContextFactory");
h.put(javax.naming.Context.PROVIDER_URL, "t3://localhost:7001");
javax.naming.Context ctx = new javax.naming.InitialContext(h);
<5> jsp페이지를 톰켓의 ROOT하위에 넣고, 관련 ejb component를
C:\SOO\JSP\Tomcat5.5\webapps\ROOT\WEB-INF\lib 하위에 넣고,
사용된 java beans도 컴파일하여 classes하위에 넣고,
tomcat을 재부팅 후 브라우져로 호출한다.
(3) 예
ROOT/ 하위의 board~와 hello.jsp
13 JMS (Java Message Service)
(1) 개념 : 자바의 비동기 메세지 전송기술로써 EJB에 채택하고 있는
서비스 ( 시스템간의 메세지 전송 )
cf) 비동기 ex) 메일 , 동기 ex) 전화
(2) MOM(Message Oriendted Middleware) 서버 [ JSM서버 ]
ex) SonicMQ (by Progress사), MQSeries (by IBM), MSMQ (by MS사)
(3) 전송(서비스) 방식
<1> Queue방식[P2P] => ( 1 : 1 = Sender : Receiver )
Sender와 Receiver가 같은 시간에 가동되어 있지 않아도
100% 메세지가 전달된다.
<2> Topic방식[pub/sub] => ( 1 : 다 = publisher : subscriber)
publisher가 메세지를 전송하는 시간에 subscriber가 가동되어
시스템에만 메세지가 전달된다.
(4) JMS의 주요 용어
<1> 메세지(Message) - 전송데이터
[1] 구성 : header , property, body
[2] 종류 : 문자열, 스트림, 기본형 데이터, Object형 데이터
[3] 특징 : 메세지 객체는 재사용이 가능
<2> Store(저장소)
- 메세지를 주고 받을 때 사용되는 MOM서버의 메세지 저장공간
<3> Destination(목적지) - 메세지의 도착지
<4> Connection - 메세지를 전송하기 위한 연결객체(길)
<5> ConnectionFactory
- 메세지 전송시 필요한 연결객체를 만드는 클래스
<6> Session - 하나의 메세지에 부여되는 메세지ID
<7> 메세지 생산자(Message Producer) - QueueSender / TopicPublisher
<8> 메세지 소비자(Message Consumer)- QueueReceiver / TopicSubscriber
(5) JMS 프로그램 순서
<1> Weblogic의 Admin툴에서 EJB서버내의 JMS서버 셋팅
( Store생성/저장폴더생성 --> Server생성 --> Destination생성 )
<2> 전송프로그램을 작성
< Queue 객체 생성 순서 - ex) MessageQueueSender.java >
(1) QueueConnectionFactory
(2) QueueConnection
(3) QueueSession
(4) Queue
(5) QueueSender
(6) Message
cf) qSender.send(tMsg); qCon.close();
< Topic 객체 생성 순서 - ex) MessageTopicPublisher.java >
(1) TopicConnectionFactory
(2) TopicConnection
(3) TopicSession
(4) Topic
(5) TopicPublisher
(6) Msg
cf) tPublisher.publish(tMsg); tCon.close();
<3> 전송프로그램 실행
저장소(soojmsfilestore)에 메세지가 저장되어있는 것을 확인
<4> 저장소에 메세지를 읽어 출력하는 출력프로그램작성
< Queue 객체 생성 순서 - ex) MessageQueueReceiver.java >
(1) QueueConnectionFactory
(2) QueueConnection
(3) QueueSession
(4) Queue //여기까지 동일
(5) QueueReceiver
cf) qCon.start(); //중요!!
Message msg = qReceiver.receive();
< Topic 객체 생성 순서 - ex) MessageTopicSubscriber.java >
(1) TopicConnectionFactory
(2) TopicConnection
(3) TopicSession
(4) Topic //여기까지 동일
(5) TopicSubscriber
cf) tSubscriber.setMessageListener();
tCon.start(); tCon.close();
<5> 출력프로그램 실행
--> Queue는 한번 전송한 Message는 MOM서버가 꺼지더라도
MOM서버가 다시 켜질 때 store저장되어있는 메세지를
보내주기 때문에 신뢰성이 있다.
14. Message-driven Bean
(1)개념 : JMS의 메세지 처리기능을
EJB Container가 EJB Component로 제작한 것
(2)장점
<1> 트랜젝션/보안/동시성 문제를 해결할 수 있는 Component
(즉, 안정적인 서비스 가능)
<2> 병렬적으로 메세지 처리가 가능
(즉, 동시에 서비가능한 여러개의 메세지 드리븐빈을 생성가능)
<3> EJB서버 내부에 드리븐빈이 있기때문에 여러 관리도구를
이용하여 효과적으로 관리
(3)특징 : 드리븐의 메소드를 사용자가 직접호출해서 사용하지 않기
때문에 홈인터페이스와 원격인터페이스가 없다.
(4)사용의 대표적인 예
<1> 비동기적으로 뉴스 제공자로부터 뉴스를 받아들여 DB에 저장
<2> 많은 수의 클라이언트가 한꺼번에 메세지를 보낼 때
클라이언트가 보내는 메세지를 Queue에 쌓아놓고 하나씩
안정적으로 처리하고 싶을 경우
(5)메세지 드리븐 빈의 명세
<1> javax.ejb.MessageDrivenBean을 구현해야 한다.
<2> javax.jms.MessageListener인터페이스를 구현해야 한다.
<3> public 선언해야 한다.
<4> final 이나 abstract 로 선언할 수 없다.
<5> 기본생성자를 포함하면 좋다.
<6> finalize 메소드를 포함하면 안 된다.
<7> ejbCreate()를 포함해야 한다.
** 포함 메소드의 세부 명세 **
<8> ejbCreate() / onMessage() / ejbRemove() 메소드
- public 으로 선언해야 한다.
- final 이나 abstract 로 할 수 없다.
- 반환형식은 void 이여야 한다.
- onMessage(Message message)를 제외하고, 인자는 없어야 한다.
- throws 절에 예외를 기술할 수 없다.
cf)onMessage()는 javax.jms.MessageListener인터페이스의 메소드
(6) 라이프 사이클
<1> 존재하지않는 상태 ---------------------------------> 준비상태
[ new Instance() / setMessageDrivenContext() / ejbCreate() ]
<2> 준비상태 ---------------------------------> 존재하지않는 상태
[ ejbRemove() ]
(7) 순서
<1> 메세지를 저장할 news 테이블을 DB에 생성
<2> news 테이블에 대한 엔티티빈을 작성
<3> EJB서버에 메세지 목적지를 생성
<4> 메세지드리븐을 작성/컴파일
<5> 배치 디스크립터 파일 작성
<6> 엔티티빈/메세지 드리븐빈/배치디스크립터를 jar로 압축 및 배치
<7> 클라이언트 프로그램 작성/실행
<8> news 테이블에 저장된 메세지를 확인
ex) News ( NewsMessageBean.java ) [출처] EJB개요|작성자 almighty80