JCFWiKi - 새 문서 [ko]

JCF edu 200905

Kyoung94 — Thu, 07 May 2009 01:11:53 GMT

바꾼내용 간추리기: /* 5일차 */

{{팁|
*산출물 : JCF 2009년 5월 정기교육 자료
* 최초작성일 : 2009/05/07
* 최종작성일 : 2009/05/11
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
{{경고|이 곳은 2009년 5월에 진행되는 JCF 정기교육에 대한 강의자료가 있는 방입니다. }}
[[Category:JCF 정기교육]]

=1일차=
*[[JCF framework|JCF프레임워크 소개]]
*개인 개발환경 설치
**[http://152.149.47.87/jcf-starterkit-1.1.0.zip 스타트 킷 다운받기]
{{주의사항|jcf 스타트킷 사용하지 않을 경우 아래의 가이드를 참조}}
**[[교육용 개발환경 (개인)|개인 개발환경 설치하기]]
**[[Eclipse Plugin Management|Eclipse Plugin 사용하기]]
**[[JCF IssueTracker through Mylyn| Mylyn를 통한 JCF IssueTracker 사용가이드]]
*JCF 맛보기
**[[QuickStart:Struts2SpringIBatis|QuickStart로 JCF sample받아오기]]
**[[QuickStart Eclipse Proejct|QuickStart로 받아온 샘플 예제를 Eclipse에 돌려보기]]
** [[Media:jcf_arch.pdf|JCF 아키텍쳐]]
*형상관리시스템
**[[Subversion using|Subversion 사용가이드]]
*코딩 표준과 명명 표준
**[[Naming Convention | Naming Convention ]]
*1일차 리뷰

=2일차=
*USER CRUD 개발 Hands on Lab
**[[EDU USER DEV|사용자 CRUD 개발]]
**[[진행1일]]
* Struts2
**[[struts basic|struts2 이해하기]]
**[[Struts2 Configuration|Struts2 설정하기(Configuration)]]
**[[Struts2 Taglibary]]
*Spring 심화과정
**[[스프링 핵심 개념 - Ioc|Spring IOC]]
**[[스프링 핵심 개념 - Aop|Spring AOP]]
**[[트랜잭션|트랜잭션 처리]]
*2일차 리뷰

=3일차=
*IBatis Framework
**[[IBatis|IBatis Framework 소개]]
**[[iBatis Cache|iBatis Cache 적용하기]]
**[[iBatis Dynamic Query|iBatis Dynamic Query 사용하기]]
*[공통]코드연동
**[[사용자주소 코드처리|코드연동하기]]
**[[블로그 분류 코드 TDD 개발하기]]
*[[JCF3_id|[공통]채번 관리]]
*3일차 리뷰
* [[Media:조회하기.word|조회하기txt]]

=4일차=
*[IDE]이클립스 활용법
**[[Eclipse debugging guide|Eclipse Debugging하기]]
**[[10_Easy_Ways_of_Navigation_in_Eclipse|이클립스 단축키]]
**[[Eclipsetemplates|이클립트 템플릿]]
*[공통]검색
**[[Search Module|검색기능 구현하기]]
*[공통]로깅
**[[로깅|log4j를 이용한 로깅처리하기]]
*[공통]에러처리
**[[에러처리|예외처리하기]]
*[공통]파일처리
**[[File attaching|파일 처리하기]]
*[공통]페이징처리
**[[paging| 페이징 처리하기]]
*4일차 리뷰

=5일차=
*[[Spring_security|Spring_security 개요]]
* [[Spring security2.0]]
* [[Spring security 2.0 따라하기]]
*통합개발환경(ALM)
*5일차 리뷰
*테스트 및 설문

=BLOG WORKSHOP=
*[[Table Schema]]

=POM=
*[[POM]]

=개발환경=
{{경고|개발환경은 사내 인트라넷에서 교육 중에 개발 및 테스트를 위해 사용할 수 있습니다. }}

*개발DB
**URL:
**ID:
**PW:

*CI서버
**URL:
**계정:

*SVN서버
**URL: http://152.149.47.86/edu/trunk/edu001~edu010
**계정(id/pw): edu001 ~edu010 (pw 동일)

Spring EJB Integration

Kyoung94 — Fri, 17 Apr 2009 09:05:08 GMT

바꾼내용 간추리기: /* Spring의 applicationContext에 SLSB 설정하기 */

{{팁|
*산출물 : Spring 2.5와 EJB 2.0 연동
*작성자: 서경진
*작성일 : 2009/04/17
*버전 : 1.0
*개정이력 :
'''Copyright © 2007 Daewoo Information Systems Co., Ltd.'''
}}

== EJB 2.0 Maven 프로젝트 생성하기 ==

=== EJB 구현을 위한 기본 라이브러리 (아키텍트용, 개발자 단순참고) ===
* m2eclipse 플러그인을 적용한 메이븐 아키타입으로 EJB 프로젝트를 재구성하였다.
<pre>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.0.2</version>
<configuration>
<source>1.4</source>
<target>1.4</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-ejb-plugin</artifactId>
<version>2.1</version>
<configuration>
<ejbVersion>2.0</ejbVersion>
<generateClient>true</generateClient>
</configuration>
</plugin>
</plugins>
</pre>
* 프로젝트에 있는 pom.xml에 정의하여 라이브러리와 빌드를 관리한다.
* 해당 라이브러리는 JCF 공용 메이븐 저장소(http://repo.expertvill.net/nexus/)에서 조회하여 다운로드 받을 수 있다.
* Stateless Session Beans 라이브러리
[[그림:SessionBeansLibrary.JPG|700px|center|thumb|Stateless Session Beans 필수 라이브러리]]
여기에서 EAdjustAnnounce.jar, EAdjustLand.jar, EAdjustCatalog.jar는 세션빈이 사용하는 각 엔티티빈을 패키징한 라이브러리이다. 세션빈의 구동을 위해 엔티티빈을 패키징한 라이브러리가 필요하다.
* Entity Beans 라이브러리
[[그림:EAdjustCatalogLibrary.JPG|600px|center|thumb|EAdjustCatalog Entity Beans 필수 라이브러리]]

[[그림:EAdjustLandLibrary.JPG|700px|center|thumb|EAdjustLand Entity Beans 필수 라이브러리]]

=== Maven 기반 EJB 프로젝트 구성하기 (아키텍트용, 개발자 단순참고) ===

* JCF 스타트킷을 사용하여 메이븐 기반의 개발환경을 구성한다.
* SAdjust 세션빈과 EAdjustAnnounce, EAdjustCatalog, EAdjustLand 엔티티빈 소스 샘플을 참고하여 프로젝트를 구성하고 JCF와 EJB 연동을 개발한다.

== Stateless Session Beans (SLSBs) 개발 및 빌드 ==

=== SLSB 개발 ===
* 메이븐 기반 EJB 프로젝트에서 기존 소스 코드 임포트

=== SLSB 빌드 ===
* 메이븐 빌드 (maven-ejb-plugin 적용)
* maven ejb:ejb 실행

=== Spring의 applicationContext에 SLSB 설정하기 ===
* 원격시스템 (Remote System)에서 웹로직서버에 디플로이된 SLSB를 사용하기 위해 다음과 같이 applicationContext.xml에 설정한다.

<code lang=xml>
<jee:remote-slsb id="ejbRemoteAdjust" jndi-name="ejb/mp.SAdjustHome"
business-interface="onbid.ejb.adjust.sadjust.SAdjust"
cache-home="true"
lookup-home-on-startup="true"
resource-ref="true"
home-interface="onbid.ejb.adjust.sadjust.SAdjustHome"
refresh-home-on-connect-failure="true">
<jee:environment>
java.naming.factory.initial=weblogic.jndi.WLInitialContextFactory
java.naming.provider.url=t3://대상서버 IP주소:포트
java.naming.security.principal=웹로직서버 사용자ID
java.naming.security.credentials=패스워드
</jee:environment>
</jee:remote-slsb>
</code>

* 로컬에서 웹로직서버에 디플로이된 SLSB를 사용하기 위해 다음과 같이 applicationContext.xml에 설정한다.

<code lang=xml>
<jee:local-slsb id="ejbSAdjustHome" jndi-name="ejb/mp.SAdjustHome"
business-interface="onbid.ejb.adjust.sadjust.SAdjustLocal"
cache-home="true"
lookup-home-on-startup="true"
resource-ref="true"
expose-access-context="false" />

</code>

== Entity Beans (CMP) 개발 및 빌드 ==

=== maven-ejb-plugin으로 EJB 빌드하기 ===

== EJB 2.0 모듈 웹로직 8.1 서버에 디플로이하기 ==

* startWebLogic.cmd 스크립트 수정하기

== Spring 2.5 기반의 테스트케이스로 EJB 테스트하기 ==

RoleGuide

Alsdkzz — Fri, 19 Sep 2008 08:09:43 GMT

바꾼내용 간추리기:

{{팁|
*산출물 : JCF3.0 공통모듈 -권한관리 사용가이드
*작성자:김민아
*작성일 : 2008/09/19
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
{{정보|
*권한관리는 시스템에서 쓰이는 권한에 대해서 관리하는 화면이다.}}
*메뉴의 공통모듈>권한관리를 클릭하면 다음과 같은 화면이 나타난다.
*시스템 코드는 코드관리에서 등록한 데이터로 권한이 많을 경우 시스템 별로 조회할 수 있다.
*입력과 수정은 그리드 내에서 이루어지고, 삭제는 왼쪽의 checkbox를 선택한 후 행삭제 버튼을 누른다. 수정과 입력, 삭제가 다 이루어졌으면 저장버튼 클릭으로 데이터가 최종 반영된다.
[[그림:RoleMng.jpg|800px]]

*권한관리에서 반영된 데이터는 밑에와 같이 사용자 추가/수정부분과 메뉴관리에서 선택할 수 있도록 보여진다.
*사용자 추가/삭제에서의 권한은 사용자에 권한을 지정하는 것이고,
*메뉴관리에서의 권한은 해당메뉴에 접근 가능한 권한을 지정하는 것이다.
[[그림:Roleex1.jpg|500px]][[그림:Roleex2.jpg|500px]]

CommonModule CodeUserGuide ext-js

Alsdkzz — Thu, 18 Sep 2008 09:45:17 GMT

바꾼내용 간추리기:

{{팁|
*산출물 : JCF3.0 공통모듈- 코드모듈 사용가이드 -ext-js를 사용 할 경우
*작성자:김민아
*작성일 : 2008/09/17
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}

*combox박스가 두개 이상이여서 상위코드 클릭 시 해당되는 하위코드가 바인딩되어야하는 경우 ext-js를 사용하였다.
*예) 코드관리에서 상위코드 가져오기

= code.js파일=
*findCodes()
<code lang="javescript">
Ext.onReady(function(){
findCodes();
}
</code>
**화면이 로딩될 때 코드값을 가져오는 메소드(findCodes)를 onReady메소드 안에 넣는다.
<code lang="javescript">
/*
* 로딩시 combox 값 가져오기
*/
function findCodes() {
var params = '{'
+ 'parentId:\"' + "0" + '\",'
+ '}'
Ext.Ajax.request({
url: '/jcf-common/comCode/findComCodeList.action',
jsonData: params,
headers:{
'Content-Type' : 'application/json'
},
success: function( r, o ) {
try {
cbUpwCodeStore.loadData(Ext.decode(r.responseText));
cbwCodeStore.loadData(Ext.decode(r.responseText));
} catch(e) {
}
},
failure: function( r, o ) {
alert("find Error! "+r.responseText);
}
})
}
</code>
**parentId가 0인 코드값을 가져오기 위해서 위에 같이 params을 지정한다.(Action참고)
**Ext.Ajax.request라는 메소드 사용하여 서버에 request를 보낼 url 과 위에서 정의한 params을 jsonData에 넣는다.
**서버로부터 값을 제대로 받아왔는지 확인하기 위해 success 와 failure을 지정해주고 success function 안에는 try /catch 문을 선언한다.
**alert(r.responseText)을 통해 받아온 JSON 데이터값을 alert창으로 확인한다.
**cbUpwCodeStore.loadData, cbwCodeStore.loadData 로 JsonStore 에 받아온 데이터를 담는다.
*JsonStore
<code lang="javescript">
var Code = Ext.data.Record.create([
{name: 'id', type: 'string'},
{name: 'name', type: 'string'}
]);

//상의 업무 시스템 Store 정의
var cbUpwCodeStore = new Ext.data.JsonStore({
root:'upwCodeList',
fields: [ 'id', 'name']
});

// 업무 시스템 Store 정의
var cbwCodeStore = new Ext.data.JsonStore({
root:'workCodeList',
fields: [ 'id', 'name']
});

</code>
**cbUpwCodeStore과 cbwCodeStore 는 findCodes에서 받아온 데이터를 저장하기 위한 JsonStore 이다.
**New Ext.data.JsonStore 로 cbwCodeStore 라는 JsonStore 를 생성한다. root에는 action의 OutChannel에서 지정한 값을 fields에는 받은 값의 각 Object들을 넣는다.
*ComboBox 생성
<code lang="javescript">
// 상위업무시스템 combox
cbUpwCode = new Ext.form.ComboBox({
store: cbUpwCodeStore,
valueField: 'id',
displayField:'name',
typeAhead: true,
mode: 'local',
triggerAction: 'all',
editable:false,
emptyText:'시스템 코드를 선택하세요',
selectOnFocus:true,
listeners:{select:{fn:function(combo, value) {
var comboNext = Ext.getCmp('cbUpwCode');
//클릭한 시스템코드에 따라 상위업무코드 필터링
cbwCodeStore.filter('parentId', this.getValue());
}}},
applyTo: 'upwCombo'
});

var cbworkCodeId;
// 상위업무코드 combox
cbworkCode = new Ext.form.ComboBox({
store: cbwCodeStore,
valueField: 'id',
displayField:'name',
typeAhead: true,
editable:false,
mode: 'local',
triggerAction: 'all',
emptyText:'업무를 선택하세요',
selectOnFocus:true,
listeners:{select:{fn:function(combo, value) {
cbworkCodeId=this.getValue();
}}},
applyTo: 'workCombo'
});

</code>
**new Ext.form.ComboBox 로 cbUpwCode 와 cbworkCode 라는 ComboBox를 생성한다
**Preperty 설명)
*** Store: 바인딩할 store 지정,
*** displayField : 화면에 보여지는 text 값
*** valueField: 실제 저장되는 value 값
*** Editable: combox 수정여부(ombox에서 선택하기 않고 직접입력이 가능하도록 설정하고 싶다면 true로 지정)
*** Mode: local data를 로당할지 server에서 data를 가져와 로딩할지 여부 (local은 local data를 로드한다는 뜻이고 remote는 server로부터 data를 로드한다는 뜻이다)
*** triggerAction: 이미 선택된 값 외의 코드값도 선택할 수 있게할지 여부( triggerAction을 all이라고 지정하지 않는다면 이미 값이 있거나, 한번 선택된 코드값은 수정할 수 없음)
*** emptyText : combox에 값이 바인딩이 되지 않았을 때 기본으로 보여지는 텍스트
*** selectOnFocus: combox를 클릭했을 때, combox에 바인딩된 데이터를 Focus 할지 여부이다. (True로 설정해놓았으면, combox를 클릭했을 때, combox에 바인딩된 데이터가 파란네모박스 안에 흰글씨로 Focus 됨)
***listeners 클릭시 선택된 데이터를 읽어서 다른곳에서 참조할 때 사용
*** applyTo: 실제 바인딩 할 jsp파일의 id
=CodeAction.java=
<code lang="java">
public String findComCodeList(){

private CodeService codeService;
private Code code;
private List upwCodeList;
private List workCodeList;
private List codeDivList;
private List codeList;

Map searchMap = (Map) InChannel.getVariables();
upwCodeList=codeService.findCodes(searchMap);
workCodeList=new ArrayList();
for (int i = 0; i < upwCodeList.size(); i++) {
System.out.println(upwCodeList.size());
code = (Code) upwCodeList.get(i);
System.out.println((code.getId()));
List tmpcodeList =codeService.findCodes(code.getId());
if (null == tmpcodeList)
continue;
workCodeList.addAll(tmpcodeList);
}
OutChannel.setDataSet("upwCodeList", upwCodeList);
OutChannel.setDataSet("workCodeList", workCodeList);

OutChannel.send();

return null;
}
</code>
*InChannel.getVariables을 통해 js파일에서 param으로 넘긴 값을 Map 유형의 searchMap에 받아온다. (parentId는 key, 0은 value로 받아옴)
*OutChannel.setDataSet을 통해 js파일에 JsonData 유형으로 변환해서 보낸다.
**여기서 "upwCodeList"은 js파일에서 선언한 JsonStore의 root와 일치되어야하고 upwCodeList는 위에서 선언한 값이다.

CommonModule CodeUserGuide struts2

Alsdkzz — Thu, 18 Sep 2008 09:41:30 GMT

바꾼내용 간추리기:

{{팁|
*산출물 : JCF3.0 공통모듈- 코드모듈 사용가이드 -struts기반의 표준웹일 경우
*작성자:김민아
*작성일 : 2008/09/17
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
*에)사용자 조회화면에서 직급코드가져오기
=UserAction=
<code lang="java">
package jcf.biz.user.action;
..
public class UserAction extends BaseAction {
..
private List usrPosCode;
... private CodeService codeService;
/**
* @return
* addUser창으로 이동
*/
public String addUser(){

return SUCCESS;
}
..
public List getUsrPosCode() {
usrPosCode=codeService.findCodes("4");
return usrPosCode;
}

}
</code>
*CodeService codeService : 코드값을 가져오기 위한 서비스 프라퍼티.
*List usrPosCode: 직급 코드값 리스트를 저장하기 위한 프라퍼티.
*addUser(..) 액션 메소드에서는 사용자 등록 화면으로 가기전에 getUsrPosCode를 호출하여 codeService를 통해서 직급 코드 값을 가져와 usrPosCode에 담는다.(결과 페이지에서는 여기서 추가된 usrPosCode를 JSP에서 참조하여 코드 값을 보여주게 된다.)
* getUsrPosCode: codeService의 findCodes 메소드를 직급코드의 id값을 넘겨 호출하여 직급데이터를 가져온다.
=editUsr.jsp=
<code lang="javascript">
<td class="Mnns_label" nowrap width='10%'>직급</td>
<td class="Mbox_bg">
<s:select name='user.usrPos' list="usrPosCode" listKey="id" listValue="name" />
</code>
*<s:select /> 태그를 사용하여 액션 클래스의 코드 리스트(usrPosCod)를 보여주고, 선택값은 액션의 user 모델 객체의 usrPos' 프라퍼티(user.usrPos)로 저장되도록 설정한다

MenuGuide

Alsdkzz — Thu, 18 Sep 2008 07:00:36 GMT

바꾼내용 간추리기:

{{팁|
*산출물 : JCF3.0 공통모듈 -메뉴관리 사용가이드
*작성자:김민아
*작성일 : 2008/09/01
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
{{정보|
*메뉴관리는 로그인 시 제일 상위에 있는 메뉴트리에 대해서 관리하는 화면이다.
}}
*메뉴관리는 상위의 '''메뉴카테고리 추가''', '''메뉴추가''', '''메뉴삭제'''로 추가.삭제 후 오른쪽 저장 버튼 클릭으로 최종 반영된다.
* 메뉴괸리는 다른 모듈과 달리 수정이나 추가 시 전체 데이터가 한 번 삭제되었다가 다시 입력되는 것이므로 만약을 대비하여 작업 전에 데이터를 백업해놓는 것이 좋다.

*메뉴카테고리에는 메뉴이름만 입력하고,
*메뉴에는 메뉴명, 화면 소스경로(상대경로로 지정), 그리고 그 메뉴에 접근가능한 권한들을 지정한다.
*만약에 여기서 접근권한을 지정하기 않은 권한을 가진 사용자가 로그인했다면 그 메뉴는 트리에 보이지 않을 것이다.

[[그림:menuMng.jpg|900px]]

UsrGuide

Alsdkzz — Thu, 18 Sep 2008 05:19:49 GMT

바꾼내용 간추리기:

{{팁|
*산출물 : JCF3.0 공통모듈 -사용자관리 사용가이드
*작성자:김민아
*작성일 : 2008/09/01
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
{{정보|
*사용자관리는 시스템을 사용하는 사용자들에 대해 관리하는 모듈이다.
*공통모듈의 사용자 관리는 모든 시스템에서 공통적으로 쓰이는 부분에 대해서만 구현하였다. 필요한 부분은 확장해서 사용하길 바란다.
}}

=사용자리스트보기=
*메뉴의 공통모듈>사용자 관리를 클릭하면 밑에와같이 사용자 리스트가 있는 화면을 볼 수 있다.
*상세보기를 할 때는 사용자 리스트의 id를 클릭하고 사용자 추가를 할 때는 상위의 '''추가'''버튼을 누른다.
*삭제는 왼쪽의 삭제 체크박스를 클릭한 후 상위의 '''삭제''' 버튼을 누른다.
[[그림:userList.jpg|800px]]

=사용자 수정/추가=
*사용자 리스트에서 '''추가'''버튼을 클릭하거나, 상세보기를 하면 밑에와 같이 검은색 바탕화면에 추가/수정 창이 나올 것이다.
*여기서 권한은 사용자에게 권한을 할당하는 것으로 add, del 버튼으로 왼쪽박스에 있는 권한을 오록쪽 박스로 추가하여 사용자에게 권한을 부여한다. **한 사용자는 여러개의 권한을 가질 수 있다,
*입력 및 수정이 끝났으면 상위의 '''저장'''버튼을 누른다.
[[그림:editUser.jpg|700px]]

CodeUserGuide

Alsdkzz — Wed, 17 Sep 2008 08:22:08 GMT

바꾼내용 간추리기: /* 코드데이터 사용하기 */

{{팁|
*산출물 : JCF3.0 공통모듈- 코드 가이드
*작성자:김민아
*작성일 : 2008/09/17
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}

{{정보|
*코드관리란 전체 시스템에서 쓰이는 코드성 데이터에 대해서 관리하는 화면이다.
*코드관리는 4개의 레벨로 되어있으며, 상위 2개의 코드(업무시스템코드, 상위업무코드)는 상위코드관리에서 관리하고. 하위 2개의 코드(업무코드,코드)는 코드관리 화면에서 관리한다.
}}

=상위코드관리=
*메뉴의 공통모듈>공통코드관리>상위코드관리를 클릭하면 밑에와 같은 화면을 볼 수 있다.
*왼쪽의 그리드는 업무시스템코드로 최상위코드이다.
*오른쪽 그리드는 상위업무코드로 업무시스템 하위에 있는 코드를 등록한다.
*그리드 상단의 추가, 삭제 버튼으로 데이터를 입력, 삭제할 수 있으며, 수정은 그리드에서 직접하며 작업이 끝났으면 최종적으로 상단의 저장버튼을 누름으로써 실제 수정된 데이터가 반영된다.
*업무시스템코드의 코드ID는 한자리 숫자로 등록하고,
*상위업무 코드의 코드아이디도 숫자로 등록하되 '''첫번째자리에는 상위코드의 ID'''를 넣는다.
**예)인사시스템의 코드ID --> 1 임직원관리의 코드ID --> 11
*상위업무 코드의 상위코드ID는 상위 업무시스템 코드의 ID로 자동 등록된다.올바른 상위코드ID를 넣기 위해서는 입력 시에는 상위코드 ID로 가져갈 업무시스템이 미리 선택되어 있어야한다.
[[그림:uCode.jpg|800px]]

=코드관리=
*메뉴의 공통모듈>공통코드관리>코드관리를 클릭하면 밑에와 같은 화면을 볼 수 있다.
*위의 콤보박스는 상위코드관리에서 등록한 코드 업무시스템과 상위업무에 대한 코드들로 상위코드를 선택하고 조회버튼을 클릭한다.
*왼쪽그리드는 업무코드 오른쪽 그리드는 실제 사용되는 코드들이 관리된다.
*업무코드의 ID 규칙은 맨 앞에는 알파벳 g가 들어가며 ,가운데에는 상위코드의 ID, 그 다음에 일련의 숫자이다. 예)g21(상위코드ID)01
*코드ID규칙은 맨 앞에는 알파벳 c가 들어가며 ,가운데에는 알파벳을 뺀 상위코드의 ID,그 다음에 일련의 숫자이다 예)c2101(상위코드ID)001
*나머지 사용법은 상위업무코드와 동일하다
[[그림:code.jpg|800px]]

=코드데이터 사용하기=
*[[commonModule_CodeUserGuide_struts2|struts2기반의 표준웹에서 코드 사용하기]]
*[[commonModule_CodeUserGuide_ext-js|ext-js 기반에서 코드 사용하기]]

BoardUserGuide

Alsdkzz — Wed, 17 Sep 2008 01:19:17 GMT

바꾼내용 간추리기: /* 목록보기 */

{{팁|
*산출물 : JCF3.0 공통모듈 -게시판 관리 사용 가이드
*작성자: 송희정, 김민아
*작성일 : 2008/09/17
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
=목록보기=

*목록보기에서는 글제목, 작성자, 작성일, 조회수를 나타낸다.
*글 검색 – 제목, 내용, 작성자, tag 로 검색할 수 있다.
*글 제목을 클릭하면 글 상세보기를 할 수 있고, 새로운 글을 등록할 때는 쓰기 버튼을 누른다.
* 답글이 있는 경우 “re” 이미지가 있고, 들여쓰기가 되어있다.
*오늘 등록한 글인 경우 “new” 이미지가 추가된다.
[[그림:boardList.jpg|750px|center]]

=글등록하기=
*목록보기에서 '''쓰기''' 버튼을 클릭하면 다음과 같은 화면이 나타난다.
*필독해야 하는 글이나 공지성 글의 경우 항상 제일 첫 페이지 앞 줄에 위치해야 하므로 그것에 대한 설정을 '''중요도 여부'''로 선택한다.
*태그 클리우딩을 하기 위해 태그입력을 한다. 여러 개의 태그를 입력할 경우 쉼표로 구분하여 입력한다.
[[그림:boardeditex.jpg|750px|center]]

=글상세보기=
*게시판 목록의 하나를 클릭하면 다음과 같은 화면이 나타난다.
*추가로 글에 관련된 기능 버튼(수정, 삭제, 답변, 목록 등)이 있다.
*'''덧글쓰기'''에 덧글을 왼쪽 그림과 같이 입력할 수 있고, 입력을 하면 오른쪽 그림과 같이 덧글이 등록된 것을 볼 수 있다.
[[그림:boardComment.jpg|500px|]]
[[그림:boardComment2.jpg|500px]]

CommonModule user guide

Alsdkzz — Tue, 09 Sep 2008 09:43:46 GMT

바꾼내용 간추리기:

{{팁|
*산출물 : JCF3.0 공통모듈 upgrade버전 사용가이드
*작성자:김민아
*작성일 : 2008/09/01
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
*공통코드
**상위코드
[[그림:upcode.jpg|left|800px]]

Database Spec

Alsdkzz — Mon, 08 Sep 2008 09:01:15 GMT

바꾼내용 간추리기: /* 게시판테이블 */

{{팁|
*산출물 : JCF3.0 공통모듈 upgrade 버전 가이드 -테이블 명세서
*작성자:김민아
*작성일 : 2008/09/08
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
{{정보|JCF 웹버전 공통모듈에 대한 테이블 명세서가 있는 곳입니다.}}

=공통 코드 테이블=
*공통코드 테이블은 어플리케이션에서 코드성으로 쓰이는 데이터를 공통으로 관리하는 테이블이다.
{|border="1" cellpadding="5" cellspacing="1" align="rigth"
|-
! style="background:#ffdead;" colspan="8" align="rigth" width="500"|CODE
|-
|No||PK, FK || Column Name || Type || Length || description || null || Default Value
|-
|1||PK || ID || varchar2 || 50|| 아이디 ||NN ||-
|-
|2||FK ||PARENTID || varchar2 || 50|| 상위코드아이디 ||NN ||-
|-
|3|| - || NAME || varchar2 || 50|| 이름 || -||-
|-
|4|| -|| DESCRIPTION || varchar2 || 200|| 설명 || - ||-
|-
|5||- || CRT_ID || varchar2 || 40|| 생성자 아이디 || -||-
|-
|6|| -|| CRT_DATE || date || 40|| 생성 일시 || -||sysdate
|-
|7|| -|| UPT_ID|| varchar2|| 40|| 수정자 아이디 || -||-
|-
|8|| -|| UPT_DATE|| date || 40|| 수정자 일시 || - ||sysdate
|}

=메뉴 테이블=
*메뉴테이블은 공통모듈 상위에 있는 메뉴트리부분을 관리하는 테이블이다.
{|border="1" cellpadding="5" cellspacing="1" align="rigth"
|-
! style="background:#ffdead;" colspan="8" align="rigth" width="500"|MENU
|-|No||PK, FK || Column Name || Type || Length || description || null || Default Value
|-
|1||PK || MENU_ID|| VARCHAR2|| 20||메뉴 아이디 ||NN ||-
|-
|2||FK || PARENT_ID || VARCHAR2|| 20|| 상위 메뉴아이디 || -||-
|-
|3||-|| MENU_NAME|| VARCHAR2|| 50||메뉴 이름||- ||-
|-
|4||- || MENU_LEVEL|| NUMBER|| -|| 메뉴 레벨 || - ||-
|-
|5||- || MENU_ORDER || NUMBER||-|| 메뉴 순서 || -||-
|-
|6|| -|| MENU_DESC || VARCHAR2|| 50|| 메뉴 설명|| - ||-
|-
|7||- || PROGRAM_PATH|| VARCHAR2|| 100|| 프로그램 패스(메뉴에 등록할 화면) || -||-
|-
|8|| -|| CRT_ID|| VARCHAR2|| 50|| 생성자 아이디 || -||-
|-
|9|| -||CRT_DATE|| DATE ||- ||생성 일시 || - ||sysdate
|}

=권한 테이블=
*권한 테이블은 사용자에게 주어질 권한에 대해서 관리하는 테이블로 사용자권한테이블, 메뉴권한테이블에서 권한테이블의 아이디를 참조하여 사용된다.
{|border="1" cellpadding="5" cellspacing="1" align="rigth"
|-
! style="background:#ffdead;" colspan="8" align="rigth" width="500"| ROLE
|-
|No||PK, FK || Column Name || Type || Length || description || null || Default Value
|-
|1||PK || ROLE_ID|| VARCHAR2|| 20||권한 아이디 ||NN ||-
|-
|2|| - || ROLE_NAME || VARCHAR2|| 30|| 권한 이름 || -||-
|-
|3||-|| DESCRIPTION|| VARCHAR2|| 50||설명|| - ||-
|-
|4||- || SYS_CODE|| VARCHAR2|| 20|| 시스템 코드 || - ||-
|-
|8|| -|| CRT_ID|| VARCHAR2||20|| 생성자 아이디 || -||-
|-
|9||- ||CRT_DATE|| DATE ||- ||생성 일시 || - ||sysdate
|-
|10|| -|| UPT_ID|| VARCHAR2|| 200|| 수정자 아이디 ||- ||-
|-
|11||- ||UPT_DATE|| DATE ||- ||수정 일시 || - ||sysdate
|}

=사용자 테이블=
*사용자 테이블은 사용자에 대해서 관리하는 테이블로 사용자 권한테이블에서 사용자 아이디를 참조하여 사용된다.
{|border="1" cellpadding="5" cellspacing="1" align="rigth"
|-
! style="background:#ffdead;" colspan="8" align="rigth" width="500"|COM_USR
|-
|No||PK, FK || Column Name || Type || Length || description || null || Default Value
|-
|1||PK || USR_ID|| VARCHAR2|| 40||사용자 아이디 ||NN ||-
|-
|2|| - ||PASSWORD|| VARCHAR2|| 40|| 패스워드 || -||-
|-
|3||-|| EMP_ID || VARCHAR2|| 40|| 사번 || - ||-
|-
|4||- || USR_NAME || VARCHAR2||40|| 사용자 이름 || - ||-
|-
|5|| -||EMAIL || VARCHAR2||40|| 이메일 || -||-
|-
|6||- ||PHONE || VARCHAR2|| 40 ||전화번호 || - ||-
|-
|7|| -||CPHONE|| VARCHAR2|| 40|| 휴대폰번호 ||- ||-
|-
|8||- ||FAX|| VARCHAR2||40 ||팩스번호 || - ||-
|-
|9||- ||USRPOS || VARCHAR2|| 40 ||직급 || - ||-
|-
|10|| -||DESCRIPTOIN || VARCHAR2|| 40|| 설명 ||- ||-
|-
|11||- ||COMP_CODE || VARCHAR2||40 ||회사코드 || - ||-
|-
|12||- ||CRT_ID || VARCHAR2|| 40 ||생성자 아이디 || - ||-
|-
|13||- ||CRT_DATE || DATE || -||생성 일시 || - ||sysdate
|-
|14|| -||UPT_ID || VARCHAR2|| 40|| 수정자 아이디 ||- ||-
|-
|15||- ||UPT_DATE || DATE ||- ||수정 일시 || - ||sysdate
|}

=권한 메뉴테이블=
*권한 메뉴테이블은 권한 ID와 메뉴 ID로 구성된 테이블로 해당 권한을 가진 사람에게만 메뉴가 보여지도록 관리하는 테이블이다.
{|border="1" cellpadding="5" cellspacing="1" align="rigth"
|-
! style="background:#ffdead;" colspan="8" align="rigth" width="500"| ROLE_MENU
|-
|No||PK, FK || Column Name || Type || Length || description || null || Default Value
|-
|1||PK || ROLE_ID|| VARCHAR2|| 32||권한 아이디 ||NN ||-
|-
|2|| PK || MENU_ID || VARCHAR2|| 32|| 메뉴 아이디 || NN ||-
|}

=사용자 권한 테이블=
*사용자 권한 테이블은 사용자 ID와 권한 ID로 구성된 테이블로 사용자에게 권한을 할당하여 해당 권한에 매핑한 메뉴들이 보여지는 것에 대해 관리하는 테이블이다.
{|border="1" cellpadding="5" cellspacing="1" align="rigth"
|-
! style="background:#ffdead;" colspan="8" align="rigth" width="500"| USR_ROLE
|-
|No||PK, FK || Column Name || Type || Length || description || null || Default Value
|-
|1||PK || USER_ID|| VARCHAR2|| 20||사용자 아이디 ||NN ||-
|-
|2|| PK || ROLE_ID || VARCHAR2||20|| 권한 아이디 || NN ||-
|}

=게시판테이블=
{|border="1" cellpadding="5" cellspacing="1" align="rigth"
|-
! style="background:#ffdead;" colspan="8" align="rigth" width="500"| BBS
|-
|No||PK, FK || Column Name || Type || Length || description || null || Default Value
|-
|1||PK ||ID||number||-||아이디||NN||-
|-
|2||-||SUBJECT ||varchar2||200||글 제목||NN||-
|-
|3||-||CONTENT ||text||-||글 내용||NN||-
|-
|4||-||REGIST_DATE|| date||-||등록일||NN||-
|-
|5||-||HIT ||number||-||조회수||NN||0
|-
|6||-||PRODUCT ||varchar2||100||글구분||NN||-
|-
|7||-||REPLY_COUNT ||number||-||답변글개수||NN||0
|-
|8||-||REGISTER_NAME ||varchar2||100||등록자 이름||-||-
|-
|9||-||EMAIL ||varchar2||100||등록자 이메일||-||-
|-
|10||-||PASSWORD ||varchar2||10||등록/삭제시 비밀번호||-||-
|-
|11||-||PARENT_ID ||number||-||부모글 아이디||-||-
|-
|12||-||ANSWER_ORDER ||number||-||답글순서||-||-
|-
|13||-||INDENT ||number||-||들여쓰기크기||-||-
|-
|14||-||isHTML || char||1||글 내용의 HTML 태그 적용여부||-||-
|-
|15||-||PRIORITY ||varchar2||10||글 우선순위||-||-
|-
|16||-||REGISTER_ID ||varchar2||10||등록자 ID||-||-
|-
|17||-||ATTACHMENT_ID ||varchar2||20||첨부파일 아이디||-||-
|-
|18||-||KEYWORD ||varchar2||100||글 키워드||-||-
|}

{|border="1" cellpadding="5" cellspacing="1" align="rigth"
|-
! style="background:#ffdead;" colspan="8" align="rigth" width="500"| BBS_COMMENT
|-
|No||PK, FK || Column Name || Type || Length || description || null || Default Value
|-
|1||PK||ID ||varchar2||20||댓글 아이디||NN||-
|-
|2||PK||BBS_ID ||number||-||관련 게시글 아이디||NN||-
|-
|3||-||COMMENT ||varchar2||200||댓글||NN||-
|-
|4||-||REGIST_DATE|| date||-||등록일||-||-
|-
|5||-||REGISTER_NAME ||varchar2||100||등록자 이름||-||-
|-
|6||-||REGISTER_ID ||varchar2||10||등록자 ID||-||-
|}

{|border="1" cellpadding="5" cellspacing="1" align="rigth"
|-
! style="background:#ffdead;" colspan="8" align="rigth" width="500"| BBS_TAG
|-
|No||PK, FK || Column Name || Type || Length || description || null || Default Value
|-
|1||PK||TAG ||varchar2||20||태그||NN||-
|-
|2||PK||BBS_ID ||number||-||관련 게시글 아이디||NN||-
|-
|3||-||REGIST_DATE||date||-||등록일자||NN||-
|}

JCFStarterKit Installation

Kyoung94 — Tue, 02 Sep 2008 00:55:37 GMT

바꾼내용 간추리기: /* JCFStarterKit 활용목적 */

{{팁|
*산출물: JCFStarterKit1.0.0로 개인개발환경 설치하기
*작성자: 서경진
*최초작성일 : 2008/09/02
*최종작성일 : 2008/09/05
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
{{정보|
* 이 문서에는 JCFStarterKit1.0.0을 활용하여 개인개발환경을 설치하는 것을 설명할 것이다.
}}

=JCFStarterKit 활용목적=
*JCFStarterKit은 다음과 목적으로 개발되었다.

[[그림:JCFStarterKit_purpose.JPG|750px|thumb|center|JCFStarterKit1.0.0 활용목적]]

=JCFStarterKit1.0.0 다운받기=
*[[media:StarterKit.zip|JCFStarterKit1.0.0 다운로드 (zip) : WIN2000/WINXP/Vista]]
**JCFStarterKit 설치를 위해 C:드라이브에 470MB이상의 공간이 필요하다.

=JCFStarterKit1.0.0 설치하기=
*위에 StarterKit.zip 파일을 다운로드 받은 후 압축을 풀면 다음과 같이 JCFStarterKit1.0.0.exe와 JCFStarterKit1.0.0.exe.txt 파일을 확인할 수 있다.

[[그림:JCFStarterKit_icon_exec.jpg|500px|thumb|center|압축을 푼 StarterKit 디렉터리의 JCFStarterKit1.0.0 내용 확인]]

*JCFStarterKit1.0.0.exe 파일을 더블 클릭하여 실행시키면 다음과 같은 설치 마법사가 실행된다.

[[그림:JCFStarterKit_install_01.jpg|400px|thumb|center|JCFStarterKit 설치]]

*다음 버튼을 클릭한다.

[[그림:JCFStarterKit_install_02.jpg|400px|thumb|center|JCFStarterKit 설치 - 라이센스 (동의)]]

*동의함 버튼을 클릭한다.

[[그림:JCFStarterKit_install_03.jpg|400px|thumb|center|JCFStarterKit 설치 - 라이센스]]

*다음 버튼을 클릭한다.

[[그림:JCFStarterKit_install_04.jpg|400px|thumb|center|JCFStarterKit 설치- 설치 폴더 선택]]

*가능하면 디폴트로 설치한다. (C 드라이브에 470MB 이상의 공간이 필요함)
*디폴트로 설치하지 않을 경우, 설치 후 이클립스를 실행시키고 설정을 변경해야 한다.
*설치시작 버튼을 클릭한다.

[[그림:JCFStarterKit_install_05.jpg|400px|thumb|center|JCFStarterKit 설치 진행]]

*설치가 시작된다.

[[그림:JCFStarterKit_install_07.jpg|400px|thumb|center|JCFStarterKit 설치 진행 중]]

*설치 진행률이 증가되는 것을 확인할 수 있다.

[[그림:JCFStarterKit_install_end.jpg|400px|thumb|center|JCFStarterKit 설치 완료]]

*설치가 정상적으로 완료되었으면 확인 버튼을 클릭한다.
*설치가 정상적으로 완료되었는지 확인하기 위해 다음과 같이 JCFStarterKit 설치 폴더를 확인한다.

[[그림:JCFStarterKit_install_directorystructure.jpg|500px|thumb|center|JCFStarterKit 설치 폴더 확인]]

[[그림:JCFStarterKit_startup_menu.jpg|500px|thumb|center|JCFStarterKit 시작 메뉴 확인]]

[[그림:JCFStarterKit_install_programs.jpg|500px|thumb|center|JCFStarterKit 프로그램 메뉴 확인]]

[[그림:JCFStarterKit_uninstall_menu.jpg|500px|thumb|center|제어판의 프로그램 추가/삭제에서 JCFStarterKit1.0.0 설치 확인]]

*설치가 완료되면 다음과 같은 환경변수가 자동으로 설정된다.
<pre>
1. JAVA_HOME = C:\j2e\java\jdk1.6.0_06
2. M2_HOME = C:\j2e\tools\maven\apache-maven-2.0.9
3. CATALINA_HOME = C:\j2e\was\apache-tomcat-6.0.16
4. path = %path%;%JAVA_HOME%\bin;%M2_HOME%\bin;%CATALINA_HOME%\bin
5. classpath = .;
</pre>

*다음과 같이 시스템 등록정보>고급>환경변수에서 위의 설정값들이 정상적으로 설정된 것을 확인할 수 있다.

[[그림:JCFStarterKit_install_java_home.jpg|280px|JAVA_HOME 환경변수 설정]]
[[그림:JCFStarterKit_install_m2_home.jpg|280px|M2_HOME 환경변수 설정]]
[[그림:JCFStarterKit_install_catalina_home.jpg|280px|CATALINA_HOME 환경변수 설정]]
[[그림:JCFStarterKit_install_path.jpg|280px|path 환경변수 설정]]

=eclipse 구동하기=
*설치된 JCFStarterKit에 포함된 eclipse IDE를 구동하기 위해 두 가지 선행작업이 필요하다.
**eclipse 실행 단축 아이콘에 JVM 메모리 관련 인수가 설정된 단축 아이콘 복사하기
**eclipse WTP에서 미리 설치된 Tomcat6.0 서버를 제거하고 다시 설치하기

==단축 아이콘 복사하기==
*바탕화면에 복사된 eclipse 바로가기로 eclipse를 구동시키기 위해서 설치 폴더 ide\eclipse에 있는 eclipse 바로가기를 바탕화면과 시작메뉴/프로그램에 다음과 같이 단축 아이콘을 복사(덮어쓰기)한다.

[[그림:JCFStarterKit_copy_eclipse_shortcut.jpg|500px|thumb|center|바탕화면/프로그램 메뉴에 JCFStarterKit 단축 아이콘 복사하기]]

[[그림:JCFStarterKit_copy_wallpaper_eclipseshortcut.jpg|500px|thumb|center|바탕화면 JCFStarterKit 단축 아이콘 확인]]

*이클립스 실행 시 발생할 수 있는 메모리 문제를 예방하기 위해서 다음과 같이 설정된 단축 아이콘을 사용한다.

[[그림:JCFStarterKit_eclipse_shortcut_properties.jpg|300px|thumb|center|바탕화면 JCFStarterKit 단축 아이콘 복사완료 확인]]

==eclipse 실행하기==
*바탕화면에 있는 eclipse 바로가기를 실행시키면 다음과 같이 workspace를 설정하는 화면이 출력된다.

[[그림:JCFStarterKit_workspace_launcher.jpg|400px|thumb|center|workspace 선택화면]]

*workspace를 선택하고 OK를 클릭하면 다음과 같이 eclipse가 실행된다.

[[그림:JCFStarterKit_eclipse_tomcat_exec.jpg|500px|thumb|center|eclipse 실행화면]]

==WTP 환경 수정하기==

=JCFStarterKit1.0.0 제거하기 (Uninstallation)=
*설치된 JCFStarterKit1.0.0을 제거하기 방법은 두 가지가 있다.
**시작 프로그램에 있는 Uninstall JCFStarterKit1.0.0을 실행하는 방법
**프로그램 추가/삭제에 있는 JCFStarterKit1.0.0을 선택하여 삭제하는 방법
*위의 두 가지 중 하나를 선택하여 실행하면 다음과 같은 창이 출력된다.

[[그림:JCFStarterKit_uninstall_popup.jpg|250px|thumb|center|Uninstall 실행 시 최초 팝업 화면]]

*예 버튼을 클릭하면 제거가 진행되는 것을 확인할 수 있다.

[[그림:JCFStarterKit_uninstall_01.jpg|400px|thumb|center|JCFStarterKit 제거 진행 화면]]

*제거 진행 시 workspace나 다른 폴더에 사용자가 추가적한 파일에 대한 삭제는 진행과정 중 팝업창을 통해 삭제 여부를 결정하게 된다.

[[그림:JCFStarterKit_uninstall_02.jpg|400px|thumb|center|JCFStarterKit 제거 완료]]

*제거가 완료되면 확인 버튼을 클릭한다.

[[그림:JCFStarterKit_uninstall_complete.jpg|500px|thumb|center|JCFStarterKit 제거 확인]]

*정상적으로 제거가 완료되었는지 확인하기 위해 바탕화면의 단축 아이콘이 삭제되었는지 다음과 같이 확인할 수 있다.

[[그림:JCFStarterKit_uninstall_wallpaper.jpg|500px|thumb|center|바탕화면에 JCFStarterKit 단축 아이콘 제거 확인]]

CommonModule

Alsdkzz — Mon, 01 Sep 2008 00:35:59 GMT

바꾼내용 간추리기:

{{팁|
*산출물 : JCF3.0 공통모듈 upgrade 버전 가이드
*작성자:김민아
*작성일 : 2008/09/01
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
*환경 정보
**WAS : Tomcat 6.0
**jdk :jdk 1.6.0_06
**DB : oracle10g
*[[source download|소스 다운받기]]
*[[CommonModule install|개인 컴퓨터에 설치하기]]
*ERD 보기
[[그림:commModule.jpg|center|850px|thumb|JCF3.0 공통모듈 upgrade 버전 erd]]
*[[Database Spec|테이블 명세서]]
*[[CommonModule user guide|공통모듈 사용가이드]]
**[[MenuGuide|메뉴관리]]
**[[roleGuide|권한관리]]
**[[UsrGuide|사용자관리]]
**[[CodeUserGuide|코드관리]]
**[[BoardUserGuide|게시판]]

JCF Quick Education

Kyoung94 — Sun, 17 Aug 2008 03:35:02 GMT

바꾼내용 간추리기:

{{팁|
*산출물 : JCF 비정기교육 자료
* 최초작성일 : 2008/08/14
* 최종작성일 : 2008/08/18
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
{{경고|이 곳은 JCF 비정기교육에 대한 강의자료가 있는 방입니다. }}

=준비사항=
*[[JCFStarterKit_Installation|JCFStarterKit 기반의 개인 개발환경 설치하기]]
*[[media:jcf_basicSample_cr(2).zip|샘플소스 다운 받기]]
*[[media:mysql.zip|mysql 다운받기]]
*JCF 공통모듈 설치

=1일차=
*JCF 공통모듈 기반의 아키텍처 이해
*[[media:JCF.pdf|JCF 소개 (pdf자료)]]
*[[media:JCFOverviewAndArchitecture.pdf|JCF 아키텍처 (pdf자료)]]
*Quick Start로 예제 돌려보기
**Struts2 + Spring + IBatis
*JCF 공통모듈 이해하기
**Quick Start와 JCF 공통모듈 차이점 이해하기
*JCF 아키텍처 이해하기
**[[media:FW_STRUTS2.pdf|Struts2 (pdf자료)]]
**[[media:FW_SPRING2.pdf|Spring2.5 (pdf자료)]]
***Spring IoC
***Spring AOP
**[[media:FW_IBATIS2.pdf|iBatis2.3 (pdf자료)]]
***iBatis Cache 적용하기
***iBatis Dynamic Query 사용하기
*[[media:TransactionAndCache.pdf|트랜잭션처리 (pdf자료)]]

=2일차=
*[[media:BasicDevelopment.pdf|기본 모듈 개발하기 (pdf자료)]]
*WTP Dynamic Web Project 기반의 Sample 웹 어플리케이션 구현하기
*[[media:Logging.pdf|log4j를 이용한 로깅처리하기 (pdf자료)]]

=Appendix=
*[[media:CodeDev.pdf|코드처리하기 (pdf자료)]]
*[[media:Search_Paging_Sorting.pdf|검색, 페이징, 정렬 처리하기 (pdf자료)]]
*[[media:Security.pdf|보안처리하기 (pdf자료)]]
*[[media:MasterAndDetail.pdf|Master/Detail 처리하기 (pdf자료)]]
*[[media:TagLibrary.pdf|Tag Library 활용하기 (pdf자료)]]
*[[media:Debugging.pdf|Debugging하기 (pdf자료)]]
*[[media:Testing.pdf|Testing (pdf자료)]]
*[[media:ANT.pdf|Ant 활용하기 (pdf자료)]]

SetMessage

Itanywhere — Wed, 13 Aug 2008 01:34:34 GMT

바꾼내용 간추리기: New page: <code lang='javascript'> function setMessage(errMsg, showType) { //alert("showType"+showType+"errMsg"+errMsg); //alert(showType); //alert(errMsg); if ( showType == "ALERT") { alert(e...

<code lang='javascript'>
function setMessage(errMsg, showType)
{
//alert("showType"+showType+"errMsg"+errMsg);
//alert(showType);
//alert(errMsg);
if ( showType == "ALERT") {
alert(errMsg);
} else if ( showType == "STARUS" ) {
div_msg.stMsg.text = errMsg;
} else if ( showType == "CONFIRM" ) {
retVal = confirm(errMsg);
return retVal;
} else {
stMsg.Value = errMsg;
}
}

</code>

Aop:pointcut의 정규표현식

Itanywhere — Tue, 12 Aug 2008 09:24:36 GMT

바꾼내용 간추리기:

==<aop:config>==
*트랜젝션을 처리할 대상을 넣음
{{정보|참조:
*[[%ED%8A%B8%EB%9E%9C%EC%9E%AD%EC%85%98#.EC.8A.A4.ED.94.84.EB.A7.81.EC.97.90.EC.84.9C_.ED.8A.B8.EB.9E.9C.EC.9E.AD.EC.85.98_.EC.84.A0.EC.96.B8.ED.95.98.EA.B8.B0|스프링에서 트랜잭션 선언하기]]
}}
==공통모듈에서의 정규표현식==
*applicationContext-aop.xml
<code lang='xml'>
<aop:config>
<aop:pointcut id="serviceOperation" expression="execution(* *..*Service.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="serviceOperation"/>
</aop:config>
</code>
*설명
**<nowiki>*_</nowiki>:모든 형태의 가시성(public,proteced..)을 가지는 메소드
**<nowiki>*..</nowiki>:모든 패키지명
**<nowiki>*Service</nowiki>:클래스명이 Service로 끝나는 클래스
**<nowiki>.*(..))</nowiki>:모든 형태의 파라미터를 가지는 모든 메소드
{{주의사항|
'''<nowiki>* *..*Service.*(..))</nowiki>''': 모든형태의 가시성을 가지는 모든 패키지명에서 클래스명이 Service로 끝나는 클래스의 모든 형태의 파라미터
}}

X-Internet 로그인

Itanywhere — Tue, 12 Aug 2008 06:59:35 GMT

바꾼내용 간추리기: /* 마이플렛폼 로그인 화면 */

==개요==
*현재 common module은 표준웹에서 로그인 하여 x-internet 전용창을 call하는 흐름
*장단점
**마이플렛폼 개발툴에서 Launch project로 실행해 볼 수 없음
**어플리케이션 test 시 마이플렛폼 개발툴에서 개발한후 다시 web 브라우져를 통해 로그인해야하는 번거로움이 있음
**표준웹에서 가졌던 JSESSIONID와 마이플렛폼 전용브라우져의 JSESSIONID가 다르므로 login이후 JSESSIONID을 client 레지스트리에 넣어주고 마이플렛폼 브라우져에서 JSESSIONID를 빼는 작업을 해야함.
**마이플렛폼 로그인을 할 경우는 autocookie를 통해 서버단 jsessionid를 가져오므로 setReg,getReg할 필요 없음. 단지 JSESSIONID란 이름으로 share변수를 선언하기만 하면 됨
[[그림:weblogin.png|900px|center|thumb|표준웹로그인 기반 흐름]]
[[그림:milogin.png|900px|center|thumb|마이플렛폼 로그인 기반 흐름]]
==마이플렛폼 개발툴에서 (PID) 로그인 하기==
===마이플렛폼 용 startxml 추가 생성하여 pid에 프로젝트 등록===
*dev_common_ci_main.xml 생성
**initurl="CommonGroup::login.xml" 로 교체
**OnBeforeExit="Common_Exit"를 삭제
*pid에 project manager에 dev_common_ci_main.xml로 등록
===마이플렛폼 로그인 화면===
{{경고|
*마이플렛폼의 option에서 autocokiee를 true로 하면(기본값 true) 자동으로 서버단의 쿠키값을 마이플렛폼의 global 변수로 가져옴
*share 변수로 JSESSIONID를 선언할 경우 자동으로 서버단의 sessionID가 JSESSIONID변수로 들어감
}}
*auth/authResult.action 호출시 j_username과 j_password 를 파라미터로 가지고 감
<code lang='javascript'>
function btnLogin_OnClick(obj)
{
var queryString = "";
queryString += "?j_username=" + edUserName.Text;
queryString += "&j_password=" + edPassword.Text;
GV_IS_DEV = true;

transaction(
"Login", //strServiceID
"Common::login/loginResult.action" + queryString, //strUrl
"", //arrParmeter
"",
"",// returnDataSet ID
"fn_LoginCallBack"); // fnCallback
}

function fn_LoginCallBack()
{
//마이플렛폼으로 로그인할 경우 jsessionID를 레지스트리에 넣어줄 필요가 없음
//alert(JSESSIONID);
//setReg("GlobalVal",JSESSIONID);
go("CommonGroup::MainFrame.xml");
}
</code>

===loginAction===
<code lang='java'>
function btnLogin_OnClick(obj)
public void authResult() {

SecurityContext securityContext = SecurityContextHolder.getContext();
AuthenticationProcessingFilter authenticationProcessingFilter = (AuthenticationProcessingFilter)SpringContextHolder.getBean("authenticationProcessingFilter");
Authentication authentication = authenticationProcessingFilter.attemptAuthentication(getRequest());
if (authentication.isAuthenticated()){
securityContext.setAuthentication(authentication);
System.out.println(getRequest().getSession().getId());
//마이플렛폼에 autocookie값이 true일 경우에는 자동으로 마이플렛폼이 서버단 cookie값을 가져오기 때문에 Outchanel로 jsessionID를 넣어줄 필요가 없음
//OutChannel.setVariable("JSESSIONID", getRequest().getSession().getId());
//OutChannel.send();
}else{
OutChannel.error("-2000", "login fail");
}
}
</code>

TimeOut Message

Itanywhere — Tue, 12 Aug 2008 06:28:41 GMT

바꾼내용 간추리기: /* srv_fn_AsyncCall */

==sessiontimeout 설정==
===was에서 설정===
**tomcat의 경우 conf 폴더 밑에 web.xml에서 설정함 (기본값 30분)
<code lang='xml'>
<session-config>
<session-timeout>30</session-timeout>
</session-config>
</code>
===application내에서 설정===
*web/web-inf/web.xml에서 설정(was설정보다 우선함)
<code lang='xml'>
<session-config>
<session-timeout>30</session-timeout>
</session-config>
</code>
===마이플렛폼에서 설정===
*pid 상에서 설정가능함.
*서버에 한번 요청을 한후 response가 오는 시간을 설정

==spring security에서 세션timeout exception 잡아내기==
*exceptionTranslationFilter에서 authenticationEntryPoint property를 수정, 세션종료후 서버단 호출시 exception잡아서 loginFormUrl을 호출
*loginFormUrl은 /commonJSP/loginError.jsp이며 jsp에서 에러코드를 던짐
*applicationContext-security.xml 수정

*filterInvocationInterceptor bean을 아래와 같이 수정하여 모든 action에 대해 spring security가 권한을 intercept 할수있도록 함

<code lang='xml'>
<bean id="filterInvocationInterceptor"
class="org.acegisecurity.intercept.web.FilterSecurityInterceptor">
<property name="authenticationManager" ref="authenticationManager" />
<property name="accessDecisionManager" ref="accessDecisionManager" />



<property name="objectDefinitionSource">
<value>
CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
PATTERN_TYPE_APACHE_ANT
/login.jsp*=ROLE_ANONYMOUS
/j_acegi_logout*=ROLE_ANONYMOUS
/login/*.action*=ROLE_ANONYMOUS

/**/*.action=ROLE_COMMON_ADMIN
</value>
</property>

</bean>
</code>
*filterInvocationInterceptor bean에서 url 패턴별로 권한을 검사한 후 권한이 없는 요청이 왔을때 exceptionTranslationFilter에서 처리
<code lang='xml' em='5,6'>
<bean id="exceptionTranslationFilter"
class="org.acegisecurity.ui.ExceptionTranslationFilter">

<property name="authenticationEntryPoint">
<bean class="org.acegisecurity.ui.webapp.AuthenticationProcessingFilterEntryPoint">
<property name="loginFormUrl" value="/commonJSP/loginError.jsp" />
<property name="serverSideRedirect" value="true"/>
</bean>
</property>

<property name="accessDeniedHandler">
<bean
class="org.acegisecurity.ui.AccessDeniedHandlerImpl">
<property name="errorPage" value="/commonJSP/loginError.jsp" />
</bean>
</property>
</bean>
</code>
==loginFormUrl에서 세션timeout 에러코드와 에러메세지 던지기==
*loginError.jsp
<code lang='jsp' em='6,7'>
<%@page import="jcf.web.ux.miplatform.MiResponse"%>
<%@page contentType="text/html; charset=EUC-KR" %>
<%
System.out.println("세션만료");

MiResponse res = new MiResponse(response);
res.error("-10000", "세션이 만료되었습니다.");
%>
</code>
==마이플렛폼에서 서버단 메세지 받기==
===Transaction 사용하여 서버에 호출하는 경우===
*마이플렛폼 화면에서 서버호출 (예)용어사전 조회버튼 누를시
<code lang='javascript' em='3'>
function menuFind()
{
Transaction(
"FIND",
"Common::term/findTerms.action",
"",
"ds_term=ds_term",
"",
"trancallback"
);
}
</code>
*마이플렛폼 화면에서 서버호출 후 callback에서 에러처리
**에러코드를 잡에서 setMessage를 호출하고 에러코드가 양수일 경우 status bar에 메세지를 뿌려주는 postxxx()를 호출

<code lang='javascript' em='6,7,10,16,17,20'>
function trancallback(trid, ErrorCode, ErrorMsg )
{

if( trid == "save" )
{
if( ErrorCode < 0 ) {
setMessage(ErrorMsg, "ALERT");
break;
}
postSave();
}

if( trid == "FIND" )
{
if( ErrorCode < 0 ){
setMessage(ErrorMsg, "ALERT");
break;
}
postFind();
}
}
</code>

{{팁|
*setMessage() 란?
**JCF_JS::jcf_message.js 사용
**setMessage(errorMeg, type);
**type종류("ALERT","STARUS","CONFIRM")
}}

===srv_fn_AsyncCall사용하여 서버에 호출하는 경우===
====srv_fn_AsyncCall====
{{정보|
*srv_fn_AsyncCall()
**위치 : JCF_JS::lib_service.js
**역할: 비동기식 서버호출 , Progress UI(loading.xml) 보여줌, 서버 호출 후 errorcode 및 errorMsg 받아서 setMassage 해줌)
**특징: 단위화면에서 callback function으로 에러메세지처리 구현 하지 않아도 됨.
}}
<code lang='javascript' em='56,57,58,59,60'>

/******************************************************************
* 입력: svcid : svcid
svcName : Transaction코드
InData : Input Dataset List
OutData : Output Dataset List
arg : 처리하고자할 argument
Result : 서비스후에 처리할 Function
* return : 처리 결과 Dataset
* ex : srv_fn_AsyncCall("select","KCAE01_MVCColsSelect.jsp","",args_out,args_mvs,"fnCallBack");
******************************************************************/
function srv_fn_AsyncCall(svcid,svcName,InData,OutData,arg,Result,Progress)
{
SetWaitCursor(true);
SetCapture();
global.MainFrame.enable = false;
//alert(Progress);
if(Progress == true) {
objProgress = object("DivProgress");
if(!isValidObject(objProgress)) {
objProgress = Create("Div","DivProgress",'Url="CommonGroup::Loading.xml" width="0" height="0" Visible=false');
}
objProgress.Width = nProgWidth;
objProgress.Height = nProgHeight;
objProgress.Left = srv_fn_GetProgLeft();
objProgress.Top = srv_fn_GetProgTop();
objProgress.Visible = true;
}

scmv_userFunc = Result;
Transaction(svcid,svcName,InData,OutData,arg,"srv_fn_Result");
}
}

function srv_fn_GetProgLeft()
{
return (this.Width / 2) - (nProgWidth / 2);
}

function srv_fn_GetProgTop()
{
return (this.Height / 2) - (nProgHeight / 2);
}

/******************************************************************
* Async Transaction 결과
*****************************************************************/
function srv_fn_Result(TrID,strErrCode,strErrorMsg)
{
if(objProgress.Visible == true) objProgress.Visible = false;
global.MainFrame.enable = true;
ReleaseCapture();
SetWaitCursor(false);
// session time out (재로그인)
if(toNumber(strErrCode) == -10000)
{
if(JSESSIONID != "timeout") {
JSESSIONID = "timeout";
alert(strErrorMsg);
}
return;
}
// no authority - 권한 없음(로그아웃)
if(toNumber(strErrCode) == -20000)
{
// 권한 없음 처리 로직을 넣으세요...
return;
}
// Exception 처리
if(toNumber(strErrCode) == -70000)
{
// Exception 처리 로직을 넣으세요...
return;
}
if(toNumber(strErrCode) < 0 && toNumber(strErrCode) > -1000000000)
{
//alert(strErrCode);
alert(strErrorMsg); }
if(length(scmv_userFunc) == 0) return;
var ExprCall = scmv_userFunc + '(TrID, strErrCode, strErrorMsg)';
eval(ExprCall);
}
</code>
*srv_fn_AsyncCall 사용하여 마이플렛폼 화면에서 서버호출 (예)용어사전 조회버튼 누를시
<code lang='javascript' em='3'>
function menuFind()
{
srv_fn_AsyncCall(
"FIND",
"Common::term/findTerms.action",
"",
"ds_term=ds_term",
"",
"trancallback",
true);
}
</code>

WebServices CXF

Kyoung94 — Mon, 11 Aug 2008 05:24:11 GMT

바꾼내용 간추리기: /* CXF Archetype 만들기 */

{{팁|
*산출물: CXF Architype 만들기
*작성자: 서경진
*최초작성일 : 2008/08/11
*최종작성일 : 2008/08/14
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
{{정보|
* 이 문서는 웹서비스 엔진 중에 하나인 CXF에 대하여 설명한 것이다.
}}
{{경고|
*이 문서는 현재 작성중에 있습니다.
}}

=CXF Archetype 만들기=

[[그림:CXF_Maven_Archetype_DirectoryStrutcture.JPG|400px|thumb|center|CXF 웹서비스 Archetype 디렉터리 구조]]

<pre>
1. archetype plugin을 위한 새 프로젝트와 pom.xml 생성하기
2. archetype descriptor 생성하기
3. prototype 파일과 prototype pom.xml 생성하기
4. archetype 설치하고 실행하기
</pre>

==archetype plugin을 위한 새 프로젝트와 pom.xml 생성하기==

==archetype descriptor 생성하기==

==prototype 파일과 prototype pom.xml 생성하기==

==archetype 설치하고 실행하기==

=CXF Quick Start로 웹서비스 개발하기=

Spring Quartz Batch

Stardust — Fri, 08 Aug 2008 08:03:40 GMT

바꾼내용 간추리기: /* SpringFramework + Quartz + SpringBatch 예제 다운로드 */

{{팁|
*산출물: SpringFramework + Quartz + SpringBatch 사용하기 (예제)
*작성자: 나윤주
*최초작성일 : 2008/08/08
*최종작성일 : 2008/08/11
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
{{정보|
* 이 문서는 Web Service 환경에서 SpringFramework와 Quartz 스케줄러를 사용해 SpringBatch를 실행시키는 방법을 설명한다.
}}

==환경준비==
*이 예제는 Web Service 환경에서 Spring Batch를 사용하는 것을 목적으로 하며, 이클립스 기반에서 작성되었다.
*주요 기술 구성은 SpringFramework와 Quartz, SpringBatch이다.
*환경설정
**이클립스를 통해 Dynamic Web Project를 생성한다.
**주요 라이브러리는 spring.jar, quartz.jar, spring-batch-core.jar, spring-batch-infrastructure.jar, jta.jar, commons-collections.jar, commons-io.jar, commons-logging.jar, commons-pool.jar, hsqldb.jar 등이 있다. 이 라이브러리들은 아래 예제 코드에 포함되어 있다. (/spring-quartz-batch/web/WEB-INF/lib/)

==SpringFramework에서 Quartz 사용하기==
*Quartz는 Java application과 통합되어 job을 스케줄링하고 관리할 수 있는 Job Scheduling System 이다.
*SpringFramwork에서는 Quartz와 연계하여 스케줄링 할 수 있는 API를 제공한다.
*SpringFramwork에서 Quartz를 사용하기 위해 스케줄링 할 Job과 스케줄러의 설정이 필요하다.
===Job Class===
*수행될 Job은 간단하게 Java Class로 작성된다.
*spring.jar에 포함된 org.springframework.scheduling.quartz.QuartzJobBean Class를 상속하며 executeInternal() 메소드를 구현해야 한다.
*executeInternal() 메소드에서 수행될 Job의 내용을 작성한다.
*간단한 Log를 찍는 job class는 다음과 같이 구현할 수 있다.
<code lang="java">
/* HelloJob.java */
package quartz.example;

import java.util.Date;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.quartz.JobExecutionContext;
import org.springframework.scheduling.quartz.QuartzJobBean;

public class HelloJob extends QuartzJobBean {

private static Log _log = LogFactory.getLog(HelloJob.class);

public HelloJob() {
}

protected void executeInternal(JobExecutionContext context) {
_log.info("<<<<<<<< Hello World! - " + new Date() + " >>>>>>>>");
}

}
</code>

===Job/Scheduler Configuration===
*Job과 scheduler의 설정은 xml 파일에서 이루어진다.
*xml 설정 파일은 web.xml에서 contextConfigLocation 설정에 포함시켜 웹 서비스가 시작됨과 동시에 스케줄된 Job이 작동하도록 한다.
*Job을 실행시키는 스케줄을 담고 있는 Trigger로는 SimpleTriggerBean과 CronTriggerBean이 있다.
**SimpleTrigger는 한번 발생하는 Job이나 일정한 주기를 가지고 반복되는 Job 등에 적용할 수 있다.
**CronTrigger는 Calendar 기반 즉, 년/월/일/시/분/초/요일 등을 기준으로 실행되어야 하는 Job 등에 적용할 수 있다.
*TriggerBean을 통해 작성된 스케줄은 SchedulerFactoryBean에 등록함으로써 작동된다.
*아래 코드에서는 simpleTrigger를 사용하여 서비스가 시작되고 10초 후 부터 50초 간격으로 Job을 실행시키도록 스케줄하였다.
<code lang="xml">
<beans ...(xmlns 설정)>
<bean id="helloJob" class="org.springframework.scheduling.quartz.JobDetailBean">
<property name="jobClass" value="quartz.example.HelloJob" />
</bean>

<bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">
<property name="jobDetail" ref="helloJob" />
<property name="startDelay" value="10000" />
<property name="repeatInterval" value="50000" />
</bean>

<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<ref bean="simpleTrigger"/>
</list>
</property>
</bean>
</beans>
</code>

==SpringFramework + Quartz + SpringBatch 사용하기==
{{틀:주의사항|
*Spring Batch는 경우에 따라 다양한 설정이 가능하고, 필요할 수 있으므로 반드시 레퍼런스를 참고하여 사용하도록 한다.
}}

*위에서 설명한 SpringFramework + Quartz의 Quartz Job에서 Spring Batch Job을 수행한다.
*즉, SpringFramework를 사용하는 웹 서비스에서 Quartz를 통해 스케줄링을 하고, Spring Batch Job을 수행하게 된다.
*Spring Batch Job을 수행하기 위해 Spring Batch의 JobLauncher, JobRepository 등의 설정과 Job에 대한 정의가 필요하다.
===Job과 연관된 components 설정===
*JobRepository와 JobLauncher는 Job의 실행을 위한 기본적으로 지정해주어야 하는 설정이다.
**JobRepository는 Job을 관리하는 Repository로 데이터베이스 및 데이터소스 설정을 한다.
**JobLauncher는 Job과 실행 Parameter를 전달하여 Job의 실행을 도와주는 역할을 한다.
*SimpleJob과 TaskletStep 등은 미리 정의해 놓고 간단한 Job을 정의할 때 상속받아 사용할 수 있도록 한다.
<code lang='xml'>
<bean id="jobRepository" class="org.springframework.batch.core.repository.support.JobRepositoryFactoryBean">
<property name="databaseType" value="hsql" />
<property name="dataSource" ref="dataSource" />
</bean>

<bean id="jobLauncher" class="org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name="jobRepository" ref="jobRepository" />
</bean>

<bean id="simpleJob" class="org.springframework.batch.core.job.SimpleJob" abstract="true">
<property name="jobRepository" ref="jobRepository" />
</bean>

<bean id="taskletStep" class="org.springframework.batch.core.step.tasklet.TaskletStep" abstract="true">
<property name="jobRepository" ref="jobRepository" />
</bean>
</code>
===Job의 정의===
*Job은 xml 파일로 정의되며, Job 내부의 Step이 Java Class로 구현된다.
*위에서 정의한 SimpleJob을 상속받아 개별 Job에 대한 속성을 지정해 줄 수 있다.
*여기서는 myHelloJob을 정의하고 내부 Step으로 메시지를 전달하는 Class를 구현하였다.
<code lang='xml'>
<bean id="myHelloJob" parent="simpleJob">
<property name="name" value="myHelloJob" />
<property name="steps">
<list>
<bean id="firstHello" parent="taskletStep">
<property name="tasklet">
<bean class="quartz.example.MyHello">
<property name="message" value="Hi~" />
</bean>
</property>
</bean>
<bean id="secondHello" parent="taskletStep">
<property name="tasklet">
<bean class="quartz.example.MyHello">
<property name="message" value="Oh~ Hi~" />
</bean>
</property>
</bean>
</list>
</property>
</bean>
</code>
*정의한 Job을 Quartz Job에 연결하기 위해, Quartz Job의 정의 및 구현도 변경되어야 한다.
*구현한 Quartz Job Class에 SpringBatch의 Job과 JobLauncher 변수를 등록하고 정의에도 추가해 준다.
<code lang='xml'>
<bean id="helloJob" class="org.springframework.scheduling.quartz.JobDetailBean">
<property name="jobClass" value="quartz.example.HelloJob" />
<property name="jobDataAsMap">
<map>
<entry key="launcher" value-ref="jobLauncher"/>
<entry key="job" value-ref="myHelloJob"/>
</map>
</property>
</bean>
</code>
*SpringBatch Job은 JobLauncher의 run() API를 통해 실행 시킬 수 있다.
*Job의 내용이 같을 경우 한번 실행된 Job이므로 이미 완료되었다는 예외가 발생하므로, JobParameter를 다르게 줌으로써 계속적으로 실행 할 수 있도록 한다.
**이 예제에서는 JobParameter로 Date를 전달하였다.
<code lang='java'>
/* HelloJob.java */
/* .. 중간생략 .. */
public class HelloJob extends QuartzJobBean {
private JobLauncher launcher;
private Job job;

/* .. 중간생략 .. */

protected void executeInternal(JobExecutionContext context) {
_log.info("<<<<<<<< " + " Hello World! - " + new Date() + " >>>>>>>>");

JobParametersBuilder jobParameterBulider = new JobParametersBuilder();
jobParameterBulider.addDate("date", new Date());

try {
JobExecution jobExecution = launcher.run(job, jobParameterBulider.toJobParameters());
} catch (JobExecutionAlreadyRunningException e) {
/* .. 중간생략 .. */
}
}

}
</code>

==SpringFramework + Quartz + SpringBatch 예제 다운로드==
*[[media:spring-quartz-batch.zip|SpringFramework + Quartz + SpringBatch 예제 다운로드]]
*데이터베이스는 hsqldb를 사용하였다.
**이 예제에서는 데이터베이스를 사용하지 않으나, 데이터베이스를 사용하는 batch job을 개발할 경우 데이터베이스 설정을 참조할 수 있다.
{{정보|
*예제 실행을 위해서는 JDK, 이클립스, 톰캣 등의 개발환경이 필요하다. ([[개인 개발환경]] 참고)
}}

*(보충)아래 예제는 Web Service Application인 블로그와 Spring Batch를 적용한 예제이다.
**Spring MVC 파일 업로드로 저장된 파일을 BLOB 타입으로 변환해서 데이터베이스에 업데이트하는 부분을 배치처리하였다.
**Spring MVC + SpringFramework + iBatis + HSQL + Quartz + SpringBatch의 조합.
**[[media:blog-batch.zip|블로그 + Spring Batch 예제 다운로드]]

==참고자료==
*[http://static.springframework.org/spring-batch/ Spring Batch Web Site]
*[http://static.springframework.org/spring-batch/spring-batch-docs/reference/html/index.html Spring Batch Reference]
*[http://chanwook.tistory.com/671 Spring Batch 튜토리얼]
*[http://www.opensymphony.com/quartz/ Quartz Web Site]
*[http://static.springframework.org/spring/docs/2.5.x/reference/scheduling.html SpringFramework Refernece(Using the OpenSymphony Quartz Scheduler)]

Spring Batch Environment Setting

Kyoung94 — Thu, 24 Jul 2008 09:41:45 GMT

바꾼내용 간추리기: /* 주요 TestCase 이해하기 */

{{팁|
*산출물: Spring Batch Environment Setting
*작성자: 서경진
*최초작성일 : 2008/07/24
*최종작성일 : 2008/07/30
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
{{정보|
* 이 문서에는 Spring Batch 코어와 샘플 프로젝트를 설치하고 구동하는 것을 설명할 것이다.
}}
{{경고|
*이 문서는 현재 작성중에 있습니다.
}}

=프로젝트 다운받기=
*Spring Batch에 대한 이해를 높이기 위해서 Spring Batch에서 제공하는 소스와 샘플을 설치하여 테스트하는 것이 필요하다.
*우선 프로젝트를 구성하기 위해 Spring Batch SVN 사이트(http://springframework.svn.sourceforge.net/svnroot/springframework/spring-batch) 에서 소스를 다운로드 받는다.
*Eclipse에서 다음과 같이 Repository를 설정한다.

[[그림:SpringBatch_SubversionSite.JPG|400px|thumb|center|Spring Batch SVN Site]]

*해당 URL을 통해 접근하면 다음과 같은 디렉토리 구조를 가지는 것을 확인할 수 있다.

[[그림:SpringBatch_DirectoryStructure.JPG|400px|thumb|center|Spring Batch 디렉토리 구조]]

*SVN 디렉토리 구조에서 trunk에서 오른쪽 버튼을 클릭하여 소스를 checkout 한다.
*Spring Batch와 관련된 모든 소스들이 Checkout 되고 로컬 프로젝트 디렉토리 구조는 다음과 같다.

[[그림:SpringBatch_LocalDirectoryStructure.JPG|700px|thumb|center|로컬 프로젝트 디렉토리 구조]]

=Eclipse 프로젝트로 Import하기=
*Package Explorer View에서 오른쪽 마우스를 클릭하고 출력된 메뉴에서 Import를 선택한다.
*Import창에 다음과 같이 설정하고 spring-batch-core 프로젝트를 생성한다.

[[그림:SpringBatch_Core_ImportProject.JPG|525px]]
[[그림:SpringBatch_Core_ImportProject_selectDir.JPG|525px]]

*마지막 그림에서 finish를 클릭하면 eclipse의 explorer view에 다음과 같이 spring-batch-core 프로젝트가 등록된 것을 확인할 수 있다.

[[그림:SpringBatch_Core_EclipseProject.JPG|772px|thumb|center|eclipse 프로젝트 등록]]

*spring-batch에 있는 서브 디렉터리인 spring-batch-infrastructure, spring-batch-integration, spring-batch-samples도 위와 같은 방법으로 eclipse 프로젝트로 등록한다.
*다음은 spring-batch의 서브 프로젝트를 eclipse 프로젝트로 등록한 화면이다.

[[그림:SpringBatch_Core_All_EclipseProject.JPG|933px|thumb|center|spring-batch 서브 프로젝트를 eclipse 프로젝트로 등록]]

=Maven 명령으로 실행하기=
*현재 eclipse에 등록된 spring-batch 프로젝트는 POM (Project Object Model) 기반의 Maven 프로젝트이다.
*Maven 기반의 프로젝트를 구동시키기 위해 Maven과 M2 Plugin을 설치하는 것이 필요하다.

==Maven과 M2 Plugin 설치하기==
*아래의 JCF tutorials의 개인 개발환경에서 지시하는 내용에 따라 개발환경을 구성한다.

{{정보|
*JCF 개인 개발환경 구성: [http://wiki.dev.daewoobrenic.co.kr/mediawiki/index.php/%EA%B5%90%EC%9C%A1%EC%9A%A9_%EA%B0%9C%EB%B0%9C%ED%99%98%EA%B2%BD_%28%EA%B0%9C%EC%9D%B8%29 이동]
}}

==로컬 라이브러리 저장소로 install하기==
*개인 개발환경이 구성되면 Maven과 M2 Plugin의 사용이 가능하다.
*spring-batch-infrastructure로부터 spring-batch-samples까지 M2 eclipse를 활용하여 다음과 같이 install한다.
<pre>
1. install의 순서
1) spring-batch-infrastructure
2) spring-batch-core (spring-batch-infrastructure에 대한 dependency 존재)
3) spring-batch-samples
4) spring-integration-batch (Optional)
</pre>

===spring-batch-infrastructure===
*다음과 같이 Maven install 명령을 실행하여 spring-batch-core가 install 될 수 있는 환경을 구축한다.

[[그림:SpringBatch_Infrastructure_Maven_Install.JPG|600px|thumb|center|spring-batch-infrastructure 프로젝트의 Run as 메뉴에서 Maven install 실행하기]]

*Maven install 명령을 실행하면 다음과 같이 시작하며 task-segment: [install]은 다음과 같은 순서로 task를 처리한다.

<pre>
1. resources:resources
2. compiler:compile
3. resources:testResources
4. compiler:testCompile
5. surefire:test
6. jar:jar
7. source:jar
8. bundle:manifest
9. install:install
</pre>
*Maven install이 시작되었을 때의 콘솔화면이다.
[[그림:SpringBatch_Infrastructure_Maven_Install_Start.JPG|700px|thumb|center|install 시작]]
*Maven install이 종료되었을 때의 콘솔화면이다.
[[그림:SpringBatch_Infrastructure_Maven_Install_End.JPG|800px|thumb|center|install 종료]]

===spring-batch-core===
*spring-batch-core는 다음과 같이 spring-batch-infrastructure에 대한 dependency가 존재한다.

<code lang="xml">
<dependency>
<groupId>org.springframework.batch</groupId>
<artifactId>spring-batch-infrastructure</artifactId>
<version>${project.version}</version>
</dependency>
</code>

[[그림:SpringBatch_Core_Maven_Install.JPG|600px|thumb|center|spring-batch-core 프로젝트의 Run as 메뉴에서 Maven install 실행하기]]

*Maven install을 클릭하면 콘솔 View에 다음과 같이 install task의 시작을 알린다.
*Maven install 명령을 실행하면 다음과 같이 시작하며 task-segment: [install]은 다음과 같은 순서로 task를 처리한다.

<pre>
1. antrun:run
2. resources:resources
3. compiler:compile
4. resources:testResources
5. compiler:testCompile
6. surefire:test
7. jar:jar
8. statemgmt:start-fork
9. antrun:run
10. statemgmt:end-fork
11. source:jar
12. statemgmt:clear-fork-context
13. bundle:manifest
14. install:install
</pre>
*Maven install이 시작되었을 때의 콘솔화면이다.
[[그림:SpringBatch_Core_Maven_Install_Start.JPG|700px|thumb|center|install 시작]]
*Maven install이 종료되었을 때의 콘솔화면이다.
[[그림:SpringBatch_Core_Maven_Install_End.JPG|900px|thumb|center|install 종료]]

===spring-batch-samples===
*samples는 spring-batch-infrastructure와 spring-batch-core에 대한 dependency를 가지고 있다.
*따라서 spring-batch-infrastructure와 spring-batch-core에 대한 install이 선행된 후에 samples에 대한 install이 가능하다.
*다음은 spring-batch-samples 프로젝트에 있는 pom.xml 파일의 dependency의 일부분이다.

<code lang="xml">
<dependency>
<groupId>org.springframework.batch</groupId>
<artifactId>spring-batch-core</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.batch</groupId>
<artifactId>spring-batch-infrastructure</artifactId>
<version>${project.version}</version>
</dependency>
</code>

*spring-batch-samples 프로젝트도 다른 프로젝트와 마찬가지로 Maven install을 실행한다.
*Maven install이 실행하면 task-segment: [install]은 다음과 같은 순서로 task를 처리한다.

<pre>
1. antrun:run
2. resources:resources
3. compiler:compile
4. resources:testResources
5. compiler:testCompile
6. surefire:test
7. jar:jar
8. statemgmt:start-fork
9. antrun:run
10. statemgmt:end-fork
11. source:jar
12. statemgmt:clear-fork-context
13. install:install
</pre>

*Maven install이 시작되었을 때의 콘솔화면이다.
[[그림:SpringBatch_Samples_Maven_Install_Start.JPG|700px|thumb|center|install 시작]]
*Maven install이 종료되었을 때의 콘솔화면이다.
[[그림:SpringBatch_Samples_Maven_Install_End.JPG|700px|thumb|center|install 종료]]

==test 실행하기==
*Maven install 이후에 Maven에 대하여 다음과 같이 선택적인 실행이 가능하다.

<pre>
1. Maven build
2. Maven build...
3. Maven clean
4. Maven generate-sources
5. Maven install
6. Maven test
</pre>

*따라서 test만 실행하기 위해서는 Maven test를 실행하여 콘솔을 통해 실행과정을 모니터링할 수 있다.
*각 TestCase를 별도로 실행하는 것도 가능하다.

=주요 TestCase 이해하기=

==별도로 spring-batch TestCase 실행시키기==

Spring Batch Use Cases

Kyoung94 — Thu, 24 Jul 2008 09:30:31 GMT

바꾼내용 간추리기:

{{팁|
*산출물: Spring Batch Use Cases 이해하기
*작성자: 서경진
*최초작성일 : 2008/07/24
*최종작성일 : 2008/08/01
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
{{정보|
* 이 문서에는 Spring Batch Use Cases에 대하여 설명한 것이다.
}}
{{경고|
*이 문서는 현재 작성중에 있습니다.
}}

=Spring Batch Use Cases 분석=

==UserCase No.1: Simple Batch Repeat==
*목적
**데이터 item이나 메시지를 처리하는 것과 같은 단순 작업(operation)을 모든 배치 범위내에서 트랜잭션을 보장하면서 정해진 횟수만큼 반복한다.
**트랜잭션 자원은 성능적인 잇점을 유도하기 위해서 모든 작업간에 공유된다.

*범위

==UserCase No.2: Automatic Retry After Failure==

==UserCase No.3: Commit Batch Process Periodically==

==UserCase No.4: Asynchronous Chunk Processing==

==UserCase No.5: Copy File to File in a Batch==

==UserCase No.6: Massively Parallel Batch Processing==

==UserCase No.7: Manual Restart After Failure==

==UserCase No.8: Sequential Processing of Dependent Steps==

==UserCase No.9: Partial Processing==

==UserCase No.10: Whole-Batch Transaction==

==UserCase No.11: Scheduled Processing==

Ext-js grid combol

Mariaro — Thu, 24 Jul 2008 08:35:12 GMT

바꾼내용 간추리기: New page: ==Grid에서 콤보처리== 그리드에서 일반적인 텍스트 입력이 아닌 콤보처리시 선택후 화면 display value가 보여지지 않고 코드값이 보여지므로 이...

==Grid에서 콤보처리==
그리드에서 일반적인 텍스트 입력이 아닌 콤보처리시 선택후 화면 display value가 보여지지 않고 코드값이 보여지므로
이에 대한 처리법을 다루도록 한다.

*이 콤보처리에서의 문제점
**현재는 콤보값 렌더링 부분이 IE에서만 동작하고 있으므로 주의하도록 한다.

==콤보 선언==
<code>
var statusCombo = new Ext.form.ComboBox({
store: cbStore,
valueField: 'abbr',
displayField:'state',
typeAhead: true,
editable: true,
mode: 'local',
triggerAction: 'all',
lazyRender:true,
listClass: 'x-combo-list-small',
emptyText:'Select a state...',
selectOnFocus:true
});
</code>

==그리드에 콤보 넣기==
이 콤보컨트롤을 그리드에 추가해야 하므로,
<code>
ColumnModel 선언시 넣도록 한다.
var cm = new Ext.grid.ColumnModel([
checkColumn,
{
header: "요청/장애#", // 헤더 타이틀
dataIndex: 'id', // 매핑되는 컬럼명
align: 'center'
},{
header: "제목",
dataIndex: 'title',
align: 'left'
},{
id:'state',
header: "상태",
dataIndex: 'status',
align: 'center',
'''editor: statusCombo,'''
renderer:Ext.jcf.Combo(statusCombo)
},
...
]);
</code>

여기에 renderer를 추가시키면 된다.
renderer는 '''Ext.jcf.Combo'''를 사용하고 이에 대한 param 값은 콤보컨트롤 명을 넣도록 한다.

Ext-js paging

Mariaro — Wed, 23 Jul 2008 08:15:43 GMT

바꾼내용 간추리기:

==Paging 처리==
Ext.jcf.Grid 를 이용하여 페이징된 그리드를 처리한다.
*생성할 파일
**comCiMng.jsp : 전체화면을 구성하는 jsp
**comCiMng.js : 그리드와 store 핸들링을 처리하는 js 파일
*그 외 사용할 공통 스크립트 파일
**/js/ext/adapter/ext/ext-base.js
**/js/ext/ext-all.js
**/js/Ext.jcf.Common.js
**/js/Ext.jcf.Form.js
**/js/Ext.jcf.FormType.js
**/js/Ext.jcf.Grid.js
**/js/common_grid.js
[[그림:edit_grid_ext.jpg]]
==js 파일 등록==
먼저 JSP 파일에 필요한 js 파일을 사용할수 있도록 추가한다.
<code lang="xml">
<script type="text/javascript" src="../../js/ext/adapter/ext/ext-base.js"></script>
<script type="text/javascript" src="../../js/ext/ext-all.js"></script>
<script type="text/javascript" src="../../js/gmdat-common.js"></script>
<script type="text/javascript" src="../../js/Ext.jcf.Common.js"></script>
<script type="text/javascript" src="../../js/Ext.jcf.Form.js"></script>
<script type="text/javascript" src="../../js/Ext.jcf.FormType.js"></script>
<script type="text/javascript" src="../../js/Ext.jcf.Grid.js"></script>
<script type="text/javascript" src="../../js/common_grid.js"></script>
</code>

==검색필드 만들기 : 입력값 정의==
위 그림처럼 검색하기 위한 검색 항목이 있는데, 다음과 같이 지정한다.
===JSP===
<code lang="xml">

<table id="s_table_header_1" border="1" cellspacing="0" cellpadding="0"
bordercolordark="white" bordercolorlight="#C0C0C0" width="100%">
<tr>
<td>CI분류명</td>
<td colspan=3><input id="shCiClassName"></td>

<td>분류레벨</td>
<td><input id="shCiClassLevel"></td>

<td>소속사</td>
<td><input id="shCompCode"></td>
</tr>
<tr>
<td>대분류</td>
<td><input id="shCiClassLev1"></td>
<td>중분류</td>
<td><input id="shCiClassLev2"></td>
<td>소분류</td>
<td><input id="shCiClassLev3"></td>
<td>세분류</td>
<td><input id="shCiClassLev4"></td>
</tr>
</table>
</code>

===js===
Ext.form.Combo의 생성은 기존의 문서를 참조하도록 한다.
일반 텍스트 필드의 경우 다음과 같이 정의한다.
getTextField 함수는 앞서 호출한 Ext.jcf.Form에 정의되어 있으므로 따로 함수선언을 하지 않아도 된다.
<code>
//1 . 입력 값 정의
fmCiClassName = getTextField('shCiClassName', 120, 20);
fmCiClassLevel = getTextField('shCiClassLevel', 120, 20);
fmCompCode = getTextField('shCompCode', 120, 20);
</code>
다음 page 호출시 application/json 형태가 아닌 일반 HttpRequest 형태로 넘어가므로,
이 값들을 저장하고 있다가 넘겨줄 수 있도록 아래의 처리를 추가한다.
<code>
//2. 다음 paging 처리시 넘겨줘야 할 param 값을 Ext.jcf.HiddenForm에 담는다.
fmSrchForm = new Ext.jcf.HiddenForm('/dsom/comCiMng/allComCiMngs.action', [fmCiClassName,fmCiClassLevel,fmCompCode,ciClassLevel1,ciClassLevel2,ciClassLevel3,ciClassLevel4])
setFormPanelElements(false,fmSrchForm);
</code>

Ext.jcf.HiddenForm은 이후 호출할때의 주소와 넘겨줄 값들에 대해 정의한 것이며,
이것을 FormPanel로 등록하도록 한다.

==Column 정보 생성==
화면의 그리드상에 보여줄 컬럼에 대한 정의를 한다.
Ext.jcf.ColumnConfig를 이용하여 정의하며,
add("헤더명","실제 보여줄 attribute값",사이즈,정렬)이 기본이다.
<code>
var config = new Ext.jcf.ColumnConfig();
config.add("분류ID",'ciClassId', 25,'center');
config.add("분류명",'ciClassName',250, 'left', null, null, new Ext.form.TextField({allowBlank: false,maxLength:153}));
config.add("분류레벨", 'ciClassLevel', 25,'center');
config.add("상위분류", 'upperCiClassId',25,'center');
config.add("사용여부", 'activeFlag', 15,'center');
config.add("고객사",'compCode', 90,'center');
config.add("비고", 'ciClassDesc', 150,'center');
</code>
분류명과 같이 에디팅이 필요한 항목일 경우 에디터(Ext.form.TextField)를 추가한다.
config.add("분류명",'ciClassName',250, 'left', null, null, '''new Ext.form.TextField({allowBlank: false,maxLength:153})''');

==Grid 선언==
Ext.jcf.Grid를 선언하는데, 이때 페이징일 경우 type을 paging으로 선언한다.

<code>
grid = new Ext.jcf.Grid({
'''type: 'paging'''', //'basic', 'detail'
single: true,
width: 'auto',
height: 180,
clicksToEdit:1,
paging: {
'''store: ciStore''',
display: 'text',
value: 'value',
xtype: 'bbar'
},
panel: {
title: '',
render: 'ciMngList',
width: 'auto',
height: 260,
resize: true
},
listeners: {//그리드 관련 이벤트 정보
beforeedit : function(e) {
var action = e.record.get(ACTION_FIELD);
if(action == DELETE_RECORD) return false;
},
validateedit : function (e){
if (e.field == 'ciClassName'){
var val = e.value.toUpperCase();
}
},
afteredit : function(e) {
editRecord(e.record);
e.record.set(e.field, e.value.toUpperCase());
},
rowclick: function(grid, index) {
var record = grid.getStore().getAt(index);
selectedRecord = record;
}
},
columns: config.getConfig()
});
</code>

==레코드 정의==
<code>
//3-3. CI분류 Records 정의
var CiClass = Ext.data.Record.create([
{name: 'flag', type: 'string'},
{name: 'ciClassId', type: 'string'},
{name: 'ciClassName', type: 'string'},
{name: 'ciClassLevel', type: 'string'},
{name: 'upperCiClassId',type: 'string'},
{name: 'compCode', type: 'string'},
{name: 'activeFlag', type: 'string'},
{name: 'ciClassDesc', type: 'string'}
]);
</code>

==Store 정보 생성==
JsonStore를 생성하여 앞서 정의한 record를 field를 지정하고,
listener에 loadStoreBaseParams를 추가하면서 처음 선언한 HiddenForm을 담도록 한다.
<code>
//3-4. Paging 데이터 바인딩을 위한 Store 정의
ciStore = new Ext.data.JsonStore({
url: '/dsom/comCiMng/allComCiMngsForPaging.action',
root:'allCiClass.list',
totalProperty: 'allCiClass.totalSize',
id: 'ciClassId',
forceFit :true,
fields:CiClass,
listeners:{
beforeload:function(store){
loadStoreBaseParams(store,fmSrchForm);
}
}
});
</code>

==Grid 생성==
grid를 생성하면서 jsonStore를 담는다.
<code>
// 4. Grid 생성
grid.create(ciStore);
</code>

Jquery calendar

Mariaro — Tue, 22 Jul 2008 06:54:10 GMT

바꾼내용 간추리기: /* 결과 화면 보기 */

==개요==
웹 화면에서 날짜 선택시 많이 사용되는 달력 컴포넌트의 사용법이다.
*달력 컴포넌트는 아래 조건을 만족하도록 한다.
**기존 달력 컴포넌트의 경우 ComboBox와 중복될 경우 Combo 아래에 달력이 생성되어 문제가 되었으므로 이를 보완할 수 있도록 한다.
**가급적 웹표준을 준수하고 자바스크립트의 코딩이 간결해 지도록 한다.
**다른 컴포넌트나 폼요소와의 종속성을 배제한다.

==jQuery의 Datepicker==
===입력할 항목 확인===
현재 예는 게시기간을 입력하는 부분에서 시작일과 종료일 텍스트 입력항목에 달력을 추가하고자 한다.
<code lang="xml">
<tr>
<td bgcolor="F2F2F2">게시기간
<td bgcolor="#FCFCFC">
<s:textfield id="strFromDate" name="notice.strFromDate" theme="simple" size="10" readonly="true"/> ~
<s:textfield id="strToDate" name="notice.strToDate" theme="simple" size="10" readonly="true"/>
</td>
</tr>
</code>

===StyleSheet와 Js 파일 추가하기===
JQuery의 달력은 몇 가지 종류가 있지만, 그간 프로젝트에서 가장 선호하는 형태이자 (상단에 년월이 표시되는) 달력의 모양도 CSS를 통해 수정이 용이하므로
다음을 사용하도록 한다.
우선 달력을 추가하기 위해 화면에 다음을 추가한다.
* StyleSheet
** flora.datepicker.css
** datePicker.css
* JavaScript
** datepicker.js
** ui.datepicker.js
<code lang="xml">
<link rel="stylesheet" href="css/flora.datepicker.css"
type="text/css" media="screen" title="Flora (Default)">
<link rel="stylesheet" href="css/datePicker.css" type="text/css"/>
<script src="js/jquery/datepicker.js"></script>
<script src="js/jquery/ui.datepicker.js"></script>
</code>

===입력항목에 달력추가 스크립트 작성하기===
문서의 ready 부분에 다음을 추가한다.
이 때, # 부분에 들어가는 값은 입력 텍스트 필드의 id 명을 의미한다.
지금 시작일(id:strFromDate)과 종료일(id:strToDate) 두 필드에 넣고자 하므로,
다음과 같이 작성한다.
<code lang="xml">
<script>
$(document).ready(function(){
$('#strFromDate').datepicker();
$('#strToDate').datepicker();
});
</script>
</code>

==결과 화면 보기==
다음과 같이 텍스트 필드를 클릭시 달력이 화면에 뿌려지는지 확인한다.<br />
[[그림:jquery_cal.jpg]]

WebStandard extJS

Alsdkzz — Wed, 16 Jul 2008 02:07:39 GMT

바꾼내용 간추리기: /* 준비사항 */

{{팁|
* 산출물 : 일반웹 grid에서 extJS 느낌내기
* 작성자 : 김민아
* 최초작성일 : 2008/07/16
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
{{정보|이곳은 일반 jsp table을 extJS 그리드로 바꾸는 예제에 대해 다룬다.}}
=샘플화면보기=
[http://extjs.com/deploy/dev/examples/grid/from-markup.html 보러가기]
=준비사항=
*ext-base.js
*ext-all.js
*ext-all.css

=jsp 파일보기 =
*밑의 예제에서와 같이 ext-base.js, ext-all.js, ext-all.css를 import 시킨다.(이파일은 extJs사이트에서 다운받도록 한다.)
*밑에서 설명할 comUsr.js파일도 import시킨다.

<code lang="jsp">
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<%@ page contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">

<script type="text/javascript"
src="/../js/ext/adapter/ext/ext-base.js"></script>
<script type="text/javascript" src="/../js/ext/ext-all.js"></script>

<link rel="stylesheet" type="text/css"
href="/../js/ext/resources/css/ext-all.css" />

<script type="text/javascript" src="/../jcf/biz/comUsr.js"></script>

</head>
<body>
<h1><s:text name="사용자 관리" /></h1>
...

<s:form name='userList' action="delComUsrList.action">

<table cellspacing="0" width="550" id='usrGrid'>
<thead>
<tr>
<th align="center">사번</th>
<th align="center">성명</th>
<th align="center">소속사</th>
<th align="center">부서</th>
</tr>
</thead>
<tbody>
<s:iterator value="userList">
<tr>
<td align="center"><s:property value="empId" /></td>
<td align="center"><s:property value="userName" /></td>
<td align="center"><s:property value="compCode" /></td>
<td align="center"><s:property value="deptId" /></td>
</tr>
</s:iterator>
</tbody>
</table>


</s:form>
</body>
</html>
</code>

=js파일 보기(comUsr.js)=
*밑의의 소스를 그대로 복사에서 사용하되 "usrGrid"는 jsp파일의 table으로 id이므로 이부분만 바꾸어준다.

<code lang="javascript">
/*
* Ext JS Library 2.0.2
* Copyright(c) 2006-2008, Ext JS, LLC.
* licensing@extjs.com
*
* http://extjs.com/license
*/

Ext.onReady(function() {
Ext.QuickTips.init();
gridBind();

function gridBind(){
// create the grid

var grid = new Ext.grid.TableGrid("usrGrid", {
stripeRows: true // stripe alternate rows
});
grid.render();
}

});

/**
* @class Ext.grid.TableGrid
* @extends Ext.grid.Grid
* A Grid which creates itself from an existing HTML table element.
* @constructor
* @param {String/HTMLElement/Ext.Element} table The table element from which this grid will be created -
* The table MUST have some type of size defined for the grid to fill. The container will be
* automatically set to position relative if it isn't already.
* @param {Object} config A config object that sets properties on this grid and has two additional (optional)
* properties: fields and columns which allow for customizing data fields and columns for this grid.
* @history
* 2007-03-01 Original version by Nige "Animal" White
* 2007-03-10 jvs Slightly refactored to reuse existing classes
*/
Ext.grid.TableGrid = function(table, config) {
config = config || {};
Ext.apply(this, config);
var cf = config.fields || [], ch = config.columns || [];
table = Ext.get(table);

var ct = table.insertSibling();

var fields = [], cols = [];
var headers = table.query("thead th");
for (var i = 0, h; h = headers[i]; i++) {
var text = h.innerHTML;
var name = 'tcol-'+i;

fields.push(Ext.applyIf(cf[i] || {}, {
name: name,
mapping: 'td:nth('+(i+1)+')/@innerHTML'
}));

cols.push(Ext.applyIf(ch[i] || {}, {
'header': text,
'dataIndex': name,
'width': h.offsetWidth,
'tooltip': h.title,
'sortable': true
}));
}

var ds = new Ext.data.Store({
reader: new Ext.data.XmlReader({
record:'tbody tr'
}, fields)
});

ds.loadData(table.dom);

var cm = new Ext.grid.ColumnModel(cols);

if (config.width || config.height) {
ct.setSize(config.width || 'auto', config.height || 'auto');
} else {
ct.setWidth(table.getWidth());
}

if (config.remove !== false) {
table.remove();
}

Ext.applyIf(this, {
'ds': ds,
'cm': cm,
'sm': new Ext.grid.RowSelectionModel(),
autoHeight: true,
autoWidth: false
});
Ext.grid.TableGrid.superclass.constructor.call(this, ct, {});
};

Ext.extend(Ext.grid.TableGrid, Ext.grid.GridPanel);
</code>

=주의사항=
*경로설정주의
**js파일과 css파일의 경로가 정확해야한다.(FireFox의 FireBug로 보았을 때 위에서 설명한 js파일과 css파일이 잘 import되어있어야 한다.)
*별도의 CSS 생략
**위에서 import한 CSS외에는 임으로 CSS를 적용하지 않도록 한다.(그리드에 css중복 적용됨)
*jsp파일의 제일 상단 주의
**jsp파일의 제일 상단이 밑에와 같이 시작되어야한다.그렇지 않으면 grid가 깨진다.
<pre>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<%@ page contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
</pre>

Grid에서 checkbox선택하기

Alsdkzz — Tue, 08 Jul 2008 05:42:16 GMT

바꾼내용 간추리기:

*표준웹을 사용할 경우 삭제는 Grid에서 check박스를 클릭하여 삭제하도록 한다.
=그리드에서 checkbox 구현하기=
*jsp파일
<code lang="javascript">
<?xml version="1.0" encoding="UTF-8" ?>
<%@ page contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<%@taglib uri="/WEB-INF/tld/app.tld" prefix="app"%>
<html>
<head>

<SCRIPT language='javascript' type='text/javascript'>
var userId=document.getElementsByName('userId');
function submit()
{
document.the-table.submit();
}
</SCRIPT>
</head>
<body>

<s:form name='userList' action="delComUsrList.action">

<table cellspacing="0" id="the-table">
<thead>
<tr>
<th>삭제 //checkbox head</th>
<th align="center">ID</th>
</tr>
</thead>
<tbody>
<s:iterator value="userList">
<tr>
<td align="center">
//input type을 checkbox로 지정하고 name은 userId value는 userId로 지정하여 Action에서 userId라는 리스트로 value값을 받을 수 있게함

<input type="checkbox" name="userId" value='<s:property id="userId" value="userId" />'>
</td>
<td align="center"><s:property value="empId" /></div>
</td>
</tr>
</s:iterator>
</tbody>

</table>

</s:form>

</body>
</html>
</code>
=Action에서delete함수 구현하기=
*Action의 delete함수
**여기서 userId는 jsp의 checkbox에서 name으로 지정한 값이다.
<code lang="java">
private String[] userId;
public String delComUsrList() {
userService.delUsrList(userId);
return SUCCESS;

public String[] getUserId() {
return userId;
}
public void setUserId(String[] userId) {
this.userId = userId;
}
</code>

Ext-js common script

Alsdkzz — Tue, 08 Jul 2008 04:42:18 GMT

바꾼내용 간추리기: /* 공통스크립트 리스트 */

=공통스크립트 리스트=
[[그림:commonscript.jpg|800px|center]]

=사용방법=
*toUpperCase – 영문글자열을 대문자로 변환
예)
<code lang="jsp">
<td class="Mbox_bg">
<input type="text" id="m_oper" size="15" maxlength="10" class="Mbox_C" onBlur="toUpperCase(id)">
</td>
</code>

*참조) gmdat_common.js 의 toUpperCase
<code lang="java">
/*
* 받은 영문글자열을 대문자로 바꾸기
*/
function toUpperCase(Uid) {
var Uname = document.getElementById(Uid).value;
if (Uname == "" || Uname == 0)
{
return;
}
else
{
Uname = Uname.toUpperCase();
document.getElementById(Uid).value = Uname;
}
}</code>
*showCalendar – 달력 생성
밑의 예제는 gageMast[1].jsp 파일의 일부이다. onClick 이벤트를 showCalendar 로 지정하여 달력팝업창을 나타낸다.. 여기서 'm_regiDate'는 달력팝업창에서 선택할 날짜를 입력할 input의 id이고, 'cal3'은 달력팝업창을 띄울 div의 id이다.
<code lang="jsp">
<td class="Mnn_label" nowrap width='10%'>등록일자</td>
<td class="Mbox_bg">
<input type="text" id="m_regiDate" size="15" maxlength="8" class="Mbox_D"
isDate="Y" readonly>
<input type="button" class="submit1" value="달력"
onClick="showCalendar('m_regiDate', 'cal3');"/>
<div id="cal3" style="position:absolute; left:224; top:360; z-index:1"></div>
</td>

</code>
*참조) gmdat_common.js 의 showCalendar
<code lang="js">
/*
* calendar 생성
*/
function showCalendar(domId, posiId) {
var cal = new Ext.DatePicker({
dayNames : ['일','월','화','수','목','금','토'], // 요일의 이름을 넣어줍니다.
monthNames : ['1월','2월','3월','4월','5월','6월','7월','8월','9월','10월','11월','12월'], // 월 이름 이구여
format : "Y년 m월 d일", // 기본 데이타 형식입니다.
disabledDays : null,
disabledDaysText : "사용불가",
disabledDates : null,
disabledDatesText : "사용불가",
minValue : null,
maxValue : null,
minText : "필드 안의 날짜는 반드시 {0}의 이후이어야 한다. ",
maxText : "필드 안의 날짜는 반드시 {0}의 이전이어야 한다. ",
invalidText : "{0} 은 유효한 날짜가 아닙니다. - 반드시 {1}과 같은 형식이어야 합니다.",
nextText : "다음 달(Ctrl+Right)",
prevText : "이전 달(Ctrl+Left)",
todayText : "오늘은 {0}" // 처음 생성하면 하단에 Today라고 버튼이 있는데 그 버튼의 메세지를 바꿔줍니다. 이미지에서는 이미 바뀐 상태입니다.
});
cal.setValue(new Date()); // 오늘 날짜로 달력을 셋팅합니다.
cal.render(posiId);
cal.on('select', function(cal, date) {
Ext.get(domId).dom.value = formatDate(date);
cal.destroy();
});
} ‘

</code>
*numberOnly - 숫자만 입력 가능하도록 설졍
밑의 예제는 gageMast[1].jsp 파일의 일부이다. onkeypress 이벤트를 numberOnly 로 지정하여 오직 숫자만 입력할 수 있도록 설정한다.
<code lang='jsp'>
<td class="Mbox_bg">
<input type="text" id="m_acquCost" size="15" maxlength="50" class="Mbox_F" isAmt="Y" onBlur="setCurrency(id)" onkeypress="numberOnly()">
</td>
</code>

*참조) gmdat_common.js 의 numberOnly
<code lang='js'>
function numberOnly() {
var input_key = event.keyCode;
if (!(isNumber( input_key )))
{
event.keyCode = '0';
return false;
}
</code>

Ext-js code

Alsdkzz — Tue, 08 Jul 2008 04:34:24 GMT

바꾼내용 간추리기: New page: =javascrpt파일= ==findCode함수== *화면이 로딩될 때 코드값을 가져오는 메소드(findCode)를 onReady메소드 안에 넣는다. *findCode 메소드에서는 Ext.Ajax.r...

=javascrpt파일=
==findCode함수==
*화면이 로딩될 때 코드값을 가져오는 메소드(findCode)를 onReady메소드 안에 넣는다.
*findCode 메소드에서는 Ext.Ajax.request라는 메소드 사용하여 서버에request를 보낼 url 을 지정한다. 서버로부터 값을 제대로 받아왔는지 확인하기 위해 success 와 failure을 지정해주고 success function 안에는 try /catch 문을 선언한다.
*alert(r.responseText)을 통해 받아온 JSON 데이터값을 alert창으로 확인한다.
*cbStore3.loadData 로 cbStore3라는 JsonStore 에 받아온 데이터 중 해당되는 데이터를 담는다.
<code lang="javescript">
Ext.onReady(function(){
findCode();
}
</code>

<code lang="javescript">
function findCode(){
params = "{" + "}"

Ext.Ajax.request({
url: '/mdms/deptInfo/findCodes.action',
jsonData: params,
headers: {
'Content-Type': 'application/json'
},
success: function( r, o ) {
alert(r.responseText);
try {
cbStore3.loadData(Ext.decode(r.responseText));

} catch(e) {
}
},
failure: function( r, o ) {
alert("ERR"+r.responseText);
}
})

}
</code>
==JsonStore==
*cbStore3는 findCode에서 받아온 데이터를 저장하기 위한 JsonStore 이다. New Ext.data.JsonStore 로 cbStore3 라는 JsonStore 를 생성한다. root에는 action의 return 값을 fields에는 List로 받은 return 값의 각Object들을 넣는다. '

<code lang="javescript">
//#########################################################################
/*
* JsonStore 생성
*/
// ###########################################################################
var cbStore3 = new Ext.data.JsonStore({
root:'inspTrgtList',
fields: [ 'id', 'name', 'parentId']
});
</code>
7.3.3. ComboBox
*new Ext.form.ComboBox 로 combo3라는 ComboBox를 생성한다
*밑의 예제에 있는 property들 중에 빨간글씨로 지정되어 있는 것들은 모든 ComboBox마다 해당되는 데이터를 바인딩하고, 그 외의 것들은 밑에 예제와 동일하게 지정한다.
<code lang="javescript">
/*
* 콤보박스 생성
*/
var combo3 = new Ext.form.ComboBox({
store: cbStore3,
displayField:'name',
valueField: 'id',
typeAhead: true,
mode: 'local',
triggerAction: 'all',
emptyText:'Select a state...',
selectOnFocus:true,
editable: true,
applyTo: 'm_inspTrgtCode'
});
</code>
*Preperty 설명)
** Store: 바인딩할 store 지정,
** displayField : 화면에 보여지는 text 값
** valueField: 실제 저장되는 value 값
** Mode: local data를 로당할지 server에서 data를 가져와 로딩할지 여부 (local은 local data를 로드한다는 뜻이고 remote는 server로부터 data를 로드한다는 뜻이다)
** triggerAction: 이미 선택된 값 외의 코드값도 선택할 수 있게할지 여부( triggerAction을 all이라고 지정하지 않는다면 이미 값이 있거나, 한번 선택된 코드값은 수정할 수 없음)
** emptyText : combox에 값이 바인딩이 되지 않았을 때 기본으로 보여지는 텍스트
** selectOnFocus: combox를 클릭했을 때, combox에 바인딩된 데이터를 Focus 할지 여부이다. (True로 설정해놓았으면, combox를 클릭했을 때, combox에 바인딩된 데이터가 파란네모박스 안에 흰글씨로 Focus 됨)
** Editable: combox 수정여부(ombox에서 선택하기 않고 직접입력이 가능하도록 설정하고 싶다면 true로 지정)
** applyTo: 실제 바인딩 할 jsp파일의 id

JCF WebStandard

Alsdkzz — Tue, 08 Jul 2008 02:53:44 GMT

바꾼내용 간추리기:

{{정보|JCF에서는 그리드 상에서 editing이 필요한 경우에서만 ext-js를 사용하도록 권장한다.}}
*Ext JS를 이용한 개발
**[[Ext-JS CRUD|Ext JS 그리드에서 CRUD만들기]]
**[[ext-js paging|Ext JS 그리드에서 페이징처리하기]]
**[[exj-js multi grid|연관된 2개의 Ext JS 그리드 처리하기]]
**[[ext-js code|Ext JS에서 코드처리하기]]
**[[ext-js linked combo| Ext JS Linked Combo Box 처리]]
**[[ext-js grid combol | Ext JS 그리드에서 Combo box 사용 시, Display 값 표시하기]]
**[[ext-js common script|Ext JS 공통스크립트 사용하기]]
*웹표준 기술을 이용한 개발
**[[webStandard_extJS|일반 그리드에서 ext-js느낌내기]]
**[[EDU USER DEV|CRUD만들기]]
**[[grid에서 checkbox선택하기]]
**[[Paging|페이징처리하기]]
**[[사용자주소 코드처리|코드처리하기]]
**[[jquery calendar|JQuery를 이용한 달력 만들기]]
*기타 자료들
**[[Naming Convention|네이밍 표준 규칙]]
**[[JCF3 id|채번관리하기(id생성)]]
**[http://trirand.com/jqgrid/jqgrid.html# jqGrid]
**[http://www.webplicity.net/flexigrid/# Flexigrid for jQuery]
**[http://ajaxian.com/archives/extending-firebug-tutorials# Extending Firebug Tutorials]

JcfRoadMap ReferenceArchitecture

Kyoung94 — Mon, 07 Jul 2008 07:33:17 GMT

바꾼내용 간추리기:

{{팁|
*산출물: JCF 로드맵과 발전방향
*작성자: 서경진
*최초작성일 : 2008/07/07
*최종작성일 : 2008/07/07
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
{{정보|
* 이 문서에는 JCF의 Reference Architecture를 기반으로 진행될 로드맵과 발전방향에 대하여 설명할 것이다.
}}
{{경고|
*이 문서는 현재 작성중에 있습니다.
}}

=JCF Reference Architecture=

[[그림:JCFReferenceArchitecture.JPG|910px|thumb|center|JCF Reference Architecture]]

=JCF RoadMap=

[[그림:JCFRoadMap.JPG|900px|thumb|center|JCF RoadMap]]

=JCF 발전방향=

==다중 채널 및 UI 통합(MCI: Multi-Channel Interface)==

==개발환경 고도화(CI & Agile)==

===개인개발환경===

===개발협업환경===

*개발 포탈

===CI환경===

*자동화

==공통모듈 고도화==

==SOA & Integration==

===웹서비스 (Web Services)===

===ESB (Enterprise Service Bus)===

==JCF 아키텍처 간소화==

==Metadata 통합관리==

==Runtime Patterns 정의==

==TDDx2 (Test Driven Development & Task Driven Development)==

Spring MVC ControllerWorkFlow

Kyoung94 — Mon, 07 Jul 2008 07:30:27 GMT

바꾼내용 간추리기:

{{팁|
*산출물: Spring MVC Architecturing
*작성자: 서경진
*최초작성일 : 2008/07/07
*최종작성일 : 2008/07/09
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
{{정보|
* 이 문서에는 Spring MVC에서 Request를 처리하는 WorkFlow에서 아키텍처를 결정하기 위한 구성요소들에 대하여 설명한 것이다.
}}
{{경고|
*이 문서는 현재 작성중에 있습니다.
}}

=Spring MVC 처리과정=
Spring MVC는 클라이언트의 요청을 처리하기 위해 다양한 클래스를 기반으로, 다음과 같은 처리과정을 통해 View를 제공하게 된다.
*일반적으로 모델 2 개발 방식의 최초 진입지점인 컨트롤러를 담당하는 대상이 서블릿인 것처럼, Spring MVC 또한 클라이언트의 요청이 처음으로 진입되는 지점으로 서블릿인 DispatcherServlet을 정의하였다(①). DispatcherServlet은 Spring MVC에서 가장 핵심적인 기능을 구현하고 있는 클래스로서 클라인언트로부터 발생한 하나의 요청을 처리하기 위하여 필요한 클래스들의 중계를 담당하는 역할을 한다.
*클라이언트로부터 요청이 들어오면 DispatcherServlet은 빈 설정파일에 정의되어 있는 HandlerMapping을 이용하여 요청 URL에 해당하는 Controller 객체를 얻게 된다(②). 빈 설정파일에 정의되어 있는 Controller는 일반적으로 요청 URL을 기반으로 정의되어 있다. 따라서 HandlerMapping은 요청 URL에 Mapping되어 있는 Controller를 DispatcherServlet에 반환하게 된다.
*DispatcherServlet은 HandlerMapping으로부터 Controller를 얻게되면 요청에 대한 모든 작업을 Controller에게 위임하게 된다(③).
*Controller는 Spring MVC를 구현하기 위하여 개발자들이 직접 구현을 담당하게 되는 부분으로 클라이언트로부터 전달된 인자에 대한 유효성 검증작업, 비즈니스 계층과의 통신, 비즈니스 계층에서 발생한 에러에 대한 처리, 작업 완료후 이동하게 될 뷰화면등에 대한 모든 처리를 담당하게 된다.
*Controller는 비즈니스 계층과의 통신을 완료한 다음 비즈니스 계층에서 전달된 모델 데이터와 클라이언트에게 보여줄 뷰 화면에 대한 정보를 ModelAndView 클래스에 담아서 DispatcherServlet에 반환하게 된다(④).
*DispatcherServlet으로 전달된 ModelAndView 클래스의 View정보는 View 객체(View Object) 또는 논리적인 View 이름(String)을 가지게 된다. ModelAndView 클래스에 저장되어 있는 View정보가 View 객체를 통하여 Controller에서 반환되었다면 DispatcherServlet은 View 객체를 이용하여 클라이언트에 화면을 출력하게 된다(⑥).
*그러나 ModelAndView에 저장되어 있는 View 정보가 논리적인 View 이름일 경우에는 빈 설정파일에 정의되어 있는 ViewResolver 클래스를 이용하여 클라이언트에게 출력할 View 객체를 얻게 된다(⑤).

[[그림:SpringMVC_RequestHandlingFlow.JPG|700px|thumb|center|Spring MVC Request 처리과정 및 대상 클래스 생명주기(원본:자바지기)]]

위에서 처럼 하나의 요청을 처리하기 위하여 관여하고 있는 클래스가 상당히 많다는 것을 알 수 있다. 그러나 요청을 처리하기 위하여 모든 클래스를 개발자들이 직접 구현할 필요는 없다. 하나의 요청이 추가될 때마다 개발자들이 구현할 필요가 있는 클래스는 Controller 클래스 하나뿐이다. 나머지 클래스는 Spring MVC에서 제공하는 클래스를 이용하여 구현하는 것이 가능하다. 물론 모델 데이터를 출력할 뷰 화면(JSP 또는 Velocity등) 또한 개발자들이 직접 구현해야 한다. 위에서 살펴보았던 대로 Spring MVC가 하나의 요청을 처리하기 위하여 실행되는 단계를 보면 그리 복잡하지 않은 것처럼 생각될 수 있다. 그러나 실질적인 Spring MVC의 복잡도는 유연성을 제공하기 위하여 지원되는 무수히 많은 옵션들 때문이다. Spring MVC는 웹 애플리케이션의 유연성을 지원한다는 명목하에 다양한 종류의 HandlerMapping, Controller, ViewResolver, View 클래스들을 지원하고 있다.

다시 한번 간단히 정리하면 다음과 같다.
<pre>
1. Resource에 대한 클라이언트의 Request
2. Spring Front Controller가 Request를 가로체서 적당한 Handler Mappings을 찿는다
3. Handler Adapters와 함께 디스패처 서블릿은 Controller에 Request를 디스패치한다.
4. Controller는 클라이언트 Request를 처리하고 FrontController에게 ModelAndView의 폼안에 Model과 View를 리턴한다.
5. Front Controller는 View Resolver 객체에게 문의하여 실제 View를 찿는다.
6. 클라이언트에게 선택된 뷰를 출력한다
</pre>

==HandlerMapping을 이용하여 URL과 Controller 연결하기==
HandlerMapping은 클라이언트가 요청한 URL과 Controller를 매핑하는 역할을 수행한다. 그 동작과정은 클라이언트 Request에 대하여 Dispatcher가 Requet와 Handling 객체맵에서 적당한 Handler Mapping을 찾는다. HanlerMapping은 클라이언트 URL이 Handler에게 매핑되는 방법을 제공한다. Spring MVC는 같은 기능을 지원하기 위하여 여러가지 옵션을 제공하고 있는데, Controller와 URL의 매핑하는 HandlerMapping 또한 여러 가지 방법을 제공하고 있다.

[[그림:SpringMVC_HandlerMapping.JPG|700px|thumb|center|HandlerMapping Interface의 계층구조]]

위의 그림은 Spring MVC가 제공하는 HandlerMapping의 다양한 방법을 구현한 클래스의 계층구조를 나타내고 있다. 실제적으로 HandlerMapping을 위해 Spring에서 제공하는 구현체는 다음과 같다.

*BeanNameUrlHandlerMapping
*SimpleUrlHandlerMapping
*CommonsPathMapHandlerMapping
*ControllerBeanNameHandlerMapping
*ControllerClassNameHandlerMapping
*DefaultAnnotationHandlerMapping

===BeanNameUrlHandlerMapping===
*BeanNameUrlHandlerMapping은 빈 이름과 URL을 Mapping한다.
*BeanNameUrlHandlerMapping을 이용하여 Mapping하는 방법은 Struts 프레임워크에서 사용하는 방법과 유사하므로 Struts 프레임워크를 사용하여 개발한 경험이 있다면 익숙하게 대응할 수 있다.
*Struts와 다른 점이라면 Spring MVC의 BeanNameUrlHandlerMapping은 매핑을 위한 경로정보로 ANT 빌드툴에서 경로정보를 표현하는 스타일을 사용할 수 있다.
**예를 들어 ANT 빌드툴에서 별표(*), 물음표(?)와 같은 기호들을 사용할 수 있듯이 BeanNameUrlHandlerMapping에서도 사용이 가능하다.
**<bean name="/*/.html" class="com.daewoobrenic.jcf.web.springmvc.BaseUrlFilenameViewController"/>
*빈 설정파일에 HandlerMapping이 설정되어 있지 않을 경우 Spring MVC는 BeanNameUrlHandlerMapping을 디폴트 HandlerMapping으로 설정한다.

===SimpleUrlHandlerMapping===
*SimpleUrlHandlerMapping은 매핑에 대한 정보를 각각의 Controller에서 설정하는 것이 아니라 하나의 저장소에서 관리한다.
*Controller를 개발하는 개발자들은 빈을 정의하기만 하고 이 Controller가 어떻게 매핑되어서 사용되는지에 대해서는 몰라도 된다.
*SimpleUrlHandlerMapping은 서블릿명-servlet.xml 파일에 다음과 같이 정의한다.

<code lang="xml">


......

<bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="mappings">
<props>
<prop key="**/*.html">staticViewController</prop>
......
<prop key="/user/listUser.do">userController</prop>
<prop key="/user/viewUser.do">userController</prop>
......
<prop key="/board/board.do">boardController</prop>
</props>
</property>
</bean>
......


<bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="mappings">
<bean class="org.springframework.beans.factory.config.PropertiesFactoryBean">
<property name="location">
<value>/WEB-INF/UrlMapping.properties</value>
</property>
</bean>
</property>
</bean>
......

</code>

*SimpleUrlHandlerMapping 방법 #2를 적용한 경우에는 UrlMapping의 프로퍼티를 설정하는 것이 필요하다.
*위의 xml에서 정의한 UrlMapping.properties에 다음과 같은 mapping 정보를 기술하면 된다.

<pre>
**/*.html=staticViewController

## user module mapping
/user/listUser.do=userController
/user/viewUser.do=userController

## board module mapping
/board/board.do=boardController
</pre>

*SimpleUrlHandlerMapping의 장점
**어플리케이션의 규모가 클 경우 매핑 정보를 수정할 필요가 있을 때 BeanNameUrlHandlerMapping보다 더 효율적으로 관리하는 것이 가능하다.
**개발자와 통합관리자가 분리된 경우 개발자는 매핑에 대한 문제에 신경쓰지 않고 Controller 클래스만 개발하면 된다.
**관리하는 입장에서 SimpleUrlHandlerMapping을 사용하면 mapping 정보를 통합하여 관리할 수 있다.

*SimpleUrlHandlerMapping의 단점
**Controller빈을 정의하고 매핑을 별도로 설정하는 불편함이 있다.
**개발자와 통합관리자가 동일한 경우 개발자는 SimpleUrlHandlerMapping을 사용하는 매핑 방법이 불편할 수도 있다.

BeanNameUrlHandlerMapping과 SimpleUrlHandlerMapping에 대한 사용방법은 현재 진행하고 있는 프로젝트가 어느 부분에 중점을 두고 있느냐에 따라 결정하면 된다.

===CommonsPathMapHandlerMapping===
*드믈게 사용되는 핸들러 매핑이다.
*컨트롤러의 소스파일에서 직접 URL 매핑을 지정하는 방법이다.
*다음과 같은 방법으로 설정하면 HandlerMapping을 제공할 수 있다.

<code lang="java">
/**
*@@ org.springframework.web.servlet.handler.commonsattributes.
*PathMap("/listUser.jsp")
*/
public class UserController{
......
}

/**
*@@ org.springframework.web.servlet.handler.commonsattributes.
*PathMap("/listCode.jsp")
*/
public class CodeController{
......
}
</code>

*클래스에서 CommonsAttribute 설정을 활성화하기 위해서 설정파일(서블릿명-servlet.xml)에 다음과 같은 설정이 필요하다.

<code lang="xml">
<beans>
......
<bean id="metaHandlerMapping" class="org.springframework.web.servlet.handler.metadata.CommonsPathMapHandlerMapping"/>
......
</beans>
</code>

===ControllerBeanNameHandlerMapping===
*BeanNameUrlHandlerMapping와 유사하게 URL과 빈이름을 매핑한다.
*차이점이 있다면 아래의 소스에서 확인할 수 있듯이 beanName을 기반으로 URL을 구성하는 방식이 다르다는 것이다.
*ControllerBeanNameHandlerMapping는 buildUrlsForHandler 메소드에서 Handler를 위한 mapping을 제공한다.
*generatePathMapping 메소드에서는 beanName과 선택적으로 지정된 urlPrefix와 urlSuffix를 조합하여 PathMap을 생성한다.

<code lang="java">
public class ControllerBeanNameHandlerMapping extends AbstractControllerUrlHandlerMapping {
private String urlPrefix = "";
private String urlSuffix = "";

......

protected String[] buildUrlsForHandler(String beanName, Class beanClass) {
List urls = new ArrayList();
urls.add(generatePathMapping(beanName));
String[] aliases = getApplicationContext().getAliases(beanName);
for (int i = 0; i < aliases.length; i++) {
urls.add(generatePathMapping(aliases[i]));
}
return StringUtils.toStringArray(urls);
}

/**
* Prepends a '/' if required and appends the URL suffix to the name.
*/
protected String generatePathMapping(String beanName) {
String name = (beanName.startsWith("/") ? beanName : "/" + beanName);
StringBuffer path = new StringBuffer();
if (!name.startsWith(this.urlPrefix)) {
path.append(this.urlPrefix);
}
path.append(name);
if (!name.endsWith(this.urlSuffix)) {
path.append(this.urlSuffix);
}
return path.toString();
}
......
}
</code>

<code lang="java">
public class BeanNameUrlHandlerMapping extends AbstractDetectingUrlHandlerMapping {
/**
* Checks name and aliases of the given bean for URLs, starting with "/".
*/
protected String[] determineUrlsForHandler(String beanName) {
List urls = new ArrayList();
if (beanName.startsWith("/")) {
urls.add(beanName);
}
String[] aliases = getApplicationContext().getAliases(beanName);
for (int i = 0; i < aliases.length; i++) {
if (aliases[i].startsWith("/")) {
urls.add(aliases[i]);
}
}
return StringUtils.toStringArray(urls);
}

}
</code>

===ControllerClassNameHandlerMapping===
*ControllerClassNameHandlerMapping도 마찬가지로 URL을 구성하는 방법이 다르다.
*pathMapping을 구성하는데 해당 클래스의 패키지명(packageName)에서 '.'을 '/'로 변경하여 기본 path를 구성한다.
*다음에 CONTROLLER_SUFFIX가 클래스 이름에 있는 경우 CONTROLLER_SUFFIX를 제거한 이름만 소문자로 구성하여 기본 path에 붙여 pathMapping을 구성한다.
*만약 MultiActionController인 경우에는 pathMapping과 그 하위에 있는 모든 요청을 처리하게 된다.
*MultiActionController가 아닌 경우에는 pathMapping에 정의된 모든 Controller 클래스로 요청을 매핑하게 된다.

<code lang="java">
public class ControllerClassNameHandlerMapping extends AbstractControllerUrlHandlerMapping {
/**
* Common suffix at the end of controller implementation classes.
* Removed when generating the URL path.
*/
private static final String CONTROLLER_SUFFIX = "Controller";
private boolean caseSensitive = false;
private String pathPrefix;
private String basePackage;

......

/**
* Generate the actual URL paths for the given controller class.
* <p>Subclasses may choose to customize the paths that are generated
* by overriding this method.
* @param beanClass the controller bean class to generate a mapping for
* @return the URL path mappings for the given controller
*/
protected String[] generatePathMappings(Class beanClass) {
StringBuffer pathMapping = buildPathPrefix(beanClass);
String className = ClassUtils.getShortName(beanClass);
String path = (className.endsWith(CONTROLLER_SUFFIX) ?
className.substring(0, className.indexOf(CONTROLLER_SUFFIX)) : className);
if (path.length() > 0) {
if (this.caseSensitive) {
pathMapping.append(path.substring(0, 1).toLowerCase()).append(path.substring(1));
}
else {
pathMapping.append(path.toLowerCase());
}
}
if (isMultiActionControllerType(beanClass)) {
return new String[] {pathMapping.toString(), pathMapping.toString() + "/*"};
}
else {
return new String[] {pathMapping.toString() + "*"};
}
}

/**
* Build a path prefix for the given controller bean class.
* @param beanClass the controller bean class to generate a mapping for
* @return the path prefix, potentially including subpackage names as path elements
*/
private StringBuffer buildPathPrefix(Class beanClass) {
StringBuffer pathMapping = new StringBuffer();
if (this.pathPrefix != null) {
pathMapping.append(this.pathPrefix);
pathMapping.append("/");
}
else {
pathMapping.append("/");
}
if (this.basePackage != null) {
String packageName = ClassUtils.getPackageName(beanClass);
if (packageName.startsWith(this.basePackage)) {
String subPackage = packageName.substring(this.basePackage.length()).replace('.', '/');
pathMapping.append(this.caseSensitive ? subPackage : subPackage.toLowerCase());
pathMapping.append("/");
}
}
return pathMapping;
}

}
</code>

===DefaultAnnotationHandlerMapping===
*Spring MVC에서 지원하는 Annotation인 @RequestMapping에 설정된 URL로 요청이 발행하면 @RequestMapping이 설정된 해당 클래스의 매소드로 매핑된다.
*아래의 예제에서 설정된 내용은 %WebContextRoot%/deptInfo/findDeptSpecs.action (servlet-mapping pattern을 .action으로 정의함)이 클라이언트에서 요청되었을 때 findDeptSpecs 메소드에서 해당 요청을 처리하게 된다.

<code lang="java">
@Controller
public class DeptController extends BaseController {
protected static Log log = LogFactory.getLog(DeptController.class);

@Autowired
private DeptInfoService deptInfoService; //Autowired Component Service

/**
* @param searchMap
* @return
*/
@RequestMapping("/deptInfo/findDeptSpecs")
public ModelAndView findDeptSpecs(@ModelAttribute("searchMap") HashMap searchMap) {
return new ModelAndView("jsonView", "deptSpecs", deptInfoService.viewDeptSpecs(super.searchMap));
}

/**
* @param searchList
* @return
*/
@RequestMapping("/deptInfo/saveDeptSpecs")
public ModelAndView saveDeptSpecs(@ModelAttribute("searchList") List searchList) {
deptInfoService.saveDeptSpec(super.searchList);
return new ModelAndView("jsonView");
}

}
</code>

==하나의 이상의 HandlerMapping을 사용하기==
*Spring MVC 기반의 웹 어플리케이션을 개발하다보면, HandlerMapping을 BeanNameUrlHandlerMapping와 SimpleUrlHandlerMapping 모두 사용해야하는 경우가 발생할 수 있다.
*Spring MVC는 HandlerMapping과 같이 같은 기능을 구현하기 위한 다양한 옵션을 제공하는 기능들이 많다. 그런데 이 같은 옵션들을 하나의 ApplicationContext내에서 같이 사용하고자 할 경우 각 옵션에 우선 순위를 결정하는 것이 가능하다.
*Spring 프레임워크는 org.springframework.core.Ordered 인터페이스를 구현함으로서 이 같은 기능이 가능하도록 지원하고 있다.
*BeanNameUrlHandlerMapping와 SimpleUrlHandlerMapping을 같이 사용하도록 빈 설정파일을 변경하면 다음과 같다.

<code lang="xml">
......
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping">
<property name="order"><value>1</value></property> 
</bean>

<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="order"><value>2</value></property> 
<property name="mappings">
<props>
<prop key="/board/board.do">boardController</prop>
</props>
</property>
</bean>
......
</code>

*하나의 빈 설정파일에서 BeanNameUrlHandlerMapping와 SimpleUrlHandlerMapping을 모두 사용하고 있는 것을 확인할 수 있다.
*실무 프로젝트를 진행할 때 위에서 처럼 두가지의 HandlerMapping을 사용하는 경우는 많지 않을 것이다.
*대부분의 프로젝트들이 프로젝트 초반에 어느 HandlerMapping을 사용할지 결정한 다음 프로젝트를 진행할 것이다.

==HandlerAdapter 이해하기==
*Spring MVC에서 DispatcherServlet이 적당한 HandlerMapping을 찾아 Request를 처리하는 방법은 상당히 동적이다.
*이와 같은 동적인 행위가 HandlerAdapter의 폼 내에서 이루어 진다.
*다음 그림은 HandlerAdapter 인터페이스의 구현한 클래스를 나타낸다.

[[그림:SpringMVC_HandlerAdapter.JPG|700px|thumb|center|HandlerAdapter 인터페이스의 계층구조]]

*처음 언급한 Request 처리방법에서 DispatcherServlet은 적당한 Handler Mapping을 선택하고, Request를 설정파일의 컨트롤러에게 넘긴다.
*이것은 기본적인 경우로 org.springframework.web.servlet.SimpleControllerHandlerAdapter로 정의된 Default HandlerAdapter에서 처리한다.
*다음은 Spring MVC의 Default HandlerAdapter인 SimpleControllerHandlerAdapter의 소스코드이다.

<code lang="java">
public class SimpleControllerHandlerAdapter implements HandlerAdapter {

public boolean supports(Object handler) {
return (handler instanceof Controller);
}

public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {

return ((Controller) handler).handleRequest(request, response);
}

public long getLastModified(HttpServletRequest request, Object handler) {
if (handler instanceof LastModified) {
return ((LastModified) handler).getLastModified(request);
}
return -1L;
}

}
</code>

*다른 핸들러 어뎁터 타입으로 Throwaway Controler HandlerAdapter, 그리고 SimpleServletController handlerAdapter가 있다.
*ThrowawayControllerHandlerAdapter는 DispatcherServlet으로부터 ThrowawayController에게 Request를 전달한다.
*SimpleServletHandlerAdapter는 Request를 DispatherServlet으로부터 Servlet.service() 메쏘드에 의해 만들어지는 Servlet에게 전달한다.
*설정파일에 다음과 같이 용도에 따라 설정할 수 있다.

<code lang="xml">
......
<bean id="throwawayHandler" class = "org.springframework.web.servlet.mvc.throwaway.ThrowawayControllerHandlerAdapter"/>



<bean id="throwawayHandler" class="org.springframework.web.servlet.mvc.throwaway.SimpleServletHandlerAdapter"/>
......
</code>

==HandlerInterceptor 이해하기==
*Spring MVC는 서블릿 2.3부터 지원하고 있는 ServletFilter와 같은 기능을 지원하기 위하여 HandlerInterceptor를 지원한다.
*HandlerInterceptor는 Controller가 실행되기 전, 후에 공통적으로 추가해야하는 작업이 있다면 유용하게 사용할 수 있다.
*서블릿 2.3을 지원하지 않는 환경하에서 ServletFilter와 같은 효과를 필요로할 경우 유용하게 사용할 수 있다.
*HandlerInterceptor의 내부는 다음과 같다.

<code lang="java">
package org.springframework.web.servlet;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public interface HandlerInterceptor {

boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception;

void postHandle(
HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
throws Exception;

void afterCompletion(
HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
throws Exception;

}
</code>

*Controller 실행 전에 수행될 동작은 preHandle에 정의하고, 실행 후에 수행될 동작은 postHandle에 정의한다.

===HandlerInterceptorAdapter 클래스로 HandlerIntercetor 구현하기===
*HandlerInterceptorAdapter 클래스는 HandlerIntercetor을 구현하고 있는 클래스로 Adaptor 패턴이 적용된 클래스이다.
*HandlerIntercetor의 모든 메소드를 구현할 필요가 없는 경우에는 HandlerInterceptorAdapter 클래스를 이용하면 쉽게 구현하는 것이 가능하다.
*다음 예제는 HandlerIntercetor을 추가하여 Controller가 실행되기 전후에 Logging 메세지를 출력하도록 구현한다.

<code lang="java">
package com.daewoobrenic.jcf.web;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

public class LoggingHandlerInterceptor extends HandlerInterceptorAdapter {
protected final Log logger = LogFactory.getLog(getClass());

public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3) throws Exception {
if( logger.isDebugEnabled() ) {
logger.debug("afterCompletion method called");
}
}

public boolean preHandle(HttpServletRequest req, HttpServletResponse res, Object obj) throws Exception {
if( logger.isDebugEnabled() ) {
logger.debug("preHandle method called");
}

return super.preHandle(req, res, obj);
}

}
</code>

*앞의 예제와 같이 HandlerIntercetor를 구현한 다음 빈 설정파일에 다음과 같이 정의하면 모든 Controller가 실행되기 전후에 공통적으로 필요한 작업을 수행한다.

<code lang="xml">
<bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="interceptors">
<list>
<ref bean="loggingInterceptor"/>
</list>
</property>
<property name="mappings">
<props>

<prop key="**/*.html">staticViewController</prop>

<prop key="/index.do">indexController</prop>
<prop key="/menu.do">leftMenuController</prop>

<prop key="/changelocale.do">sessionLocaleController</prop>

<prop key="/user/login.do">loginFormController</prop>


<prop key="/user/listUser.do">userController</prop>
<prop key="/user/viewUser.do">userController</prop>
<prop key="/user/editUser.do">userFormController</prop>


<prop key="/board/board.do">boardController</prop>
<prop key="/board/editBoard.do">boardFormController</prop>
</props>
</property>
</bean>

<bean id="loggingInterceptor" class="com.daewoobrenic.jcf.web.LoggingHandlerInterceptor"/>
</code>

==다양한 형태의 Controller 구성하기==
*Spring MVC는 용도에 따라 다양한 형태의 Controller를 제공한다.
*전형적인 Controller 유형으로 ViewContoller, CommandController(FormContoller), MulitActionController, ParameterizableViewController, ServletForwardingController, ServletWrappingController를 제공한다.
*다음은 Controller Interface가 제공하는 다양한 Abstract 클래스와 Implementation 클래스의 계측구조이다.

[[그림:AbstractController.JPG|800px|thumb|center|Controller Interface의 계층구조]]

===AbstractController===
*Custom Controller 컴포넌트를 만들려고 할 경우, Controller 인터페이스를 구현하지 말고 AbstractController를 상속한다.
*기본적으로 GET과 Post를 지원한다.

<code lang="java">
public class JcfSimpleController extends AbstractController{

public void handleRequestInternal(HttpServletRequest request,
HttpServletResponse response){

return new ModelAndView("jcfView");

}
}
</code>

*DispatcherServlet은 Request와 Response를 파라미터로 하여 handleRequest()를 호출한다
*Implementation 클래스는 ModelAndView 객체를 리턴한다.
*Logical View Name과 실제 Physical Location 뷰 리소스 사이의 매핑을 제공하는 일을 하는 ViewResolver라는 컴포넌트가 있다.
*예제에서 DispatcherServlet이 JcfSimpleController 객체를 invoke할 경우, View의 형태에 따라 JstlView인 경우는 jcfView.jsp로, JsonView인 경우는 jcfView.js를 통해 jcfView.jsp로 클라이언트에 출력될 것이다.

===AbstractCommandController===
*CommandController는 비즈니스 로직이 사용자에 의해 제공되는 값(모델)에 의해 종속될 때 적용하는 것이 적절하다.
*Spring MVC에서는 데이터 바인딩 기능뿐만 아니라 유효성 체크기능까지 입력폼으로 모든 기능을 지원하기 위하여 AbstractCommandController 클래스를 지원한다.
*AbstractCommandController를 기반으로 구현된 Controller는 데이터 바인딩 뿐만 아니라 유효성 체크까지 지원한다.
*데이터 바인딩 및 데이터에 대한 유효성 체크 기능을 지원하고 있지만 이 Controller를 이용할 경우 입력 화면이 추가될 때마다 Controller가 하나씩 추가되어야 하며, 빈 설정 정보 또한 수정해 주어야 한다는 단점이 있다.
*다음의 예제에서 사용자 이름의 존재유무에 따라 success.jsp와 failure.jsp가 출력된다.

<code lang="java">
public class JcfSimpleController extends AbstractCommandController{

public JcfSimpleController(){
setCommandClass(UserInfo.class);
}

public void handle(HttpServletRequest request, HttpServletResponse response,
Object command){

UserInfo userInfo = (UserInfo)command;
if ( exists(userInfo.getUserName){
return new ModelAndView("success");
}else{
return new ModelAndView("failure");
}
}

private boolean exits(String username){
// Some logic here.
}
}
</code>

*클라이언트 파라미터는 UserInfo라는 클래스로 캡슐화되어 있고 username 필드는 UserInfo의 username 속성에 매핑된다.
*JcfSimpleController의 생성자에서 지정한 CommandClass인 UserInfo는 다음과 같다.
*CommandClass는 생성자에서 지정할 수 있고 서블릿명-servlet.xml 설정파일에서 Controller의 property로 설정할 수 있다.

<code lang="java">
public class UserInfo{

private String username;
// Getters and Setters here.

}
</code>

===UrlFilenameViewController===
*웹 애플리케이션을 개발하다보면 샘플 애플리케이션의 메인 페이지처럼 정적인 페이지에 접근해야 되는 경우가 종종 발생한다.
*웹 애플리케이션의 모든 URL에 대하여 공통적인 작업을 처리할 필요가 있을 경우에는 정적인 페이지 또한 DispatcherServlet을 통하여 접근한다.*
*정적인 페이지의 경우 비즈니스 계층과 통신하는 부분도 없을 뿐 아니라 단지 HTML이나 JSP화면을 출력하는 역할만을 담당하고 있다.
*Spring MVC의 특성상 정적인 페이지에 접근하기 위하여 매번 새로운 Controller를 추가하는 것은 불필요한 작업이 아닐 수 없다.
*이 같은 단점을 보완하기 위하여 Spring MVC는 UrlFilenameViewController를 지원한다.
*UrlFilenameViewController의 단점은 모든 URL을 다음과 같이 처리한다는 것이다.

<pre>
http://localhost:8080/jcf/index.html => /jcf/index.jsp
http://localhost:8080/jcf/user/index.html => /jcf/index.jsp
http://localhost:8080/jcf/board/index.html => /jcf/index.jsp
</pre>

*위와 같이 모든 서브 디렉토리에 대한 URL을 하나로 인식하여 처리한다는 것이 단점이다.
*정적인 페이지는 특정 디렉토리에만 존재하는 것이 아니라 JSP를 관리하는 모든 디렉토리에 존재할 수 있기 때문에 UrlFilenameViewController를 모든 서브 디렉토리에 대해서도 처리하는 것이 가능하도록 다음과 같이 구현할 수 있다.

<code lang="java">
.... 중간 생략 ....

public class JcfUrlFilenameViewController implements Controller {
protected final Log logger = LogFactory.getLog(getClass());

public ModelAndView handleRequest(HttpServletRequest request,
HttpServletResponse response) {
String contextPath = request.getContextPath();
String uri = request.getRequestURI();

if( logger.isDebugEnabled() ) {
logger.debug("URI : " + uri);
logger.debug("ContextPath : " + contextPath);
}

int begin = 0;
if ((contextPath == null) || (contextPath.equals(""))) {
begin = 1;
} else {
begin = contextPath.length() + 1;
}

if( logger.isDebugEnabled() ) {
logger.debug("Begin : " + begin);
}

int end;
if (uri.indexOf(";") != -1) {
end = uri.indexOf(";");
} else if (uri.indexOf("?") != -1) {
end = uri.indexOf("?");
} else {
end = uri.length();
}
String fileName = uri.substring(begin, end);
if (fileName.indexOf(".") != -1) {
fileName = fileName.substring(0, fileName.lastIndexOf("."));
}

for (Enumeration en = request.getParameterNames(); en.hasMoreElements();) {
String attribute = (String) en.nextElement();
Object attributeValue = request.getParameter(attribute);

if( logger.isDebugEnabled() ) {
logger.debug("set Attribute in Request : " + attribute + "=" + attributeValue);
}

request.setAttribute(attribute, attributeValue);
}

return new ModelAndView(fileName);
}
}
</code>

*정적인 페이지에 접근할 때 사용할 확장자를 web.xml에 다음과 같이 추가한다.

<code lang="xml">
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.html</url-pattern>
</servlet-mapping>
</code>

*web.xml에 servlet-mapping을 추가했으므로 확장자가 ".html"에 해당하는 모든 URL은 DispatcherServlet이 처리하게 된다.
*구현된 JcfUrlFilenameViewController를 서블릿명-servlet.xml 설정파일에 다음과 같이 설정한다.

<code lang="xml">
<beans>
<bean name="/**/*.html" class="com.daewoobrenic.jcf.web.JcfUrlFilenameViewController"/>

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

<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="viewClass">
<value>org.springframework.web.servlet.view.JstlView</value>
</property>
<property name="cache" value="false" />
<property name="prefix" value="/WEB-INF/jsp/" />
<property name="suffix" value=".jsp" />
</bean>
</beans>
</code>

*MyUrlFilenameViewController에서 사용한 빈 이름을 보면 별표(asterisk, *)를 사용하여 확장자가 ".html"에 해당하는 모든 URL에 대하여 MyUrlFilenameViewController을 매핑(Mapping)하도록 설정하고 있다.
*Spring MVC에서는 URL과 Controller를 매핑할 때 별표(*)를 사용하는 것이 가능하다.

===MultiActionController===
*Spring MVC로 웹 애플리케이션을 개발하면 가장 큰 제약사항으로 하나의 페이지가 추가될 때마다 새로운 Controller를 하나씩 추가해야 하는 번거로움이 발생한다
*이와 같은 번거로움 뿐만아니라 페이지 수가 많아지면 많아질수록 관리해야될 Controller 클래스의 수도 같이 증가하게 되므로 빈 설정파일 또한 상당히 복잡해지기 때문에 Controller의 이 같은 문제점을 해결하기 위하여 Spring MVC는 MultiActionController를 제공한다.
*MultiActionController는 하나의 Controller를 구현함으로서 다수의 요청을 처리하는 것이 가능하도록 지원한다.
*Spring MVC에서는 입력 화면(또는 수정화면)에서 전달되는 입력 데이터를 비즈니스 계층에 전달하기 위하여 HttpServletRequest에 담긴 인자와 도메인 모델의 속성을 자동적으로 연결하는 데이터 바인딩을 지원하고 있다.
*MultiActionController를 이용하여 데이터바인딩을 처리하는 방법은 다음과 같다.

<code lang="java">
public class UserController extends MultiActionController {
protected static final Log logger = LogFactory.getLog(UserController.class);

private UserService userService = null;

public void setUserService(UserService userService) {
this.userService = userService;
}

.... 중간 생략 ....

public ModelAndView add(HttpServletRequest request,
HttpServletResponse response) throws Exception {
User command = new User();
bind(request, command);

userService.addUser(command);

return dispatchView(request, response);
}

public ModelAndView update(HttpServletRequest request,
HttpServletResponse response) throws Exception {
User command = new User();
bind(request, command);

userService.updateUser(command);

return dispatchView(request, response);
}

private ModelAndView dispatchView(HttpServletRequest request,
HttpServletResponse response) throws Exception {
HttpSession session = request.getSession();

if (session.getAttribute("loginUser") != null) {
User loginUser = (User) session.getAttribute("loginUser");
if (loginUser.isAdmin()) {
return list(request, response);
}
}

return new ModelAndView("redirect:/index.html");
}
}
</code>

*MultiActionController 클래스의 bind() 메써드를 이용하여 HttpServletRequest에 전달된 인자를 User 도메인 모델에 전달하고 있는 것을 확인할 수 있다.
*클라이언트가 입력한 데이터를 도메인 모델과 데이터 바인딩하기 위해서는 입력 화면에서 사용한 속성이름과 도메인 모델의 속성 이름이 같아야 한다.

<code lang="jsp">
.... 중간 생략 ....

<table border="0" cellpadding="0" cellspacing="1" width="100%"
bgcolor="BBBBBB">
<tr>
<td width=150 align=center bgcolor="E6ECDE" height="22">사용자 아이디</td>
<td bgcolor="ffffff" style="padding-left:10">
<input type="text" style="width:150" name="userId"/>
</td>
</tr>
<tr>
<td width=150 align=center bgcolor="E6ECDE" height="22">비밀번호</td>
<td bgcolor="ffffff" style="padding-left:10">
<input type="password" style="width:150" name="password"/>
</td>
</tr>
<tr>
<td width=150 align=center bgcolor="E6ECDE" height="22">비밀번호 확인</td>
<td bgcolor="ffffff" style="padding-left:10">
<input type="password" style="width:150" name="password2"/>
</td>
</tr>
<tr>
<td width=150 align=center bgcolor="E6ECDE" height="22">이름</td>
<td bgcolor="ffffff" style="padding-left:10">
<input type="text" style="width:240" name="name"/>
</td>
</tr>
<tr>
<td width=150 align=center bgcolor="E6ECDE" height="22">이메일 주소</td>
<td bgcolor="ffffff" style="padding-left:10">
<input type="text" style="width:240" name="email"/>
</td>
</tr>
<c:if test="${ loginUser.admin }">
<tr>
<td width=150 align=center bgcolor="E6ECDE" height="22">Admin 유무</td>
<td bgcolor="ffffff" style="padding-left:10">
<input type="checkbox" name="admin" value="true" />
</td>
</tr>
</c:if>
</table>

.... 중간 생략 ....
</code>

<code lang="java">
.... 중간 생략 ....

public class User extends BaseObject {
private String userId = null;
private String password = null;
private String password2 = null;
private String name = null;
private String email = null;
private boolean admin = false;

.... 각 속성에 대한 setter, getter 메써드 ....
}
</code>

*하나의 Controller에 사용자 관리 프로젝트의 모든 기능을 구현하도록 개발하는 것은 Controller 개발을 용이하게 할 뿐만 아니라 빈 설정파일이 단순해지기 때문에 개발 및 관리에 많은 장점이 된다.
*하지만 Spring MVC의 MultiActionController는 입력 데이터에 대한 유효성 체크 기능을 지원하지 않는다.
*Spring MVC에서 지원하는 유효성 체크기능을 사용하지 않고 데이터 바인딩 기능만을 이용하고자할 때는 MultiActionController를 이용하여 구현한다.

===SimpleFormController===
*일반적으로 폼에 데이터를 넣고 submit 하는 목적으로 사용하는데 적합하다.
*클라이언트가 empInfo.jsp라는 empName, empAge, empSalary 필드가 있는 페이지를 요청한다고 가정하고 요청의 처리가 성공적으로 마치면 empSuccess.jsp이 클라이언트에게 출력된다.
*이것을 SimpleFormController로 다음과 같이 구현할 수 있다.
*먼저 Getter와 Setter를 이용하여 다음 내용을 정의하자.

<code lang="java">
public class EmpInfo{

private String empName;
private int empAge;
private double empSalary;

// Getters and setters for the above properties.

}
</code>

*다음은 SimpleFormController를 확장하여 클래스를 작성한다.
*여기서 doSubmitAction은 override된 것으로 폼이 submit 될때 호출된다.

<code lang="java">
public class EmpFormController extends SimpleFormController{

public EmpFormController(){
setCommandClass(EmpInfo.class);
}

public void doSubmitAction(Object command){
EmpInfo info = (EmpInfo)command;
process(info);
}

private void process(EmpInfo info){
//Do some processing with this object.
}
}
</code>

*설정파일에서 submission이 성공했을 경우에 대한 처리를 다음과 같이 정의한다.

<code lang="xml">
......
<bean id = "empForm" class="EmpFormController">
<property name="formView"><value>empInfo</value></property>
<property name="successView"><value>empSuccess</value></property>
</bean>
......
</code>

*SimpleFormController는 접근하는 URL이 GET/POST에 따라서 서로 다른 방식으로 실행된다.
*SimpleFormController가 GET/POST에 따라 처리하는 과정을 살펴보면 다음 그림과 같다.

[[그림:SpringMVC_SimpleFormController_WorkFlow_GET.JPG|750px|thumb|center|GET 방식의 SimpleFormController 처리과정]]

*위의 그림에서 보는 바와 같이 GET 방식으로 접근할 때 여러 단계를 거친 다음에 최종 화면을 출력한다.
*GET 방식으로 SimpleFormController에 접근할 때의 과정을 살펴보면 다음과 같다.

<pre>
1. 처음으로 호출되는 메써드는formBackingObject() 메써드이다. formBackingObject() 메써드는 디폴트로 설정한 Command 클래스의 인스턴스를 생성한다. 만약 수정화면과 같이 데이터베이스로부터 데이터를 추출해야 하는 경우 이 메써드를 오버라이드(Override)해야한다.
2. Request 패러미터로 전달되는 모든 값은 String이다. 그러나 바인딩할 Command 클래스의 속성으로는 모든 타입을 가질 수 있다. 심지어 String을 Object 타입으로 바인딩해야 하는 경우도 있다. 이와 같이 Request 패러미터를 Command 클래스의 속성과 바인딩시키기 위하여 생성한 Custom Property Editor가 있다면 initBinder() 메써드에서 등록할 수 있다.
3. 빈 설정파일에서 bindOnNewForm 속성이 true로 설정되어 있다면 Request 패러미터와 Command 클래스의 데이터바인딩을 실행한다.
4. 빈 설정파일에서 sessionForm 속성이 true로 설정되어 있다면 Command 클래스를 세션에 저장한다.
5. referenceData() 메써드는 폼 화면을 구현하기 위하여 Command 클래스 이외에 다른 데이터가 필요할 때 오버라이드하여 새롭게 구현하는 것이 가능하다.
6. showForm() 메써드는 디폴트로 빈 설정파일에서 정의한 "formView" 속성에 해당하는 ModelAndView 객체를 반환한다. 만약 요청인자, 상태에 따라 다른 페이지로 이동하고자 한다면 이 메소드를 오버라이드하여 새롭게 구현하는 것이 가능하다.
</pre>

*Spring MVC에서는 GET 요청에 대한 워크플로우상에서 개발자들이 추가적인 기능을 구현할 수 있도록 지원하고 있다.
*POST 방식으로 접근할 때가 GET 방식으로 접근할 때보다 상당히 복잡한 워크플로우를 가지고 있다.
*그 이유는 POST 방식으로 폼 화면의 데이터를 전송하고 있기 때문에 데이터 바인딩, 데이터에 대한 유효성 체크 기능이 추가적으로 구현되어야 하기 때문이다.
*다음으로 POST 방식으로 SimpleFormController에 접근할 때의 과정을 살펴보면 다음과 같다.

[[그림:SpringMVC_SimpleFormController_WorkFlow_POST.JPG|650px|thumb|center|POST 방식의 SimpleFormController 처리과정]]

<pre>
1. POST 방식으로 접근할 때의 첫 단계는 빈 설정파일에 sessionForm 속성이 true로 설정되어 있는지에 따라 나뉜다. sessionForm 속성이 true로 설정되어 있다면 세션에 저장되어 있는 Command 클래스를 반환하게 된다. 만약 Command 클래스가 세션에 존재하지 않는다면 handleInvalidSubmit() 메써드가 호출되면서 에러 페이지로 이동하게 된다.
2. sessionForm속성이 설정되어 있지 않다면(디폴트 false) GET 방식으로 접근할 때와 같이 formBackingObject(), initBinder() 메써드를 실행한다.
3. Request 패러미터와 Command 클래스의 데이터 바인딩을 진행한다.
4. 데이터 바인딩 후에 추가적인 구현이 필요하다면 onBind() 콜백 메써드를 오버라이드하여 구현하면 된다.
5. 빈 설정파일에 추가된 Validator가 존재한다면 Validator의 validate() 메써드를 호출함으로서 유효성 체크를 진행한다.
6. 유효성 체크까지 완료한 후 추가적인 구현이 필요하다면 onBindAndValidate() 콜백 메써드를 오버라이드하여 구현하면 된다.
7. BindException의 에러 리스트에 에러가 존재할 경우 showForm() 메써드를 호출하여 빈 설정파일의 formView 속성으로 정의되어 있는 페이지로 이동하게 된다.
8. BindException 에러 없이 정상적으로 처리될 경우 onSubmit() 또는 doSubmitAction() 메써드가 호출된다. onSubmit() 또는 doSubmitAction() 메써드의 디폴트 ModelAndView는 빈 설정파일의 successView 속성으로 정의되어 있는 페이지로 이동한다. 만약 Request 패러미터로 전달되는 값에 따라 다른 페이지로 이동해야한다면 오버라이드함으로서 구현하는 것이 가능하다.
</pre>

*SimpleFormController는 개발자들에게 유연성을 제공하기 위하여 각 단계마다 콜백 메소드를 제공한다.
*개발자들은 SimpleFormController를 상속하는 하위 클래스에서 이 콜백 메소드를 오버라이딩(Overriding)함으로서 개발자들이 원하는 기능을 추가적으로 구현할 수 있다.
*SimpleFormController의 데이터 바인딩이나 유효성체크 등에 특별히 추가적으로 구현할 기능이 없다면 formBackingObject(),onSubmit() 메써드만을 오버라이드함으로서 쉽게 구현할 수 있다.

===CancellableFormController===
*CancellableFormController는 Form이 Cancel되었을 때 Cancel에 대한 처리를 제공한다.
*SimpleFormController에서 Cancel이 처리될 경우 대한 것만 추가된 것이다.

<code lang="java">
public class JcfCompleteFormController extends CancellableFormController{

public ModelAndView onCancel(){
return new ModelAndView("cancelView");
}
}
</code>

==ModelAndView 이해하기==
*ModelAndView는 컨트롤러에 의해 DispatcherServlet에 반환된다.
*이 클래스는 Model과 View 정보를 갖고 있는 컨테이너 클래스이다.
*View 기법은 org.springframework.web.servlet.View에 정의되어 있다.
*예를 들어 excel, Jasper Reports, pdf, xslt, Free Marker, Html, Tiles, velocity 등을 지원한다.
*Model과 View 객체를 다음과 같이 구현할 수 있다.

<code lang="java">
View pdfView = …;
Map modelData = new HashMap();

ModelAndView mv = new ModelAndView(pdfView, modelData);
</code>

*다음 예제코드를 보자.

<code lang="java">
ModelAndView mv = new ModelAndView("jcfView", someData);
</code>

*위 예제에서 someData가 jcfView에 전달된다. 여기서 view는 논리뷰이다.
*jcfView는 jcfView.jsp 또는 jcfView.pdf, jcfView.xml에 대응될 수 있다.
*논리뷰에 대응되는 물리뷰의 위치는 설정파일에서 정의된다.

==ViewResolver 이해하여 적용하기==
*ViewResolver는 논리뷰와 물리뷰를 매핑한다.
*Spring MVC에서 지원하는 ViewResolver는 다음과 같다.

<pre>
1. BeanNameViewResolver
2. FreeMarkerViewResolver
3. InternalResourceViewResolver
4. JasperReportsViewResolver
5. ResourceBundleViewResolver
6. UrlBasedViewResolver
7. VelocityLayoutViewResolver
8. VelocityViewResolver
9. XmlViewResolver
10. XsltViewResolver
</pre>

*ViewResolver 구현 시 계층구조를 참고하여 용도에 맞는 ViewResolver를 선택해야 한다.
*다음은 ViewResolver Interface의 계층구조를 나타낸다.

[[그림:SpringMVC_ViewResolver.JPG|700px|thumb|center|ViewResolver Interface의 계층구조]]

===InternalResourceViewResolver===
*InternalResourceViewResolver는 ModelAndView 폼에서 컨트롤러에 의해 리턴된 리소스의 논리적 이름을 Physical View Location에 매핑하려고 시도한다.
*단점은 뷰파일의 이름이 어플리케이션 컨텍스트 내에 명시되어야 한다는 것이다.
*따라서 동적으로 생성되는 뷰파일에 대한 처리는 불가능하다.
*다음 예제코드와 같이 구성된 Controller에서는 조건에 따라 서로 다른 ModelAndView 객체를 리턴한다.

<code lang="java">
public class JcfController {

public void handle(){
if(condition1()){
return new ModelAndView("jcfView1");
}else if (condition2()){
return new ModelAndView("jcfView2");
}
return new ModelAndView("jcfView3");
}
}
</code>

*만약 클라이언트의 Request가 condition1()을 만족한다면, View는 jcfView1.jsp 이고 condition2() 일 경우에는 jcfView2이다.
*이와 같은 동작이 정상적으로 이루어지기 위해서는 반드시 다음 설정파일 내용이 필요하다.

<code lang="xml">
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix"><value>/WEB-INF/</value></property>
<property name="suffix"><value>.jsp</value></property>
</bean>
</code>

*이것은 InternalResolverViewResolver가 논리뷰이름을 Physical Location에 매핑하는 방법을 보여준다.
*논리뷰이름이 jcfView1일 때, View 이름은 prefix + 논리뷰이름 + suffix이며, 여기서는 /WEB-INF/jcfView.jsp가 된다.

===BeanNameViewResolver===
*InternalResourceViewResolver의 단점인 동적 뷰파일 처리의 문제점을 해결하기 위한 ViewResolver이다.
*BeanNameViewResolver는 Pdf 또는 엑셀 등의 View를 동적으로 생성할 수 있다.

<code lang="java">
......
return ModelAndView("pdf");
......
</code>

*위와 같이 pdf를 생성해야 한는 ModelAndView인 경우 다음과 같은 설정파일을 정의한다.

<code lang="xml">
<bean id="beanNameResolver" class="org.springframework.web.servlet.view.BeanNameViewResolver"/>

<bean id="pdf" class="com.daewoobrenic.jcf.web.servlet.view.JcfPdfGenerator"/>
</code>

*이때 JcfPdfGenerator는 반드시 org.springframework.web.servlet.view.document.AbstractPdfView의 서브클래스이어야 한다.

==View 구현하기==
*AbstractView 클래스를 상속받고 Abstract 메소드인 renderMergedOutputModel 메소드를 오버라이딩하여 클라이언트에게 제공하고자 하는 물리적인 뷰를 생성할 수 있도록 구현한다.
*View에서는 생성자나 XML 설정파일을 통해 View 클래스에 대한 초기값을 설정할 수 있다.
*Spring MVC에서 제공하는 View는 다음과 같다.

[[그림:SpringMVC_View.JPG|700px|thumb|center|View Interface의 계층구조]]

==파일업로드 구현하기==

=참고자료=
*[http://wiki.javajigi.net/display/SFL/Home 자바지기 Springframework 워크북]
*[http://static.springframework.org/spring/docs/2.5.x/reference/index.html SpringFramework Reference Manual]

Code Module

Alsdkzz — Thu, 03 Jul 2008 06:15:51 GMT

바꾼내용 간추리기:

=코드 테이블 생성=
* 코드의 아이디와 값 그리고 분류 카테고리를 가지는 간단한 코드 테이블을 생성한다.
* HSQLDB 기준으로 생성함(오라클의 경우 int --> NUMBER로, VARCHAR는 VARCHAR2로 변경해 준다.)
<code lang='sql'>
CREATE TABLE CODE(
id int,
name varchar(20),
description varchar(50),
category varchar(20),
CONSTRAINT code_pk PRIMARY KEY(id)
)

INSERT INTO CODE(id, name, description, category) VALUES(1, 'SEOUL', '서울','user_address_code');
INSERT INTO CODE(id, name, description, category) VALUES(2, 'INCHEN', '인천','user_address_code');
INSERT INTO CODE(id, name, description, category) VALUES(3, 'PUSAN', '부산','user_address_code');
INSERT INTO CODE(id, name, description, category) VALUES(4, 'ULSAN', '울산','user_address_code');
</code>

=MODEL 작성=
<code lagn='java'>
public class Code {
private int id;
private String category;
private String name;
private String description;

public int getId() {return id;}
public void setId(int id) {this.id = id;}
public String getCategory() {return category;}
public void setCategory(String category) {this.category = category;}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public String getDescription() {return description;}
public void setDescription(String description) {this.description = description;}
}
</code>

=SQL 작성=
* getCodes 문장만 작성한다.
* resultMap은 선택적으로 사용한다.
<code lang='xml'>
<sqlMap namespace="code">
<typeAlias alias="code" type="edu.code.model.Code"/>

<resultMap id="code-resultMap" class="code" >
<result property="id" column="id"/>
<result property="category" column="category"/>
<result property="name" column="name"/>
<result property="description" column="description"/>
</resultMap>

<statement id="getCodes" parameterClass="string" resultMap="code-resultMap">
SELECT id, category, name, description
FROM CODE
WHERE category = #category#
</statement>
</sqlMap>
</code>

* SQL CONFIG XML(sqlmap-config.xml) 파일에 정의를 추가한다.
<code lang="xml">
<sqlMapConfig>
<settings cacheModelsEnabled="true" />

<sqlMap resource="sample/user/dao/sqlmap/User.xml" />
<sqlMap resource="edu/code/dao/sqlmap/Code.xml" />
</sqlMapConfig>
</code>

=DAO 작성=
* 카테고리를 파라미터로 받는 조회 메소드를 작성한다.
* jcf.dao.ibatis.BaseSqlMapClientDAO를 상속 받도록 한다.
<code lang='java'>
public class CodeDao extends BaseSqlMapClientDAO {
public List getCodes(String category) {
List codeList = executeQueryForList("getCodes", category);
return codeList;
}
}
</code>

* 작성된 CodeDao 클래스를 Spring 빈으로 정의한다(applicationContext-code.xml)
* CodeDao 클래스 정의에서는 상속 받은 BaseSqlMapClientDAO에서 필요로 하는 sqlMapClient를 프라퍼티로 가지도록 정의한다.
<code lang="xml">
<beans ..>
<bean id="codeDao" class="edu.code.dao.CodeDao">
<property name="sqlMapClient" ref="sqlMapClient" />
</bean>
</beans>
</code>

= SERVICE 작성=
* 카테고리를 파라미터로 받는 서비스 조회 메소드를 작성한다.
* CodeDao를 프라퍼티로 선언하고 setter 메소드를 작성한다.
<code lang='java'>
public class CodeService {
private CodeDao codeDao;

public List getCodes(String category) {
return codeDao.getCodes(category);
}

/* getter & setter */
public void setCodeDao(CodeDao codeDao) {this.codeDao = codeDao;}
}
</code>

* 작성된 코드DAO 클래스를 Spring 빈으로 정의한다(applicationContext-code.xml)
* 로직상에서 호출하는 CodeDao를 DI 프라퍼티로 정의한다.
<code lang="xml">
<beans ..>
<bean id="codeService" class="edu.code.service.CodeService">
<property name="codeDao" ref="codeDao" />
</bean>
<bean id="codeDao" class="edu.code.dao.CodeDao">
<property name="sqlMapClient" ref="sqlMapClient" />
</bean>
</beans>
</code>

Jdk14 Conversion

Kyoung94 — Thu, 03 Jul 2008 00:59:48 GMT

바꾼내용 간추리기: /* Retrotranslator 1.2.7를 활용하겨 java1.4로 변환하기 */

{{팁|
*산출물: JCF 라이브러리 및 공통모듈 jdk1.4로 다운그레이드하기
*작성자: 서경진
*최초작성일 : 2008/07/03
*최종작성일 : 2008/07/03
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
{{정보|
*이 문서는 Java 1.4환경에서 JCF Framework와 공통모듈을 사용하기 위한 Tip을 제공한다.
}}

==JCF 라이브러리 jdk1.4로 다운그레이드하기==
JCF는 Java1.5를 기반으로 개발되었지만, MCI (Multi-Channel Interface)의 jcf.web.RequestContextHolder 클래스에서 사용하는 java.lang.ThreadLocal.remove() (rt.jar) 함수가 1.5 이상에서만 지원되는 것을 제외하면 java 1.4 환경에서의 구동이 가능하다.
java1.4 환경에서 안정적으로 JCF를 기반으로 어플리케이션을 개발하기 위해서는 소스의 수정없이 Retrotranslator를 활용하여 java1.5로 컴파일된 JCF 라이브러리를 java1.4로 변환하면 된다.

===Retrotranslator 1.2.7를 활용하여 java1.4로 변환하기===
*Retrotranslator 다운받기: http://sourceforge.net/projects/retrotranslator
*JCF 라이브러리 다운받기: http://wiki.dev.daewoobrenic.co.kr/mediawiki/index.php/JCF_Download

*Retrotranslator와 JCF 라이브러리를 다운받아 아래와 같이 같은 디렉터리에 복사한다.

[[그림:Retrotranslator_jdk14_conversion.JPG|700px|thumb|center|디렉터리 구조]]

*DOS Command를 통해 다음과 같은 명령을 실행한다.

<pre>
java -jar retrotranslator-transformer-1.2.7.jar -advanced -srcjar jcf-3.0.1-SNAPSHOT.jar -destjar jcf-3.0.1-SNAPSHOT-jdk14.jar
java -jar retrotranslator-transformer-1.2.7.jar -advanced -srcjar jcf-ibatis-sqlmap-3.0.1-SNAPSHOT.jar -destjar jcf-ibatis-sqlmap-3.0.1-SNAPSHOT-jdk14.jar
</pre>

*다음은 JCF 라이브러리가 Retrotranslator를 통해 java1.4용으로 변환된 결과이다.

[[그림:Retrotranslator_jdk14_conversion_command.JPG|800px|thumb|center|변환 명령실행 결과]]

*위의 과정을 통해 동일 디렉터리에 jcf-3.0.1-SNAPSHOT-jdk14.jar와 jcf-ibatis-sqlmap-3.0.1-SNAPSHOT-jdk14.jar 두 개의 라이브러리가 생성된다.
*java1.4 환경에서 JCF 기반의 어플리케이션을 개발할 경우, 기존에 있는 java1.5용 JCF 라이브러리를 제거하고 생성된 두 개의 라이브러리를 buildpath에 설정하여 java1.4로 컴파일하면 어플리케이션이 정상적으로 구동할 것이다.

==JCF 공통모듈 jdk1.4로 다운그레이드하기==

===JCF 공통모듈의 메뉴관리가 참조하는 Tree.jar 라이브러리 다운그레이드하기===
*JCF 공통모듈에는 메뉴관리 모듈이 있는데, 메뉴관리는 Tree형 데이터 구조를 활용하기 위해 sourceforge에 공시된 Tree.jar라는 open source 라이브러리를 활용한다.
*Tree.jar는 다음 소스와 같이 java1.5 스팩인 jre1.5 이상에 포함된 rt.jar의 java.lang.Iterable과 GenericType <>을 사용한다.
*따라서 java1.4 환경에서는 구동이 불가능하다. (클래스를 찾을 수 없는 에러 발생)
*다음은 java1.5로 구현된 소스의 예제이다.

<code lang="java">
public interface Tree<T> extends Iterable<T>, Serializable
{
public abstract TreeRoot<T> getRoot();
public abstract Iterator<T> iterator();
public abstract Iterator<TreeNode<T>> nodeIterator();
public abstract List<T> getBreadthFirstList();
public abstract List<TreeNode<T>> getBreadthFirstNodeList();
public abstract List<T> getDepthFirstList();
public abstract List<TreeNode<T>> getDepthFirstNodeList();
public abstract List<T> getList();
public abstract List<TreeNode<T>> getNodeList();
public abstract int size();
public abstract int depth();
}
</code>

<code lang="java">
public class ArrayTree<T> implements Tree<T>
{
private static final long serialVersionUID = 7161315168915445688L;
private TreeRoot<T> root;
private final List<List<TreeNode<T>>> levels = new ArrayList<List<TreeNode<T>>>();

public ArrayTree()
{
this(null);
}

public ArrayTree(final T element)
{
super();
this.root = new ArrayTreeRoot<T>(this);
this.root.setElement(element);
this.saveNode(this.root, 0);
}

private void addLevel(final TreeNode<T> node) {
List<TreeNode<T>> level = new ArrayList<TreeNode<T>>();
level.add(node);
this.levels.add(level);
}

protected void saveNode(final TreeNode<T> node, final int depth) {
if (depth >= this.levels.size()) {
this.addLevel(node);
}
else {
this.levels.get(depth).add(node);
}
}

protected void removeNode(final TreeNode<T> node, final int depth) {
if (depth < this.levels.size()) {
this.levels.get(depth).remove(node);
}
}

protected List<TreeNode<T>> getNodes(final int depth) {
if (depth < this.levels.size()) {
return this.levels.get(depth);
}

return null;
}

public TreeRoot<T> getRoot()
{
return this.root;
}

public Iterator<T> iterator()
{
return this.getDepthFirstList().iterator();
}

public Iterator<TreeNode<T>> nodeIterator()
{
return this.getBreadthFirstNodeList().iterator();
}

public List<T> getBreadthFirstList()
{
final List<TreeNode<T>> nodes = this.getBreadthFirstNodeList();
final List<T> elements = new ArrayList<T>(nodes.size());
for (final TreeNode<T> node : nodes)
{
elements.add(node.getElement());
}

return Collections.unmodifiableList(elements);
}

public List<TreeNode<T>> getBreadthFirstNodeList()
{
final List<TreeNode<T>> nodes = new LinkedList<TreeNode<T>>();
for (List<TreeNode<T>> level : this.levels) {
nodes.addAll(level);
}

return Collections.unmodifiableList(nodes);
}

public List<T> getDepthFirstList()
{
final List<TreeNode<T>> nodes = this.getDepthFirstNodeList();
final List<T> elements = new ArrayList<T>(nodes.size());
for (final TreeNode<T> node : nodes)
{
elements.add(node.getElement());
}

return Collections.unmodifiableList(elements);
}

public List<TreeNode<T>> getDepthFirstNodeList()
{
final List<TreeNode<T>> nodes = new LinkedList<TreeNode<T>>();
this.addDepthFirst(nodes, this.root);

return Collections.unmodifiableList(nodes);
}

private void addDepthFirst(final List<TreeNode<T>> nodes, final TreeNode<T> node)
{
nodes.add(node);
for (final TreeNode<T> child : node.getChildren())
{
this.addDepthFirst(nodes, child);
}
}

public int depth()
{
return this.levels.size() - 1;
}

public int size()
{
int size = 0;
for (List<TreeNode<T>> level : this.levels) {
size += level.size();
}

return size;
}

public List<T> getList()
{
return this.getBreadthFirstList();
}

public List<TreeNode<T>> getNodeList()
{
return this.getBreadthFirstNodeList();
}
}
</code>

*Tree.jar를 java1.4 환경에서 활용하기 위해서 소스코드를 java1.4 스팩에 맞도록 수정하였다.
*Iterable 클래스와 GenericType <>은 사용하지 않도록 모두 제거하였고 T와 같이 Type이 선언된 부분은 Object로 변경하였다.
*java1.5용 for문을 java1.4에 맞도록 수정하였다.

<code lang="java">
interface Tree extends Serializable
{
public abstract TreeRoot getRoot();
public abstract Iterator iterator();
public abstract Iterator nodeIterator();
public abstract List getBreadthFirstList();
public abstract List getBreadthFirstNodeList();
public abstract List getDepthFirstList();
public abstract List getDepthFirstNodeList();
public abstract List getList();
public abstract List getNodeList();
public abstract int size();
public abstract int depth();
}
</code>

<code lang="java">
public class ArrayTree implements Tree
{
private static final long serialVersionUID = 7161315168915445688L;
private TreeRoot root;
private final List levels = new ArrayList();

public ArrayTree()
{
this(null);
}

public ArrayTree(final Object element)
{
super();
this.root = new ArrayTreeRoot(this);
this.root.setElement(element);
this.saveNode(this.root, 0);
}

private void addLevel(final TreeNode node) {
List level = new ArrayList();
level.add(node);
this.levels.add(level);
}

protected void saveNode(final TreeNode node, final int depth) {
if (depth >= this.levels.size()) {
this.addLevel(node);
}
else {
((ArrayList) this.levels.get(depth)).add(node);
}
}

protected void removeNode(final TreeNode node, final int depth) {
if (depth < this.levels.size()) {
((ArrayList) this.levels.get(depth)).remove(node);
}
}

protected List getNodes(final int depth) {
if (depth < this.levels.size()) {
return (List) this.levels.get(depth);
}

return null;
}

public TreeRoot getRoot()
{
return this.root;
}

public Iterator iterator()
{
return this.getDepthFirstList().iterator();
}

public Iterator nodeIterator()
{
return this.getBreadthFirstNodeList().iterator();
}

public List getBreadthFirstList()
{
final List nodes = this.getBreadthFirstNodeList();
final List elements = new ArrayList(nodes.size());
for (Iterator iterator = nodes.iterator(); iterator.hasNext();) {
TreeNode node = (TreeNode) iterator.next();
elements.add(node.getElement());
}

return Collections.unmodifiableList(elements);
}

public List getBreadthFirstNodeList()
{
final List nodes = new LinkedList();
for (Iterator iterator = this.levels.iterator(); iterator.hasNext();) {
List level = (List) iterator.next();
nodes.addAll(level);
}

return Collections.unmodifiableList(nodes);
}

public List getDepthFirstList()
{
final List nodes = this.getDepthFirstNodeList();
final List elements = new ArrayList(nodes.size());
for (Iterator iterator = nodes.iterator(); iterator.hasNext();) {
TreeNode node = (TreeNode) iterator.next();
elements.add(node.getElement());
}

return Collections.unmodifiableList(elements);
}

public List getDepthFirstNodeList()
{
final List nodes = new LinkedList();
this.addDepthFirst(nodes, this.root);

return Collections.unmodifiableList(nodes);
}

private void addDepthFirst(final List nodes, final TreeNode node)
{
nodes.add(node);
for (Iterator iterator = node.getChildren().iterator(); iterator.hasNext();) {
TreeNode child = (TreeNode) iterator.next();
this.addDepthFirst(nodes, child);
}
}

public int depth()
{
return this.levels.size() - 1;
}

public int size()
{
int size = 0;
for (Iterator iterator = this.levels.iterator(); iterator.hasNext();) {
List level = (List) iterator.next();
size += level.size();
}

return size;
}

public List getList()
{
return this.getBreadthFirstList();
}

public List getNodeList()
{
return this.getBreadthFirstNodeList();
}
}
</code>

*소스 수정이 끝나고 j2sdk1.4.2_17과 jre1.4.2_17로 컴파일을 한 후, Tree-1.0-jdk14.jar로 패키징하였다.
*패키징된 Tree-1.0-jdk14.jar 라이브러리는 Maven 저장소에 Artifact로 디플로이하여 Maven을 통한 활용이 가능하다.

[[그림:Maven_repository_tree_jar_jdk14.JPG|700px|thumb|center|Maven 저장소에 Artifact로 디플로이된 Tree-1.0-jdk14.jar 라이브러리]]

*Tree-1.0-jdk14.jar를 Maven에서 적용하기 위한 pom.xml

<code lang="xml">
------ ARTIFACT EFFECTIVE METADATA BEGIN ------
<groupId>Tree</groupId>
<artifactId>Tree</artifactId>
<version>1.0</version>
------- ARTIFACT EFFECTIVE METADATA END -------

<?xml version="1.0" encoding="UTF-8"?><project>
<modelVersion>4.0.0</modelVersion>
<groupId>Tree</groupId>
<artifactId>Tree</artifactId>
<version>1.0</version>
<description>Auto generated POM</description>
</project>
</code>

===메뉴관리 모듈 다운그레이드하기===
*Java 개발환경을 jdk 및 jre를 1.4.2._17로 변경한다.
*buildpath에 있는 Tree.jar를 Tree-1.0-jdk14.jar로 변경한다.
*메뉴모듈에 적용된 GenericType <>은 사용하지 않도록 모두 제거한다.
*GenericType으로 설정된 부분은 Casting(Type명)으로 형변환 에러를 방지한다.
*java1.5용 for문을 java1.4에서 사용할 수 있도록 수정한다.
*Java1.4로 컴파일한다.

Spring MVC & Java1.4 tip

Stardust — Tue, 01 Jul 2008 09:02:13 GMT

바꾼내용 간추리기: /* 설정파일의 간략화 */

{{팁|
*산출물: Java 1.4에서 Spring MVC 간단하게 사용하기
*작성자: 나윤주
*최초작성일 : 2008/07/01
*최종작성일 : 2008/07/02
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
{{정보|
*이 문서는 Java 1.4환경에서 Spring Web MVC Framework를 간단하게 사용할 수 있는 Tip을 제공한다.
}}

==설정파일의 간략화==
*Arid와 ControllerClassNameHandlerMapping의 조합으로 Annotation을 사용할 수 없는 Java 1.4 환경에서 번거로울 수 있는 web controller의 설정을 줄이고, Controller 클래스의 수를 줄임으로써 개발의 편이성을 높일 수 있다.
*다음은 블로그 예제에 대하여 Java 1.4에서 SpringMVC를 사용하였을 때, arid와 coc를 적용하였을 때, Jave 5.0+에서 annotation을 사용하였을 때를 비교한 것이다.
<table border='1' align='center' width='700' cellspacing='0'>
<tr>
<td align='center'>'''코드'''</td><td align='center'>'''Blog(Original)'''</td>
<td align='center'>'''Blog(arid+coc)'''</td><td align='center'>'''Blog(java5.0+ annotation)'''</td>
</tr>

<tr>
<td rowspan='2' align='center'>'''blog-servlet.xml'''</td><td>View Resolver bean 등록,<br>각 Controller-url 맵핑 bean 등록</td>
<td>Arid, mapping handler bean,<br>view name translator bean 등록</td>
<td>component scan,<br>view resolver bean 등록</td>
</tr>
<tr>
<td align='center'>약 30 lines</td><td align='center'>약 20 lines</td><td align='center'>약 15 lines</td>
</tr>

<tr>
<td rowspan='3' align='center'>'''Controller'''</td>
<td>blog.web.CreateBlogFormController,<br>blog.web.EditBlogFormController,<br>blog.web.FindBlogController</td>
<td>blog.web.BlogController</td><td>blog.web.BlogController</td>
</tr>
<tr>
<td>MultiActionController,<br>SimpleFormController 상속</td>
<td>MultiActionController 상속</td><td>@Controller 지정</td>
</tr>
</table>
{{경고|
*위 표는 Spring MVC를 이용하여 개발한 블로그의 예제에서 각 경우에 따라 설정파일 및 controller 파일을 최소화 하였을 때를 나타낸 것으로, 프로젝트 구조 및 성격에 따라 내용이 달라질 수 있다.
}}

===Arid===
*<arid:define-bean />
**클래스 및 클래스의 멤버변수를 bean으로 등록해주는 역할을 한다.
*arid 사용하기
**arid-framework.jar와 aspectjweaver.jar 클래스 파일이 필요하다.
**beans 정의에 arid를 추가해야 한다.
**web controller는 xxx-servlet.xml에서 설정한다.
**controller 클래스 멤버변수의 set 메소드의 작성이 필요하다.
<blockquote>
'''@Autowired == <arid:define-bean /> + setXXX()'''
</blockquote>
<code lang="xml">
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns:arid="http://chrisrichardson.net/schema/arid"
xsi:schemaLocation="http://chrisrichardson.net/schema/arid http://chrisrichardson.net/schema/arid.xsd" >


<arid:define-beans package="edu.blog" pattern="*..web.*Controller" autowire="byName"/>
</beans>
</code>
*한계
**Spring MVC annotation 중 @Autowired를 커버할 수 있지만, Controller, RequestMapping 등의 다른 annotation을 대체할 순 없다.
{{정보|
*(참고) [[에리드(ARID)|Arid]]
}}

===ControllerClassNameHandlerMapping===
*url과 클래스 맵핑의 관계를 자동으로 지정해주는 Handler Mapper이다.
*Conversion of Configuration(CoC)의 개념이다.
*ControllerClassNameHandlerMapping을 적용하지 않은 경우 Controller class에 대한 url을 직접 지정해주어야 한다.
<code lang="xml">
<bean name="/findBlogs.do" class="blog.web.FindBlogController">
<property name="blogService" ref="blogService" />
</bean>
</code>
*ControllerClassNameHandlerMapping을 적용한 경우 Controller class의 이름이 url로 자동 매핑된다.
<code lang="xml">
<bean class="org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping"/>
<bean class="blog.web.FindBlogController">
<property name="blogService" ref="blogService"/>
</bean>
</code>
*한계
**ControllerClassNameHandlerMapping을 사용하더라도, 각 controller 파일에 대해 bean 등록을 직접 해주어야 한다.
**클래스 및 메소드의 이름이 url로 사용되므로, 클래스 및 메소드 이름 결정에 주의해야 한다.
**Controller의 종류에 따라 url 매핑의 형태가 다르므로, jsp 소스 코드 관리에 주의해야 한다.
***MultiActionController의 경우 '''''/클래스이름/메소드이름.확장자'''''로 매핑되며, 다른 Controller의 경우 '''''/클래스이름.확장자'''''로 매핑된다.

==Arid + ControllerClassNameHandlerMapping==
*Arid의 자동 bean 등록과 ControllerClassNameHandlerMapping의 url 자동 매핑의 기능을 사용하여 설정파일을 간략하게 사용할 수 있다.
*Web Controller는 MultiActionController를 상속받아 사용함으로써 Controller 클래스의 수를 줄일 수 있다.
===servlet 설정===
*Arid와 ControllerClassNameHandlerMapping의 설정 만으로 기존의 url-controller class 설정을 모두 생략할 수 있다.
*InternalResourceViewResolver는 Controller에서 ModelAndView 타입이 아닌 ModelMap 타입으로 반환하더라도 알맞은 View를 선택하여 보여주도록 해준다.
**stripLeadingSlash 속성은 false로 설정을 해야 requestContext 이후의 정확한 url 매핑이 이루어진다. (stripLeadingSlash의 default value는 true이다.)
**InternalResourceViewResolver를 사용할 경우 suffix를 지정하기 위해 사용한 InternalResourceViewResolver를 중복으로 사용하지 않아도 된다. (단, 특정 viewClass를 지정하거나 InternalResourceViewResolver에서 필요한 속성을 설정하기 위해서는 지정해준다.)
<code lang="xml">

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:arid="http://chrisrichardson.net/schema/arid"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://chrisrichardson.net/schema/arid http://chrisrichardson.net/schema/arid.xsd" >


<arid:define-beans package="edu.blog" pattern="*..web.*Controller" autowire="byName"/>
<bean class="org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping"/>

<bean id="viewNameTranslator" class="org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator">
<property name="stripLeadingSlash" value="false"/>
<property name="suffix" value=".jsp"/>
</bean>


</beans>
</code>

===Web Controller===
*하나의 controller에서 처리하기 위해 MultiActionController를 사용하고, 메소드 형태의 혼란을 줄이기 위해 같은 형태의 메소드를 사용하였다.
*다른 레이어와 연계가 필요한 멤버변수(blogService)는 setXxx 함수로 설정을 해준다.
*서블릿에서 InternalResourceViewResolver를 사용하지 않을 경우, 반환형을 ModelAndView로 하여 view 이름을 지정해주어야 한다.
*deleteBlog()와 같이 직접 view로 반환하지 않는 메소드는 return type이 Map/ModelAndView형태가 아니어도 된다.
**redirect/forword 키워드로 알맞은 url로 변환해준다.
<code lang="java">
/* BlogController.java */
/* 패키지 선언 및 import 생략 */
public class BlogController extends MultiActionController {
private BlogService blogService;

public void setBlogService(BlogService blogService) {
this.blogService = blogService;
}

public Map findBlogs(HttpServletRequest request,
HttpServletResponse response) throws Exception {
Collection blogList = blogService.findBlogs();
return new ModelMap("blogList", blogList);
}

public String deleteBlog(HttpServletRequest request,
HttpServletResponse response) throws Exception {
blogService.deleteBlog(Integer.parseInt((String)request.getParameter("blogId")));
return "redirect:findBlogs.do";
}
</code>
*get 형태의 파라미터는 request.getParameter()로, post 형태의 form 관련 파라미터는 bind() 함수로 설정할 수 있다.
*SessionAttributes Annotation과 같이 하나의 blog 모델을 유지할 수 없기 때문에, View에서는 Controller에서 넘겨준 모델의 모든 정보를 다시 설정하여 보내주도록 해야한다. (blog 예제 소스 참고)
<code lang="java">
public Map createBlog(HttpServletRequest request,
HttpServletResponse response) throws Exception {
Blog blog = new Blog();
blog.setRegDate(new Date());
return new ModelMap("blog", blog);
}

public String addBlog(HttpServletRequest request,
HttpServletResponse response) throws Exception {
Blog blog = new Blog();
bind(request, blog);
blogService.createBlog(blog);
return "redirect:findBlogs.do";
}
/* 중간 생략 */
</code>
*MultiActionController로부터 override한 initBinder 함수는 form 관련 속성 값들에 대한 설정이 필요할 때 사용한다.
**이 예제에서는 Date Type과 String Type의 변환을 위해 initBind() 메소드를 사용하였다.
<code lang="java">
// Override
protected void initBinder(HttpServletRequest request, ServletRequestDataBinder binder) throws Exception {
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
CustomDateEditor dateEdit = new CustomDateEditor(df, false);
binder.registerCustomEditor(Date.class, dateEdit);
}

}

</code>

==Spring MVC Blog 예제 다운로드==
*SpringMVC + springframework + iBatis으로 이루어진 예제이다.
*[[media:blog_arid_coc.zip|Spring MVC Blog 예제 다운로드]]
*데이터베이스는 Oracle을 사용하였다.
{{정보|
*예제 실행을 위해서는 JDK, 이클립스, 톰캣 등의 개발환경이 필요하다. ([[개인 개발환경]] 참고)
}}

==참고자료==
*[http://static.springframework.org/spring/docs/2.5.x/reference/mvc.html Spring Web MVC Framework]
*[http://code.google.com/p/aridpojos/ Arid Pojo]

Spring MVC JSON

Kyoung94 — Sat, 28 Jun 2008 04:47:16 GMT

바꾼내용 간추리기: /* ViewResolver */

{{팁|
*산출물: Quick Start에서 SpringMVC/JSON/Ext-js 개발하기
*작성자: 서경진
*최초작성일 : 2008/07/04
*최종작성일 : 2008/07/14
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
{{정보|
* 이 문서에 해당하는 프로젝트는 Maven Project이므로 M2 Plugin을 활용한 라이브러리 관리 및 Build 및 Deploy 관리가 가능하다.
* Quick Start는 jetty와 hsql 기반이지만 이 프로젝트는 tomcat과 postgresql로 구현되었으므로 mvn에서 Build 및 Deploy를 위한 명령을 제공한다.
}}
{{경고|
*이 문서는 현재 작성중에 있습니다.
}}

=프로젝트 환경 구축하기=
*다음 Quick Start 매뉴얼에 따라 Spring MVC 기반으로 Ext-js, JSON을 적용한 웹 어플리케이션 환경을 구축할 수 있다.

{{정보|
*JCF Quick Start로 프로젝트 환경설치: http://wiki.dev.daewoobrenic.co.kr/mediawiki/index.php/JCFQuickStart
*프로젝트 생성에서 SpringMVC + Spring + IBatis 선택 후 프로젝트 구성: http://wiki.dev.daewoobrenic.co.kr/mediawiki/index.php/QuickStart:SpringMVCSpringIBatis
}}

*Local PC에 Maven을 위한 라이브러리 Repository를 설정하기 위하여 해당 사용자의 개인디렉터리에 있는 .m2 폴더에 설정파일(setting.xml)에 사용자의 환경에 맞도록 설정한다.

[[그림:Maven_LocalRepository_Configuration.JPG|600px|thumb|center|Maven Local Repository 설정파일]]

*다음은 .m2 디렉터리에 있는 setting.xml에 설정된 내용이다.

<code lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">

<localRepository>d:\maven\repository</localRepository> 

<mirrors>
<mirror>
<id>mirror-of-central</id>
<mirrorOf>*</mirrorOf>
<name>Mirror of central repository</name>
<url>http://scm.dev.daewoobrenic.co.kr/artifactory/repo</url> 
</mirror>
</mirrors>

<profiles>
<profile>
<id>mirroringCentral</id>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
<repositories>
<repository>
<id>central</id>
<url>http://scm.dev.daewoobrenic.co.kr/artifactory/repo</url>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>false</enabled>
</snapshots>
</repository>
<repository>
<id>snapshots</id>
<url>http://scm.dev.daewoobrenic.co.kr/artifactory/repo</url>
<releases>
<enabled>false</enabled>
</releases>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>central</id>
<url>http://scm.dev.daewoobrenic.co.kr/artifactory/plugins-releases</url>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>false</enabled>
</snapshots>
</pluginRepository>
<pluginRepository>
<id>snapshots</id>
<url>http://scm.dev.daewoobrenic.co.kr/artifactory/plugins-snapshots</url>
<releases>
<enabled>false</enabled>
</releases>
<snapshots>
<enabled>true</enabled>
</snapshots>
</pluginRepository>
</pluginRepositories>
</profile>
<profile>
<id>oracle</id>
<properties>
<db.groupId>com.oracle</db.groupId>
<db.artifactId>ojdbc14</db.artifactId>
<db.version>10.2.0.3.0</db.version>
<jdbc.driverClassName>oracle.jdbc.driver.OracleDriver</jdbc.driverClassName>
<jdbc.url>jdbc:oracle:thin:@DB서버IP:포트번호:SID</jdbc.url>
<jdbc.username>사용자ID</jdbc.username>
<jdbc.password>패스워드</jdbc.password>
</properties>
</profile>
</profiles>
</settings>
</code>

*로컬 저장소를 <localRepository>d:\maven\repository</localRepository>와 같이 저장하면 다음과 같이 Maven 저장소에서 받은 라이브러리가 이 위치에 저장된다.
*이와 같이 로컬 저장소를 설정하지 않으면 디폴트인 .m2 디렉터리에 라이브러리가 저장된다.

[[그림:Maven_LocalRealRepository.JPG|800px|thumb|center|로컬 저장소에 저장된 라이브러리]]

*command(cmd.exe) 콘솔을 실행시켜서 다음과 같이 명령을 입력하면 pom.xml에 정의된 hsql에 table을 생성하여 jetty가 구동된다.
*위에서 정의된 내용에 따라 memo 웹 어플리케이션이 구동되고 다음과 같이 웹브라우저로 확인이 된다면 SpringMVC + Spring + IBatis 아키텍처를 가진 Maven 프로젝트 기반으로 개발할 수 있는 환경이 구축된 것이다.

[[그림:MavenProject_MemoApplication.JPG|580px|thumb|center|memo 웹 어플리케이션 구동 화면]]

{{정보|
*샘플 웹 어플리케이션의 개발환경
**UI: Ext-js 2.0, JSP
**Presentation Tier: Spring MVC, Spring MVC Annotation (SpringFramework 2.5.4)
**Business Tier: SpringFramework 2.5.4
**Persistence Tier: ibatis 2.3.0
**DB: PostgreSQL 8.3.3
**IDE: Eclipse Platform 3.3.0 (WTP, DTP 적용)
**Build & Deploy: Maven
**WAS: Tomcat 5.0
}}

*위의 개발환경 정보에 따라 예제 어플리케이션의 개발은 jetty 환경이 아닌 Tomcat 환경에서 구현된다.
*따라서 소스개발 이후 Tomcat을 구동시키기 전에 다음과 같은 일련의 명령을 DOS Command 콘솔에서 실행해야 한다.

해당프로젝트위치> mvn compiler:compile
<pre>
: 수정된 내용에 대하여 Maven 기반의 컴파일을 수행한다. (Target에 저장)
</pre>
해당프로젝트위치> mvn war:inplace
<pre>
: Tomcat 환경에서 구동하기 위해 Web Root (src/main/webapp/WEB-INF의 lib와 classes 디렉터리에 라이브러리와 클래스를 복사한다.)
</pre>
해당프로젝트위치> mvn eclipse:eclipse
<pre>
: pom.xml로부터 eclipse 프로젝트 파일(.project)을 생성한다. 즉 라이브러리를 buildpath에 설정한다.
</pre>

*Quick Start에서 SpringMVC/JSON/Ext-js로 개발할 간단한 웹 어플리케이션은 다음과 같다.

[[그림:MavenProject_DSOMApplication.JPG|850px|thumb|center|Ext-js 기반 샘플 웹 어플리케이션 화면]]

*위의 샘플 웹 어플리케이션은 상단의 메뉴바에서 해당 메뉴를 클릭하면 부서리스트 조회화면이 우측 Div에 출력된다.
*우측 상단에 조회버튼을 클릭하면 서버에서 부서리스트를 조회하여 그 결과를 다음과 같이 JSON 데이터로 출력한다.

[[그림:MavenProject_JsonResponse.JPG|700px|thumb|center|조회 Request에 대한 JSON Response]]

*JSON 데이터를 받으면 위의 샘플 웹 어플리케이션 화면과 같이 데이터를 그리드에 바인딩한다.

=Spring MVC Request Lifecycle=
*샘플 웹 어플리케이션 구현은 Spring MVC Request Lifecycle을 기반으로 순서대로 진행될 것이다.

[[그림:SpringMVC_JsonView_Request_Sequence.jpg|820px|thumb|center|SpringMVC Request 처리 Sequence Diagram]]

*Spring MVC 기반의 웹 어플리케이션은 아키텍처 구성에 따라 일반적으로 다음과 같은 순서대로 설정파일을 구성한다.

<pre>
1. Request에 따른 DispatcherServlet의 요청 패턴을 정의 및 설정한다. => web.xml
</pre>

<pre>
2. DispatcherServlet이 참조할 HandlerMapping을 설정한다. => 서블릿명-servlet.xml (필요하다면 새로운 HandlerMapping 구현 가능)
(명시적으로 설정하지 않으면 Spring MVC는 BeanNameUrlHandlerMapping을 디폴트 HandlerMapping으로 설정)
</pre>

<pre>
3. HandlerMapping에 Controller mapping에 대한 정보를 설정한다.
3.1 Annotation을 사용하지 않는 경우, 서블릿명-servlet.xml에 mapping 정보를 설정한다.
3.2 Annotation을 사용하는 경우, Spring MVC Annotation을 사용하여 해당 클래스에 설정한다.
</pre>

<pre>
4. View를 처리하기 위한 ViewResolver 및 View에 대하여 설정한다.
</pre>

<pre>
5. Spring의 Application Context에 Controller, Service, Dao를 등록하기 위해 설정한다.
5.1 Annotation을 사용하지 않는 경우,
5.1.1 Controller를 Bean으로 등록한다.: 서블릿명-servlet.xml의 HandlerMapping에 설정된 Controller 클래스를 등록한다.
5.1.2 Service와 Dao를 모두 Bean으로 등록한다.

5.2 Annotation을 사용하는 경우,
5.2.1 Controller 클래스에 @Controller Annotation을 적용하고 서블릿명-servlet.xml의 Controller에 대한 Component 스캐닝을 통해 자동으로 bean을 등록한다.
5.2.2 Service 클래스에 @Component Annotation을 적용하고 applicationContext-어플리케이션명.xml의 Service에 대한 Component 스캐닝을 통해 자동으로 bean을 등록한다.
5.2.3 Dao 클래스는 SqlMapClient에 대한 등록문제로 Annotation을 사용하지 않는 방법과 같이 applicationContext-어플리케이션명.xml에 Bean으로 직접 등록한다.
</pre>

*위에 명시된 순서는 아키텍처 구조나 적용된 구성요소에 따라 변경이 필요할 수 있다.

=연동 설정방법=

<pre>
1. Request에 따른 DispatcherServlet의 요청 패턴을 정의 및 설정한다. => web.xml
</pre>

*Request에 따른 DispatcherServlet의 요청 패턴 정의 및 설정

<pre>
1. JSTL을 활용한 JSP 페이지를 출력할 경우 .action 패턴 적용
2. JSON을 활용한 Ext-js 페이지를 출력할 경우 .json 패턴 적용
</pre>

*웹 설정파일인 web.xml에 다음과 같이 설정한다.

<code lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext*.xml</param-value>
</context-param>

<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<filter>
<filter-name>characterEncodingFilter</filter-name>
<filter-class>
org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

<servlet>
<servlet-name>jsonview</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet>
<servlet-name>annotated</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>

<servlet-mapping>
<servlet-name>jsonview</servlet-name>
<url-pattern>*.json</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>annotated</servlet-name>
<url-pattern>*.action</url-pattern>
</servlet-mapping>
</web-app>
</code>

<pre>
2. DispatcherServlet이 참조할 HandlerMapping을 설정한다. => 서블릿명-servlet.xml (필요하다면 새로운 HandlerMapping 구현 가능)
(명시적으로 설정하지 않으면 Spring MVC는 BeanNameUrlHandlerMapping을 디폴트 HandlerMapping으로 설정)
</pre>

*HandlerMapping으로 BeanNameUrlHandlerMapping을 사용할 경우는 서블릿명-servlet.xml에 명시적으로 설정할 필요가 없다.
*만약 BeanNameUrlHandlerMapping이 아닌 다른 HandlerMapping을 사용할 경우에는 다음과 같이 명시적으로 설정한다.
*다음은 Spring MVC 매뉴얼에 있는 SimpleUrlHandlerMapping을 적용하는 방법이다.

*web.xml
<code lang="xml">
<web-app>
...
<servlet>
<servlet-name>sample</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>


<servlet-mapping>
<servlet-name>sample</servlet-name>
<url-pattern>*.form</url-pattern>
</servlet-mapping>


<servlet-mapping>
<servlet-name>sample</servlet-name>
<url-pattern>*.html</url-pattern>
</servlet-mapping>
...
</web-app>
</code>

*서블릿명-servlet.xml
<code lang="xml">
<beans>


<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="mappings">
<value>
/*/account.form=editAccountFormController
/*/editaccount.form=editAccountFormController
/ex/view*.html=helpController
/**/help.html=helpController
</value>
</property>
</bean>

<bean id="helpController"
class="org.springframework.web.servlet.mvc.UrlFilenameViewController"/>

<bean id="editAccountFormController"
class="org.springframework.web.servlet.mvc.SimpleFormController">
<property name="formView" value="account"/>
<property name="successView" value="account-created"/>
<property name="commandName" value="Account"/>
<property name="commandClass" value="samples.Account"/>
</bean>
<beans>
</code>

<pre>
3. HandlerMapping에 Controller mapping에 대한 정보를 설정한다.
3.1 Annotation을 사용하지 않는 경우, 서블릿명-servlet.xml에 mapping 정보를 설정한다.
3.2 Annotation을 사용하는 경우, Spring MVC Annotation을 사용하여 해당 클래스에 설정한다.
</pre>

==Controller==

==ViewResolver==

===JstlViewResolver===

===XmlViewResolver===

===MiplatformViewResolver===

==View==

===JstlView===

===JsonView===

===MiplatformView===

로그인 세션 체크하는 커스텀 인터셉터 만들기

Purple — Wed, 25 Jun 2008 06:50:16 GMT

바꾼내용 간추리기: /* 작업 개요 */

{{팁|
*산출물: 세션 체크하는 커스텀 인터셉터Spring MVC 개요
*작성자: 정광선
*최초작성일 : 2008/06/25
*최종작성일 : 2008/06/25
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
{{정보|
* 스트럿츠2에서 세션 검사하는 커스텀 인터셉터를 작성해 본다.
}}
{{경고|
* 권한별 요청 접근 처리가 아니며, 또한 모든 웹 요청이 아니라 스트럿츠 액션에 대한 요청만 처리하는 모듈 예제이다.
}}

==작업 개요==
* 로그인 했는지 검사하여, 로그인 하지 않았다면, 로그인 페이지나 특정 XML 메세지를 보내기 위한 인터셉터를 작성한다.
* 액션 요청에 대해서만 검증할 것이기 때문에 인터셉터에서의 적용이 적합하겠다.
* 적용 작업은 아래와 같다.
** 커스텀 인터셉터 작성하기
** struts.xml에 인터셉터 정의하여 적용하기
* [[media:custom_interceptor_session_check.png|처리 프로세스 플로우차트 보기]]

== 커스텀 인터셉터 작성하기 ==
* // TODO 부분(2군데..)는 해당 애플리케이션에 맞게 작성해 주어야 하겠다.
** 첫번째는 proccessDeniedResponse() 메소드에 있으며, 마이플랫폼 메세지를 던져주는 부분이다.
** 두번째는 isLogined()메소드에 있으며, 세션상에 로그인 정보를 검사하는 부분이다.
* 소스 설명
** 인터셉터가 작동하는 메인 메소드는 intercept(ActionInvocation invocation) 메소드이다.
*** 여기서 허용 URL인지, 로그인 했는지 검사하는 것과 요청을 거부하는 프로세스를 처리한다.
** excludeActions 변수는 로그인 했는지 검사하는 것에서 제외하기 위한 액션들이 있는 경우 사용한다.
** redirectWebPage 변수는 일반 웹 요청시 액션 수행 거부(로그인 하지 않음)에 대해 라디이렉트 할 페이지를 지정한다.
*** 이와 마찬가지로 마이플랫폼 요청에 대한 거부 메세지도 파라미터화 하여 처리할 수 있겠다.
<code lang='java'>
public class LoginSessionCheckInterceptor extends AbstractInterceptor{

private static Log log = LogFactory.getLog(LoginSessionCheckInterceptor.class);

protected Set excludeActions = null;

protected String redirectWebPage = "/index.html"; // default page if not setted by param.

public void setExcludeActions(String excludeActions) {
this.excludeActions = TextParseUtil.commaDelimitedStringToSet(excludeActions);
}

public void setRedirectWebPage(String redirectWebPage) {
if( StringUtils.isNotBlank(redirectWebPage)) this.redirectWebPage = redirectWebPage;
}

/**
* check and deny the request unless rquested action is available action without login or has authenticated session.
*
*/
public String intercept(ActionInvocation invocation) throws Exception {

if( isAvailableActionWithoutLogin() ){ // check if action is available action without login
return invocation.invoke(); // execute action
}
else{
if( isLogined()){ // check if logged in or not
return invocation.invoke(); // execute action
}
else{
proccessDeniedResponse(); // redirect to login page, or send denial xml message
return null;
}
}
}

private void proccessDeniedResponse() throws IOException {
if( isMiplatformRequest(ServletActionContext.getRequest()) ){
// TODO send MiResponse denial message
// example is following :
// MiResponse miresponse = new MiResponse(ServletActionContext.getResponse());
// miresponse.error("-1","sessionout");
}
else{
String redirectUrl = null;
if( redirectWebPage.startsWith("/") || redirectWebPage.startsWith("\\")){
redirectUrl = ServletActionContext.getRequest().getContextPath() + redirectWebPage;
}else{
redirectUrl = ServletActionContext.getRequest().getContextPath() + "/" +redirectWebPage;
}
ServletActionContext.getResponse().sendRedirect(redirectUrl);
}
}

private boolean isMiplatformRequest(HttpServletRequest request) {
String agent = request.getHeader("User-Agent");
if( agent != null && ( agent.indexOf("MiPlatform") != -1 ) ){
return true;
}else{
return false;
}
}

private boolean isLogined() {
HttpSession session = ServletActionContext.getRequest().getSession(false);
if( null == session) return false;

// TODO check if session is logined session.
// example is following :
// if( isLogedin(session) ) return true;
// else return false;

return false;
}

private boolean isAvailableActionWithoutLogin() {
String requestedResouece = getRequestedResource(ServletActionContext.getRequest());
if( log.isDebugEnabled() ) log.debug("Requested action resource : " + requestedResouece);

String action = null;
Iterator excludeActionsIter = excludeActions.iterator();
while( excludeActionsIter.hasNext() ){
action = (String) excludeActionsIter.next();
if( requestedResouece.equals(action) ) return true;
}

return false;
}

private String getRequestedResource(HttpServletRequest request){
String requestedResouece = null;

String contextPath = request.getContextPath();
String requestedUri = request.getRequestURI();

if( "/".equals(contextPath) ){
requestedResouece = requestedUri;
}
else{
requestedResouece = requestedUri.substring(contextPath.length());
}
return requestedResouece;
}
}
</code>

== 인터셉터의 적용 ==
* struts.xml에 우리가 작성한 인터셉터를 정의하고, 이를 이용하여 인터셉터 스택을 만든다.
* 정의가 끝나면 common 패키지를 상속하는 다른 모든 스트럿츠2 패키지들을 모두 디폴트 인터셉터 스택이 commonStack이 될 것이다.
** 여기서는 스트럿츠의 디폴트 인터셉터 스택을 다소 최적화하여 사용하고 있다.
** loginCheck 인터셉터의 정의 부분과 스택에서 사용하는 부분을 주의하여 살펴 본다.
** excludeActions 파라미터에는 샘플로 login.action과 /lab1/hello2.action은 로그인을 하지 않아도 수행할 수 있는 액션으로 정의해 놓았다.
** excludeActions 아래에 <param name="redirectWebPage">/login.jsp</param>를 추가 작성하면, 로그인 하지 않고 접근하는 액션 일반 웹 액션 요청들을 거부하고 login.jsp로 리다이렉트 하게 될 것이다.
** [과제] 웹 요청 말고도 마이플랫폼 요청을 거부하는 경우에 사용하는 에러코드와 에러메시지도 파라미터로 처리하도록 개선해 보자.
<code lang='xml'>
<struts>
<package name="common" extends="struts-default" namespace="">
<interceptors>
<interceptor name="loginCheck" class="kr.ac.catholic.web.struts2.interceptor.LoginSessionCheckInterceptor"/>
<interceptor-stack name="commonStack">
<interceptor-ref name="exception"/>
<interceptor-ref name="loginCheck">
<param name="excludeActions">login.action, /lab1/hello2.action</param>
</interceptor-ref>
<interceptor-ref name="alias"/>
<interceptor-ref name="servletConfig"/>
<interceptor-ref name="prepare"/>
<interceptor-ref name="i18n"/>
<interceptor-ref name="chain"/>
<interceptor-ref name="debugging"/>
<interceptor-ref name="fileUpload"/>
<interceptor-ref name="checkbox"/>
<interceptor-ref name="staticParams"/>
<interceptor-ref name="params">
<param name="excludeParams">dojo\..*</param>
</interceptor-ref>
<interceptor-ref name="conversionError"/>
<interceptor-ref name="validation">
<param name="excludeMethods">input,back,cancel,browse</param>
</interceptor-ref>
</interceptor-stack>
</interceptors>

<default-interceptor-ref name="commonStack"/>

</package>
</struts>
</code>

Spring MVC Annotation

Stardust — Tue, 24 Jun 2008 05:26:30 GMT

바꾼내용 간추리기:

{{팁|
*산출물: Spring MVC Annotation
*작성자: 나윤주
*최초작성일 : 2008/06/24
*최종작성일 : 2008/06/24
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
{{정보|
*이 문서는 Java 5+환경을 사용하는 Spring Web MVC Framework에서 적용할 수 있는 Annotation에 관한 것이다.
}}

==Spring MVC Annotation==
*Spring Web MVC Framework는 Java 5+ 부터 annotation을 제공한다. annotation의 사용으로 설정파일을 간결화하고, View 페이지와 객체 또는 메소드의 맵핑을 명확하게 할 수 있다.

===@Controller===
*Controller annotation으로 Controller interface 및 class의 기능을 간단하게 사용할 수 있다.
**Annotation을 사용하지 않고, Controller를 직접 상속받아 쓰는 경우 필요한 xml 설정을 생략할 수 있다.
**SimpleFormController, MultiActionController 등 Controller의 종류를 명시하지 않고 @Controller 설정만으로 사용할 수 있다.
*xxx-servlet.xml 파일에서 component-scan 으로 web controller가 있는 패키지를 명시해 줌으로써, 별도의 bean 설정을 하지 않아도 @Controller로 등록된 클래스 파일에 대한 bean을 자동으로 생성해준다.
**Controller로 사용하고자 하는 클래스에 @Controller 지정해주면 component-scan으로 자동 등록된다.
<code lang="xml">

<context:component-scan base-package="blog.web" />
</code>
<code lang="java">
/* BlogController.java */
package blog.web;

/* 기타 package import .. */
import org.springframework.stereotype.Controller;

@Controller
public class BlogController {
}
</code>

===@RequestMapping===
*RequestMapping annotation은 url을 클래스 또는 메소드와 맵핑시켜주는 역할을 한다.
**Annotation을 쓰지 않을때 지정했던 Controller 등록을 위한 url bean 설정을 생략할 수 있다.
*class에 하나의 url 맵핑을 할 경우, 클래스 위에 @RequestMapping("/url")을 지정하며, GET 또는 POST 방식 등의 옵션을 줄 수 있다.
**해당되는 메소드가 실행된 후, return 페이지가 따로 정의되어 있지 않으면 @RequestMapping("/url")에서 설정된 url로 다시 돌아간다.
<code lang="java">
/* 중간생략 */

@Controller
@RequestMapping("/helloWorld")
public class helloController {
/* 중간생략 */

@RequestMapping(method=RequestMethod.GET)
public returntype getController() {
/* .... */
}

@RequestMapping(method=RequestMethod.POST)
public returntype postController() {
/* .... */
}

/* 중간생략 */
}
</code>

*메소드별로 url 맵핑을 할 경우는 메소드 위에 @RequestMapping("/url")로 지정한다.
*return 페이지가 지정되지 않은 경우 원래의 맵핑되었던 url로 돌아간다.
**return type을 String으로 하여 redirect:url또는 forward:url을 사용하여 다른 페이지로 넘길 수 있다.
<code lang="java">
/* BlogController.java */
package blog.web;

/* 중간생략 */

@Controller
public class BlogController {
/* 중간생략 */

@RequestMapping("/createBlog")
public ModelMap createBlogHandler() {
blog = new Blog();
return new ModelMap(blog);
}

/* 중간생략 */
}
</code>

===@RequestParam===
*RequestParam annotation은 key=value 형태로 화면에서 넘어오는 파라미터를 맵핑된 메소드의 파라미터로 지정해준다.
*주로 get 방식으로 들어오는 request에서 사용한다.
**아래 예제코드에서 xxx/editBlog.do?blogId=3 과 같이 접근할 때, editBlogHandler 메소드의 파라미터인 blogId에는 3이 셋팅된다.
**필수 요건이 아닐 경우, @RequestParam(value="id", required="false")와 같이 옵션을 주고 사용할 수 있다.
<code lang="java">
/* BlogController.java */
package blog.web;

/* 중간생략 */

@Controller
public class BlogController {
/* 중간생략 */

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

/* 중간생략 */
}
</code>

===@ModelAttribute===
*ModelAttribute annotation은 화면의 form 속성으로 넘어온 model을 맵핑된 메소드의 파라미터로 지정해주는 역할을 한다.
*주로 POST 타입으로 넘어오는 form 속성의 model 값을 받아올 때 사용된다.
<code lang="java">
/* BlogController.java */
package blog.web;

/* 중간생략 */

@Controller
public class BlogController {
/* 중간생략 */

@RequestMapping("/updateBlog")
public String updateBlogHandler(@ModelAttribute("blog") Blog blog) {
blogService.updateBlog(blog);
return "redirect:findBlogs.do";
}

/* 중간생략 */
}
</code>

===@SessionAttributes===
*SessionAttributes annotation은 세션상에서 model의 정보를 유지하고 싶을 경우 사용할 수 있다.
<code lang="java">
/* BlogController.java */
package blog.web;

/* 중간생략 */

@Controller
@SessionAttributes("blog")
public class BlogController {
/* 중간생략 */

@RequestMapping("/createBlog")
public ModelMap createBlogHandler() {
blog = new Blog();
blog.setRegDate(new Date());
return new ModelMap(blog);
}

/* 중간생략 */
}
</code>

===@InitBinder===
@InitBinder annotation은 WebDataBinder를 초기화하는 메소드를 지정할 수 있는 설정을 제공한다. 일반적으로 WebDataBinder는 annotated handler 메소드의 command와 form 객체 인자를 조작하는데 사용된다. Initbinder 메소드는 command/form 객체와 validation result 객체와 대응하는 것을 제외하고 RequestMapping을 지원하는 모든 인자를 지원한다. Initbinder 메소드가 필수적으로 반환값을 가질 필요는 없으며, 일반적으로 이런 경우에 void를 선언한다.
특별한 인자는 WebDataBinder와 WebRequest 또는 Locale의 조합으로 이루어지며, 이러한 조건이 만족되면 context-specific editors를 등록하는 것이 허용된다.

*'''WebDataBinder''' : WebDataBinder는 web request parameter를 JavaBean 객체에 바인딩하는 특정한 DataBinder이다. WebDataBinder는 웹 환경이 필요하지만, Servlet API에 의존적이지 않다. Servlet API에 의존적인 ServletRequestDataBinder와 같이 특정한 DataBinder를 위한 더 많은 base classs를 제공한다.

*'''RequestMapping''' : RequestMapping annotation은 web request를 특정한 handler class와/나 handler method에 매핑하는 역할을 수행한다. 대응하는 HandlerMapping (for type level annotations)과/이나 HandlerAdapter (for method level annotations)가 dispatcher에 존재한다면, @RequestMapping이 처리될 것이다.

*'''WebRequest''' : WebRequest는 웹 요청에 대한 Generic interface이다. 주로 일반 request metadata에 generic web request interceptors의 접근을 허용하여 metadata에 대한 처리를 하기 위한 것이지 request 자체를 처리하기 위한 것은 아니다.

*@InitBinder 예제
다음의 InitBinder는 Request에 포함된 JSON 데이터를 binding하여 처리하는 역할을 수행한다.

<code lang="java">
......
@InitBinder
protected void initBinder(HttpServletRequest request, ServletRequestDataBinder binder) throws Exception {

if (logger.isDebugEnabled()) {
logger.debug("entering 'initBinder' method...");
}

JsonWriterConfiguratorTemplateRegistry registry = JsonWriterConfiguratorTemplateRegistry.load(request);
registry.registerConfiguratorTemplate(new JsonlibJsonWriterConfiguratorTemplate() {
@Override
public JsonConfig getJsonConfig() {
JsonConfig config = new JsonConfig();

// Exclude all date properties
config.setJsonPropertyFilter(new PropertyFilter() {
public boolean apply(Object source, String name, Object value) {
if (value != null && Date.class.isAssignableFrom(value.getClass())) {
return true;
}
return false;
}
});
return config;
}
});
}
......
</code>

==Spring MVC Annotation의 장점과 단점==

===장점===
*XML 설정파일에 대한 설정을 최소화할 수 있다.
*설정방법이 단순하다.
*관리해야 하는 XML 설정파일의 개수가 감소한다.
*대상 클래스에서 Auto Completion을 통한 구현이 가능하다.
*개발자가 설정되는 대상 클래스와 메소드에 대한 정확한 이해(매핑, 파라미터, 모델, 폼 등) 후 적용하므로 유지보수 및 관리가 용이해 진다.
*개발자적 입장에서 보았을 때, 보기 명확하며 편안하다.

===단점===
*Java1.5 이상의 환경에서 지원된다.
*XML 설정파일에서 제공되는 다양한 property 설정이 불가능하다.
*Annotation의 적절한 사용을 위한 진입장벽이 발생한다. (Learning Curve: 일정 기간의 학습이 필요함)
*Annotation의 내부 구조 이해가 어렵다.
*현재까지 Annotation 사용을 위한 Reference가 부족하다.

==Spring MVC Blog 예제 다운로드==
*SpringMVC + springframework + Hibernate3으로 이루어진 예제이다.
*[[media:blog_annotation.zip|Spring MVC Blog 예제 다운로드]]
*데이터베이스는 hsql을 사용하였다. 예제를 실행시키기 전에 data 폴더안의 server.bat 파일을 먼저 실행시켜 데이터베이스를 띄워야한다.
{{정보|
*예제 실행을 위해서는 JDK, 이클립스, 톰캣 등의 개발환경이 필요하다. ([[개인 개발환경]] 참고)
}}
{{정보|
*(참고) [[Annotation|Springframework와 관련된 Annotation]]
*(참고) [[어노테이션 기반 설정|annotation 기반 설정(component-scan 등)]]
}}

==참고자료==
*[http://static.springframework.org/spring/docs/2.5.x/reference/mvc.html Spring Web MVC Framework]

Spring MVC Basic

Stardust — Mon, 23 Jun 2008 08:34:06 GMT

바꾼내용 간추리기: /* Spring MVC 소개 */

{{팁|
*산출물: Spring MVC 개요
*작성자: 나윤주
*최초작성일 : 2008/06/23
*최종작성일 : 2008/06/27
'''Copyright © 2008 Daewoo Information Systems Co., Ltd.'''
}}
{{정보|
*이 문서는 Spring Framework에서 제공되는 Web MVC Framework인 Spring MVC에 관한 것입니다.
}}

==Spring MVC 소개==
*Web MVC framework은 Spring Reference의 Chapter 13. Web MVC framework에서 언급한 대로 다음과 같은 설계사상을 가지고 있다.
**'Spring's Web MVC framework is designed around a DispatcherServlet that dispatches requests to handlers, with configurable handler mappings, view resolution, locale and theme resolution as well as support for upload files.' (원문: http://static.springframework.org/spring/docs/2.5.x/reference/mvc.html). Web MVC framework는 Request를 Handler에 전달하는 역할을 담당하는 DispatcherServlet과 연동하는 구성요소로 설계된다.
**그 요소는 설정이 가능한 handler mapping, view resolution, locale and theme resolution 그리고 파일업로드를 지원하는 요소로 구성된다.
**'''설계의 핵심사상은 최소의 설정으로 패턴화된 다양한 Mapper, Handler 그리고 View를 제공하는 것'''으로서 간단한 설정을 통해 다양한 Request를 mapping하는 Mapper와 mapping된 Request를 처리하는 Handler, 그리고 비즈니스 모듈을 통해 처리된 컨텐츠를 다양한 View로 처리할 수 있는 기반을 제공한다.
*다음 그림은 SpringMVC의 설계사상을 기반으로 구성된 대상 클래스의 Lifecycle과 처리흐름을 나타낸다.

[[그림:springMVCArchitecture.jpg|700px|thumb|Spring web MVC Framework의 Lifecycle과 workflow|center]]

*Spring web MVC Framework는 기존에 사용되는 Struts, Servlet 등과 같이 웹 어플리케이션의 Presentation Tier에 적용된다. Spring web MVC Framework는 웹 어플리케이션 개발에서 구현과 설정을 간결하고 유연성있게 해준다.
*Struts와 비교해 보았을때, Struts의 Action 맵핑 대신 CommandController, FormController, MultiActionController 등 상황에 맞는 Controller를 사용할 수 있다. 또한, Java 5+ 이상에서는 annotation을 사용할 수 있어, 설정을 최소화 할 수 있게 해준다.

<pre>
Controller종류
* AbstractCommandController : Request 파라미터를 가진 commond 객체를 활용할 경우에 사용한다.
* MultiActionController : 동일 클래스에서 다양한 이름의 메소드를 정의하고 맵핑하는 경우에 사용한다.
* SimpleFormController: 정의된 다중 form을 처리할 때 사용한다.
* AbstractWizardFormController: wizard를 처리할 때 사용한다.
o method : onBind(), validatePage(), getTargetPage()
o parameter : _target,_finish,_cancel,_page
* AbstractFormController: Simple과 AbstractWizardFormController의 부모 클래스로, 사용하기 위해서 프로그래밍을 통해 before/after view 이름이 설정되어야 한다.
</pre>

==Spring MVC의 동작==
[[그림:springMVCworkflow.png|600px|thumb|Spring web MVC Framework의 workflow|center]]

*Spring web MVC Framework는 크게 Dispatcher Servlet, Controller, View Template로 구성되어 있다. ([http://static.springframework.org/spring/docs/2.5.x/reference/mvc.html Spring Reference] 참고)

===Dispatcher Servlet===
*Spring web MVC Framework의 Dispatcher Servlet은 다른 web MVC Framework와 마찬가지로 사용자의 요청을 url에 따라 정의된 Controller에 전달하고 요청에 따른 결과를 사용자에게 보여주는 역할을 한다.
*Dispatcher servlet은 org.springframework.web.servlet.DispatcherServle에 의해 표현되며, 클라이언트 요청을 처리하기 위한 Front Controller Design Pattern이다.
*클라이언트에서 요청한 모든 URL에 대하여 이 서블릿은 클라이언트의 Request가 Controller에 가기전에 해당 Request를 가로챈다.
*Web Configuration File은 Dispatcher Servlet이 클라이언트의 Request에 대하여 invoked 되도록 정의되어 있다.
*Web Configuration File인 web.xml에서 서블릿 맵핑을 시켜줌으로써 사용할 수 있다.
**아래의 코드와 같이 설정할 경우, <servlet-name>과 맵핑되는 blog-servlet.xml 파일이 요청되며, *.do의 url 요청은 모두 DispatcherServlet을 거치게 된다.
<code lang="xml">
<servlet>
<servlet-name>blog</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>blog</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</code>
*blog-servlet.xml은 빈으로 등록하는 url과 맵핑되는 Controller를 지정해주는 역할을 하게 된다.
**예제코드에서 보는 것과 같이 /createBlog.do라는 url로 접근을 하면, blog.web.CreateBlogController 클래스의 메소드가 실행된다.
**지정된 Controller 클래스는 Controller 인터페이스 또는 특정 Controller 클래스를 상속된다.

<code lang="xml">
<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">


<bean name="/createBlog.do" class="blog.web.CreateBlogController"/>
<bean name="/findBlogs.do" class="blog.web.FindBlogsController"/>

</beans>

</code>

====다중 DispatcherServlet 적용하기====

*클라이언트의 Request에 대한 다양한 servlet-mapping을 제공하기 위해 다중 DispatcherServlet 클래스를 등록하고 매핑정보를 web.xml에 설정한다.
*예를 들어, JstlView(JSP에서 JSTL을 활용하는 경우)와 JsonView(Ext-js에서 JSON을 활용하는 경우)를 동시에 하나의 웹 어플리케이션에서 활용하는 경우, 다음과 같이 설정하여 적용할 수 있다.

<code lang="xml">
<servlet>
<servlet-name>blog</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet>
<servlet-name>blog2</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>blog</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>blog2</servlet-name>
<url-pattern>*.json</url-pattern>
</servlet-mapping>
</code>

===Controller===
*web MVC 모델에서, Controller는 전달받은 사용자의 요청을 서비스로 연결해주는 역할을 한다. 또한, 서비스로부터 받은 요청 결과를 다시 사용자에게 전달해 준다. Spring web MVC Framework의 최상위 Controller는 interface로 제공되고, 각 역할에 따라 Form에 관련된 Controller, command에 관련된 Controller 클래스 등을 제공한다. Controller interface는 ModelAndView 타입의 반환 값을 가지는 handleRequest method를 포함하며, 이 메소드에서 사용자에게 전달할 응답 결과를 ModelAndMap 형태로 하여 반환한다.
*Web controller를 사용하기 위해서는 xxx-servlet.xml 파일에 controller 등록이 필요하다.

----

*'''Controller''' interface의 사용
**handleRequest 메소드를 override하여, 이 FindBlogController가 해야하는 동작을 정의한다.
**아래의 코드는 findBlogs.do라는 url 요청이 들어오면 blog.web.FindBlogController 클래스의 handleRequest가 수행된다.
<code lang="xml">

<bean name="/findBlogs.do" class="blog.web.FindBlogController">
<property name="blogService" ref="blogService"/>
</bean>
</code>
<code lang="java">
/* FindBlogController.java */
/* package 정의 및 import */
public class FindBlogController implements Controller {
private BlogService blogService; // 서비스 클래스 정의

public ModelAndView handleRequest(HttpServletRequest request,
HttpServletResponse response) throws Exception {

Collection<Blog> blogList = blogService.findBlogs();
return new ModelAndView("findBlogs", "blogList", blogList);
}

public void setBlogService(BlogService blogService) {
this.blogService = blogService;
}
}
</code>

*'''SimpleFormController''' class의 사용
**화면의 form 태그와 관련된 동작을 수행할 때 사용한다.
**formBackingObject 메소드는 form 화면을 보여주기 위한 값 설정에, onSubmit 메소드는 화면의 form 결과를 전달하기 위해 사용한다.
<code lang="jsp">


<form:form name="blogForm" commandName="create">

</form:form>
</code>
<code lang="xml">


<bean name="/createBlog.do" class="blog.web.CreateBlogFormController">
<property name="blogService" ref="blogService"/>
<property name="commandClass" value="blog.model.Blog"/>
<property name="commandName" value="create"/>
</bean>
</code>
<code lang="java">
/* CreateBlogFormController.java */
/* package 정의 및 import */
public class CreateBlogFormController extends SimpleFormController {
private BlogService blogService; // 서비스 클래스 정의

protected ModelAndView onSubmit(Object command) throws Exception {
Blog blog = (Blog) command;
blogService.createBlog(blog);
return new ModelAndView(new RedirectView("findBlogs.do"));
}

protected Object formBackingObject(HttpServletRequest request)
throws Exception {
Blog blog = new Blog();
blog.setRegDate(new Date());
return blog;
}

public void setBlogService(BlogService blogService) {
this.blogService = blogService;
}
}
</code>

*'''MultiActionController''' class의 사용
**하나의 controller 클래스에서 다양한 요청을 처리하기 위해 사용한다.
**다음과 같은 형태로 메소드를 작성 해야한다.
<blockquote>
public [ModelAndView | Map | void] anyMeaningfulName(HttpServletRequest, HttpServletResponse [, Exception | AnyObject]);
</blockquote>
**메소드 이름은 맵핑하고자 하는 url 이름과 같게하여 작성한다.
**아래의 예제는 위의 FindBlogController 클래스를 변형하여 findBlogs와 deleteBlog를 수행할 수 있게 하였다.
<code lang="xml">

<bean name="/findBlogs.do" class="blog.web.FindBlogController">
<property name="blogService" ref="blogService"/>
</bean>
<bean name="/deleteBlog.do" class="blog.web.FindBlogController">
<property name="blogService" ref="blogService"/>
</bean>
</code>
<code lang="java">
/* FindBlogController.java */
/* package 정의 및 import */
public class FindBlogController extends MultiActionController {
private BlogService blogService; // 서비스 클래스 정의

public ModelAndView findBlogs(HttpServletRequest request,
HttpServletResponse response) throws Exception {
Collection<Blog> blogList = blogService.findBlogs();
return new ModelAndView("findBlogs", "blogList", blogList);
}

public ModelAndView deleteBlog(HttpServletRequest request,
HttpServletResponse response) throws Exception {
blogService.deleteBlog(Integer.parseInt((String)request.getParameter("blogId")));
return new ModelAndView(new RedirectView("findBlogs.do"));
}

public void setBlogService(BlogService blogService) {
this.blogService = blogService;
}
}
</code>

===View Template===
*사용자의 요청을 Controller에 전달하고, 또 Controller에서 전달받은 응답 결과를 화면에 보여주기 위해, spring form 태그와 jstl 태그 등을 사용하여 View 페이지를 작성 할 수 있다.

==Spring MVC의 예외처리==
*Spring MVC에서 제공하는 예외처리는 발생하는 예외에 따라 적절한 에러 페이지를 보여주고 싶을 때 사용할 수 있다.
**springframework의 샘플 코드 중 아래의 petclinic 예제에서는 DataAccessException 또는 TransactionException가 발생할 경우 dataAccessFailure.jsp 페이지로 예외를 넘겨준다.
*HandlerExceptionResolvers interface를 구현하여 사용자 예외를 직접 처리 할 수 있고, SimpleMappingExceptionResolver class를 사용하여 이미 정의된 예외에 대한 처리를 할 수 있다.
<code lang="xml">

<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
<property name="exceptionMappings">
<props>
<prop key="org.springframework.dao.DataAccessException">dataAccessFailure</prop>
<prop key="org.springframework.transaction.TransactionException">dataAccessFailure</prop>
</props>
</property>
</bean>
</code>

==Spring MVC Blog 예제 다운로드==
*SpringMVC + springframework + Hibernate3으로 이루어진 예제이다.
*[[media:blog2.zip|Spring MVC Blog 예제 다운로드]]
*데이터베이스는 hsql을 사용하였다. 예제를 실행시키기 전에 data 폴더안의 server.bat 파일을 먼저 실행시켜 데이터베이스를 띄워야한다.
{{정보|
*예제 실행을 위해서는 JDK, 이클립스, 톰캣 등의 개발환경이 필요하다. ([[개인 개발환경]] 참고)
}}

==참고자료==
*[http://www.springframework.org Springframework]
*[http://static.springframework.org/spring/docs/2.5.x/reference/mvc.html Spring Web MVC Framework]
*[http://www.habuma.com/spring/SpringMVCandSecurity.pdf Spring MVC & Spring Security]
*[http://www.flickr.com/photos/60896767@N00/89101625/sizes/l/ Spring MVC Request LifeCycle 그림]

Ext-JS CRUD

Alsdkzz — Mon, 23 Jun 2008 01:02:59 GMT

바꾼내용 간추리기: /* 저장하기 */

=Ext-js기반의 CRUD만들기=
==조회하기==
*js파일의 findData함수
<code lang='javascript'>
function findData() {

params = "{"
+ 'deptCoder:\"' + Ext.get('shDeptCode').dom.value + "\","
+ 'deptNamer:\"' + Ext.get('shDeptName').dom.value + "\","
+ 'custCoder:\"' + Ext.get('shCustCode').dom.value + "\""
+ "}"

Ext.Ajax.request({
url: '/mdms/deptInfo/findDeptSpecs.action',
jsonData: params,
headers: {
'Content-Type': 'application/json'
},
success: function( r, o ) {
alert(r.responseText);
try {
specStore.loadData(Ext.decode(r.responseText));

} catch(e) {
}
},
failure: function( r, o ) {
alert("ERR"+r.responseText);
}
})
}

</code>
*struts.xml
<code lang='xml'>
<action name="findDeptSpecs" class="com.daewoobrenic.dsom.mm.action.DeptInfoAction" method="findDeptSpecs">
</action>
</code>
*action
<code lang='java'>
public String findDeptSpecs() {

deptMasts = new ArrayList();
Map searchMap = (Map) InChannel.getVariables();
deptMasts.add(deptInfoService.viewDeptMast(searchMap));
deptSpecs = deptInfoService.viewDeptSpecs(searchMap);
OutChannel.setDataSet("deptSpecs", deptSpecs);
OutChannel.send();

</code>

==추가/삭제(그리드 적용시)==
*그리드에서 셀추가는 화면에서만 이루어지는 것이므로 js파일만 다음과 같이 작성 하면된다.
**추가)EditorGridPanel에 tbar로 그리드에 '''추가''' 버튼 넣고 insertHandler함수 호출하기
***insertHandler
<code lang="javascript">
function insertHandler(btn) {
var code = new Code({ //초기값 셋팅
flag: 'insert',
id: ' ',
name: '',
inUse: '사용',
parentId: '',
description: '',
indoor: false
});
gridForm.stopEditing();
codeStore.insert(0, code);
gridForm.startEditing(0, 0);
}
</code>
**삭제)EditorGridPanel에 tbar로 그리드에 '''삭제''' 버튼 넣고 공통 스트립트의 deleteGridRow함수에 EditorGridPanel 넘기면 삭제완료
** 그리드 부분 소스
<code lang="javascript">
var gridForm = new Ext.grid.EditorGridPanel({
id: 'company-form',
store: codeStore,
cm: colModel,
sm: sm,
renderTo: 'upperWork_grid',
autoExpandColumn: 'desc',
width:700,
autoWidth: true,
height:350,
title:'CI 분류목록',
clicksToEdit:2,
frame:true,
bbar: new Ext.PagingToolbar({
pageSize: 10,
store: codeStore,
displayInfo: true,
displayMsg: 'Displaying topics {0} - {1} of {2}',
emptyMsg: "No topics to display"
}),
tbar: [{
text: '추가',
handler: insertHandler,//함수호출
iconCls: 'blist'
}, {
text: '삭제',
handler : function(){
deleteGridRow(gridForm);
},
iconCls: 'blist'
}]
});
});
</code>

==저장하기==
*화면에서 저장 버튼을 누르면 화면에서만 입력과 수정, 삭제되었던 데이터들이 한꺼번에 서버에 날라가고 서비스에 각각 해당되는 Dao를 호출한다.
**js파일이 saveData()
<code lang="javascript">
function saveData() {
var param = createGridData(codeStore);
param = "{" + '"codeList":' + param + "}" //codeList은 action에서 받는 dataSet이름
Ext.Ajax.request({
url: '/dsom/comCode/saveComCodeList.action',
jsonData: param,
headers: {
'Content-Type': 'application/json'
},
success: function( r, o ) {
setMessage("success");
codeStore.commitChanges();
},
failure: function( r, o ) {
setMessage("ERR");
}
})

}
</code>
**action의 saveComCodeList()
***InChannel.getDataSetList메소드에 해당되는 모델 클래스(Code.class), 와 js파일에서 넘긴 dataSet(codeList) 넘김
<code lang='java'>
public String saveComCodeList(){
codeList = new ArrayList();
codeList = InChannel.getDataSetList(Code.class, "codeList");
codeService.saveComCodeList(codeList);
return null;
}
</code>
**service의 saveComCodeList()
***받은 list를 for으로 돌려 insert, update, delete 중에 해당되는 Dao를 호출함.
<code lang='java'>
public void saveComCodeList(List codeList) {
// TODO Auto-generated method stub
// Flag로 수정인지 조회인지, 삭제인지 파악
for (int i = 0; i < codeList.size(); i++) {
code = (Code) codeList.get(i);
System.out.println(code.getFlag());
if (Constant.USER_STATUS_INSERT.equalsIgnoreCase(code.getFlag()))
codeDao.createCode(code);
else if (Constant.USER_STATUS_UPDATE.equalsIgnoreCase(code
.getFlag()))
codeDao.updateCode(code);
else if (Constant.USER_STATUS_DELETE.equalsIgnoreCase(code
.getFlag()))
codeDao.deleteCode(code.getId());
else
throw new BusinessException("Row Status" + code.getFlag()
+ " is not appropriate.");
}

}
</code>