Beyond J2EE

Struts 2로 동적 데이터 처리하기

2010-08-10T19:28:00.000-07:00

http://durl.kr/28q9c

JAXB가 싫다면...XStream 사용하기

2010-08-02T22:45:00.000-07:00

http://durl.kr/27ejc

Spring MVC 3 Showcase

2010-07-25T23:27:00.000-07:00

http://durl.kr/266km

How to Test for Cross-site Scripting (XSS)

2010-07-22T07:45:00.000-07:00

http://utku-utkan.appspot.com/2010/07/13/how-to-test-for-cross-site-scrpiting-xss/

REST, 웹 서비스, REST-ful 서비스

2010-07-21T19:20:00.000-07:00

http://durl.kr/25ifk

Spring 3.0 MVC Series Part 5: Internationalization & Localization Tutorial with Example

2010-07-16T22:47:00.000-07:00

http://durl.kr/24rvk

Spring 3.0 MVC Series Part 4: Internationalization & Localization Tutorial with Example

2010-07-16T22:45:00.002-07:00

http://durl.kr/24rvc

Spring 3.0 MVC Series Part 3: Handling Forms in Spring 3.0 MVC

2010-07-16T22:45:00.001-07:00

http://durl.kr/24rv7

Spring 3.0 MVC Series Part 2: Create Hello World Application in Spring 3.0 MVC

2010-07-16T21:58:00.000-07:00

http://durl.kr/24roa

Spring 3.0 MVC Series Part 1: Introduction to Spring 3.0 MVC framework

2010-07-16T21:57:00.000-07:00

http://durl.kr/24ro4

Calculate Free Disk Space in Java using Apache Commons IO

2010-07-14T01:34:00.001-07:00

http://durl.kr/247e5

SpringShowCase IDE 다운 받기

2010-07-07T07:55:00.001-07:00

아 제가 SpringShowCase IDE를 구글 문서에 업로드 했는데

모르고 비공개를 설정을 했네요 ㅠ.ㅠ

정말 죄송 합니다.

앞으로 아래 주소에 접근 해서

http://code.google.com/p/springshowcase/wiki/SSCAllToolSetting

다운 받으시면 됩니다.

Exchanging Data with XML and JAXB

2010-07-06T00:29:00.000-07:00

http://durl.kr/22usd

J2EE6에서 DataSource 사용 하기

2010-07-06T00:27:00.000-07:00

http://durl.kr/2338u

Locking and Concurrency in Java Persistence 2.0

2010-07-06T00:26:00.001-07:00

http://durl.kr/2336w

JBoss Tools on Eclipse 3.6 (Helios) Release!!

2010-07-06T00:24:00.002-07:00

http://durl.kr/2338f

STS on Eclipse 3.6 Release

2010-07-06T00:24:00.001-07:00

http://durl.kr/2336j

SpringBatch In Action 출시 진행 중!!

2010-07-06T00:22:00.000-07:00

로드 존슨형 트위터에서 가져 왔습니다.
http://durl.kr/23373

Java Collections API에 대해 모르고 있던 5가지 사항

2010-07-02T06:10:00.001-07:00

http://bit.ly/bWOx67

Spring DM Server의 새로운 이름 Virgo

2010-07-02T06:03:00.001-07:00

http://bit.ly/bv6EEV

Servlet 3.0에서 비동기 처리 방법

2010-07-02T06:00:00.001-07:00

http://bit.ly/9kThJA

이클립스에서 Code Template 사용하기

2010-07-02T05:46:00.001-07:00

http://bit.ly/b1ekgC

톰캣7 Release!!

2010-07-02T05:43:00.000-07:00

http://bit.ly/cL9Ecf

Eclipse 프로젝트 중에서 가장 멋진 25개 프로젝트

2010-07-02T05:42:00.001-07:00

http://bit.ly/c35mRm

OSGi Bundles의 두 가지 의존 타입

2010-06-06T02:56:00.000-07:00

(1) Package dependency: A bundle exports its packages so that

other bundles can import the packages

and then access the classes, interfaces,

and resources in the packages.

(2) Service dependency: A bundle registers its objects to

the service registry provided by the OSGi

container as OSGi services, so that other bundles

can consume the services.

OSGi의 이점

2010-06-06T02:30:00.000-07:00

거의 한달만에 포스트를 올리네요 .

한달 동안 정말 개인적으로 너무 힘들 었습니다.

이제 정신이 들어서 다시 블러그를 하려고 합니다.

당분간 Spring DM관련해서 포스팅을 하려고 합니다.

OSGi's Advantages

- 전체 시스템을 restart 하지 않고 각 모듈 (class, jar) 단위로

dynamically하게 install,uninstall,update,start,stop 할 수 있음

- 하나의 시스템내에서 각 모듈의 버전 정보를 복수로 install 할 수 있음

시스템 업그레이드에 좋은 대안이 될 수 있음

- OSGi 컨테이너는 모듈관의 의존 관계를 관리 한다.

- 각 모듈 (bundle)은 개별적인 life cycle을 가지고 있음.

- 각 모듈은 SOA 처럼 서비스로 노출하고 , 사용 할수 있음.

즉 느슨한 연결과 Service-Oriented한 설계를 가능 하도록 함.

최근 프로젝트 분위기

2010-05-07T09:08:00.000-07:00

최근의 프로젝트 분위기를 보면 어느때 보다
최악의 한해를 보내고 있는 것 같습니다.
1월부터 3월까지는 비수기라 치고
4월,5월 까지 프로젝트 물량이 나오지 않는
다는 것은 다소 심각 하다고 볼 수 있습니다.

물론 앞으로 시간이 지나면 풀린다 라고 얘기
할 수도 있지만 현재 분위기는 전혀 장담 할수가
없습니다.
(몇일 전만 해도 코스피 1730 이였는데 이 글을
쓰는 시점은 1630)

현재 진행 하려고 하는 프로젝트들이
갑자기 drop 되거나 holding 되는 경우가 많습니다.

설사 진행이 되더라도 대부분 기간이 3 ~ 4개월
정도이고 중장기 프로젝트는 거의 찾아 볼 수가
없습니다.

그리고 기존 협렵업체나 외부 소싱 인력의 TO를
Big3 업체의 정규직으로 대체하는 경우가
최근들어서 많이 늘었습니다.
아무래도 매출액 때문이겠죠.
(프로젝트 비용이 거의 노마진 수준)

그래서 시장에서 고급인력의 수요는
거의 없으며 프리랜서 같은 경우는
정말 key man 같은 스페셜
리스트가 아닌 경우는 고급으로
들어갈 수가 없습니다.
(예전 처럼 경력이나 등급이 고급이라고
해서 고급단가 그대로 주는 시대는 갔음)

이러다 보니 고급 프리랜서들이 경력을
다운 사이징 하거나 협의를 통해서 중급같은
고급들이 많아지고 있습니다.
단가 또한 공급이 많으니 당연히
내려 가겠죠.

그리고 예전엔 xxx 프로젝트는 안간다.
이렇게 나름 구분해서 골랐다면 지금은
기간이나 모든 것이 예전보다 열악하기 때문에
지금은 어딜가나 고생은 각오 하셔야 할 것
같습니다.
(최근 면접 본데는 2주 설계완료,개발 한달 이였음..)
그냥 일하는 것 자체만으로 행복하다고 생각
하면서 긍정적으로 일하는게 좋을 듯 합니다.

가끔 후배들 중에서 프리를 하고 싶어 하거나
또는 현재 근무환경에 불만을 가지는 분들은
허벅지바늘로 찌르고 참으시라고 말씀 드리고
싶습니다.
어떻게 보면 행복한 고민 입니다.
한번 몇달 쉬어보면 아실 것입니다.
즉 힘드시더라도 일단 어느 정도 경기가
풀린다고 생각 되면 그때 움직이시란 뜻 입니다.

그리고 이렇게 일이 없다보니 면접이 예전보다
많이 까다로와 졌습니다.
예전에는 면접을 하면 바로 언제 출근 가능하냐
하면서 바로 확정을 지었는데 요새는 아무래도
인력이 많다 보니 예전보다는 깐깐하게 면접을
진행 하는 것 같습니다.
(자기 개발만이 살길.... 무늬만 고급은 이제 고급 단가를
받기 어려움)

이런 분위기에서 최신 트렌드 운운하는 것이
업계 모든 분들께 과연 어떻게 다가갈까
하는 생각이 듭니다.
씁쓸하죠.....

일부러 회의적인 글을 쓰려고 한 것은 아니고,
나름 현실에 대한 정보를 제공 하려는 것 뿐입니다.
이럴때 일수록 서로 예민하지 말고 힘내서
극복해 나갔으면 합니다.
분명 언제가 IT 업계 모든분들이 즐거울
날이 오겠죠 모두 화이팅 !!

세미나 공지!!

2010-04-21T18:32:00.000-07:00

아래와 같이 세미나를 하려고 합니다.

시간 : 4/24 오후 5시 ~ 8시
장소 : 강남역 모토 (http://www.mottozone.com/)

(1) J2EE 와 오픈소스의 현재 트렌드
(2) Spring Overview
(3) Spring 개발 환경 설정
(4) ssc-mvc 구현 및 실행 방법
(5) ssc-rpc 구현 및 실행 방법
(6) 실무에서 스프링 활용예
(7) Application Architect 소개

참여하고 싶은 분은 springorg@gmail.com으로 연락주세요

Application Architect란?

2010-04-20T07:37:00.000-07:00

몇년전 JCO 컨퍼런스에 참석한적이 있었습니다.
제가 들으려는 section은 사람들이 너무 많아서
들을 수가 없었습니다.
그래서 시간내서 온 것이 아까워서 사람들이
덜 몰리는 section쪽으로 갔습니다.

이동한 section의 컨퍼런스 주제는
"Application Architect" 였습니다.

※ 이하 Application Architect를 AA로 하겠습니다.

내용을 곰곰히 들어 보니 현재 제가 하고 있는
일도 포함이 되었고 반면에 내가 하지 않은
생소한 일도 있었습니다.

마지막에 강사님께서 앞으로
프로젝트에서 AA 롤은 반드시 필요 하며
또한 그에 따른 수요도 증가 할 것이다.

앞으로 고급 프로그래머라면 충분히 도전할
만한 가치가 있다 라고 말씀 하셨습니다.

레퍼런스가 끝나고 저를 포함한 참석했던 분들의
애매한 표정이 생각 납니다.

그러고 몇년이 지나서 최근 프로젝트에
조금씩 AA롤을 수행 하는 분들을 종종 만나게 됩니다.

그분들에게 "What's Application Architect?"
라고 물어보면 대답이 다들 제각각 이였습니다.
심지어 어떤곳은 TA (Technical Architect)라는용어를
사용하거나 프레임웍커(프레임웍 구축자)라고
하는 곳도 있었습니다.

혹시나 해서 웹 으로 검색을 해봐도
AA에 대한 정의가 개념적이지 구체적인
내용을 찾기가 어려웠습니다.

그렇다면 과연 AA는 프레임웍 과 공통 모듈을
구현 하는 사람인지 아니면 GoF의 디자인 패턴을
사용해서 멋지게 UML 설계를 하는 사람인지..

과연 여러분은 프로젝트에서 AA는 무엇이라고 생각
하십니까?

불명확한 실체에 대해서 한 개인이 정의를 내린다는 것은
상당히 조심스러운 행동이라고 생각 합니다.

그래서 주관적인 생각을 최대한 자제 하고
관련 책들과 자료 그리고 AA 담당자들과
대화에 근거 해서 설명 드리도록 하겠습니다.

Application Architect란?

시스템 특징에 적합한 설계와 구현의 지침인 아키텍쳐
를 작성하고, 이것을 개발팀 전원이 파알할 수 있도록
하는 것이다. 이를 통해 시스템의 품질을 끌어 올린다.
다수가 참여하는 프로젝트에서 아키텍트의 주된 업무는
설계 단계에 진행된다.
아키텍트는 설계 단계 전까지 준비한 아키텍쳐를 개발팀
에게 전달 하고, 팀원들이 아키텍쳐 설계서에 따라
설계와 구현을 할 수 있도록 지원 한다.

- 아키텍트 이야기 85p -

정보시스템에 대한 전반적인 지식과 시스템 구축
노하우를 보유한 경험이 풍부한 기술 전문가로서
프로젝트 전반에 대한 기술적인 총괄 책임을
담당한다.
아키텍처 정의에서 아키텍트가 수행
하여야 하는 업무로서 프로젝트에서 구축 하고자
하는 정보 시스템의 기반 구조를 정의한다.
기반구조의 정의에는 시스템 플랫폼,운영 및 개발환경
,표준 프로토콜,소프트웨어/하드웨어 솔루션 벤치마킹
및 선정 ,시스템 인터페이스 관계 정의,데이터 분산 및
통합 방안등 시스템의 기본적인 골격에 관련된
내용을 포함 한다.

- SI Project (전문가로 가는길) -

즉, 쉽게 설명하면 분석시에 업무담당자 한테
시스템 모모 필요 하니? 필요한 청사진 그리고
설계 단계에서 좀더 구체적으로 표준안 잡고
프레임웍 구축하고 개발자 교육하고
테스트 하는 일련에 Application A~Z까지
전체 총괄하는 롤이라고 이해 하시면 됩니다.

아키텍트 수행 역할

- 프로젝트 착수 시 제안서와 계약서를 검토하여 기본적인
소프트웨어 및 하드웨어 아키텍쳐 환경에 대안 초안을
작성 한다.

- 분석 단계에서 전체 시스템에 대한 아키텍쳐 정의를 통해
소프트웨어 및 하드웨어 인프라 구조 정의,
서버 및 네트워크의 기본 모델 정의, 어플리케이션 모듈의
최상위 수준 모델링 등을 수행한다.

- 분석 단계에서 프로세스 모델링 및 데이터 모델링을 수행할 때
시스템 기본 아키텍처를 준수하도록 분석 산출물에
대한 검증을 수행한다.

- 소프트웨어 개발 환경 표준을 정의한다. 소프트웨어 개발을 위한
개발도구의 선정과 프로토타이핑를 주관한다.

- 설계 단계에서 프로그램 및 데이터베이스에 대한 설계 내용을
아키텍처 관점에서 표준의 준수 여부를 검증한다.

- 시스템 테스트 시나리오에서 아키텍쳐와 관련된 시스템 테스트
시나리오의 작성을 총괄 한다.

아키텍트에게 요구 되는 것

※상,중,하는 역량의 중요도 입니다.

- 비용관리 (하)
- 일정 관리 (하)
- 요구 사항정의(하)
- 명세 수립 (중)
- 소프트웨어 설계 (상)
- 프로그래밍 (상)
- 개발 방법론 (상)
- 인프라 구축 (중)
- 테스트 방법 (중)
- 품질 관리 (하)

실무에서 Application Architect

실무에서 만났던 대부분의 AA는
개발 주관 업체(일명:"을" Big3) 에서 하거나
컨설팀 업체에서 담당을 합니다.
(이유는 크리티컬한 업무이기 때문이죠^^)

그리고 전체적인 분석 및 설계 부분을
대부분 참여 하고 프레임웍 구축 및
코어 공통 모듈에 대해서는 거의
참여를 하지 않습니다.
그래서 대부분 AA + 전문 기술팀(Technical Architect) 또는
AA +TA로 구성된 단일 AA팀으로 구성이 되어있 있습니다.

개인적으로는 이러한 구성이 맞다고 생각 합니다.
과연 AA만으로 신기술과 오픈 소스 홍수 속에서
구현까지 잘 할수 있을까요?
그리고 장애복구,서버이중화등 비기능적 크리니컬
영역에 대해서도 해당 전문가와 co-work를 해야
합니다.
물론 단기 프로젝트거나 프로젝트 규모가
크지 않다면 충분히 혼자서도 가능 하겠죠.

AA 준비 하기...

사실 저도 AA는 아닙니다. (전 해커에 가깝다고
할까요 ㅋㅋ. 워낙 오픈소스 기반에 매쉬업을
좋아해서 )
이런 위치에서 AA 준비를 이렇게 하라고 말
하는 자체가 웃긴 일이지만 저 또한 AA가
되기 위해서 노력하는 사람으로써 말씀 드리겠습니다.

먼저 되도록 Big3 업체 또는 개발 전문 컨설팅 업체
에서 근무 하는 것이 좋다고 생각 합니다.
물론 들어가서 AA쪽으로 빠진다는 보장은 없습니다.
단 일반 SI 회사보다 기회가 많다는 뜻 입니다.

일반 SI 회사일경우는 정말 매니아적인
마인드가 필요 합니다.
프로젝트 특성상 SI는 업무 중심이기 때문에
기술적으로 깊이 있게 경험을 쌓기에는 제약
사항이 있습니다.
그렇기 때문에 더욱더 기술분야에 관심을
갖어야 할 것 같습니다.

초,중급일 경우 최신 트렌드 보다는
기술적 기본기에 투자를 많이 해야 합니다.
가끔 초,중급 개발자들 중에서 Spring의 한가지
기능을 사용했다고 해서 본인이 스킬이 뛰어난
사람이라고 착각 하는 경우를 종종 보게 됩니다.

초,중급분들한테 거의 아키텍처 관련된 구현을
맡기지 않습니다. 본인들이 교육을 받고 비지니스
로직을 구현할 정도의 센스만 실무에서 경험하고
나머지 시간은 집중적으로 core java,network,xml등
기본적인 기술을 연마 해야 합니다.
(프레임웍크는 업무에 편하지만 기술적인 부분은 점점
개발자를 바보로 만들고 있습니다.)

최소 7년간의 실무 경험이 필요 합니다.
AA는 절대로 물리적 시간과 경험이 필요 합니다.
7년까지는 구현에 대해서 많은 투자가 필요하고
그 이후는 설계에 더 무게 중심을 두어야 할 것 같습니다.
(요새 저도 설계쪽에 많은 시간을 투자 하고 있습니다.)

횡성수설 잘 알지도 못하면서 말씀 드렸네요
어쨌든 앞으로 시스템은 점점도 복잡하고
규모더 커쳐 가고 있습니다. 이럴때 AA의
역할은 절실히 대두되고 있습니다.
AA는 단기간에 만들어 지는 것이 아니며 양성하기도
쉽지 않습니다.
오직 열정과 매니아 정신만이 AA가 될수있다고
생각 합니다.

SI Project 패러다임!!

2010-04-19T07:52:00.001-07:00

우리나라의 IT 프로젝트는 몇몇 특화된 것을 제외한
대부분이 J2EE 기반 SI 프로젝트일 것입니다.
하지만 이런 SI 프로젝트가 힘든 이유가 무엇
일까요 그 풀리지 않은 미스터리에 대한
의문점과 나름 해결 방법을 몇자 적어보려고
합니다.

왜? 크리니컬 이슈는 항상 개발 막바지에 발생 하는가?

애자일의 가장 기본은 바로 test-first 입니다. 즉 개발 보다
테스트 환경구축 입니다.
공통모듈,프레임웍,비지니스 로직 개발 등 이러한 것보다
제일 먼저 아래와 같은 Activity가 선행이 되어야 할 것입니다.

- JUNIT과 같은 단위 테스트 탬플릿
- CI(Maven,Nexus,Hudson..등)를 위한 자동화 빌드
- Code Inspect (PMD..등)

※ 가끔 개발자 분들이 JUNIT을 상당히
귀찮은 존재로 생각을 하십니다.
개발할 것도 많은데 어느 세월에 Test
Junit을 만드냐고 합니다.
하지만 그건 전혀 잘못된 생각 입니다.
스프링이 Pojo인 이유는 바로 테스트를
편하게 하기 위해서 입니다.
그리고 저는 예를 들어서 게시판 CRUD 한 셋을
화면 포함해서 개발할때 비지니스로을
먼저 만들고 Junit으로실행 한다음
뷰단을 몰아서 작업 합니다.
그 중독성이란... 여러분 한번 제 방식이랑
여러분 방식이랑 CRUD 배틀 한번 해볼실까요^^
로직이 복잡할수록 그 공수 차이는 더 커집니다.

왜? 화려한 시스템 아키텍쳐 청사진과 멋진 패턴로 구성된 UML 문서는 있음에도 불구 하고 프레임웍은 항상 불안 할까?

대부분 개발표준,프레임웍 구성등은 AA(Application Architecture)가
설계및 구축을 담당하고 있습니다. 하지만 최근 개발 동향을 보면
금융권을 제외한 (책임문제 때문인지 상용툴만 사용)한 일반
프로젝트는 스프링 기반에 오픈 소스로 구성 되었습니다.
물론 AA가 당연히 기술적인 부분을 많이 알고 있어야하지만
많은 오픈소스에 대해서 물리적으로 혼자서 해결 한다는 것은
무리라고 생각 합니다. 즉 전문 Technical 팀이 구성이 되어야
한다고 봅니다. AA 팀에 같이 소속이 되었던 별도의 공통파트이건
간에 이러한 팀이 AA와 기술적인 긴밀한 협조를 통해서
기술적 리딩을 해야 한다고 생각 합니다.

일정은 있고 대화는 없는 건가?

PM과 PL의 제일 중요한 work는 당연 일정 관리 입니다.
하지만 일정관리 와 같은 중요도를 가지고 있는 것이
바로 프로젝트 팀원 관리 입니다.
하지만 이런 부분을 간과하는 경우가 많습니다.
가끔 저는 프로젝트가 이슈가 생겨서 중간에 투입
하는 경우가 있습니다. 그럴때 저는 일정이 연기되었거나
또는 기술적인 이슈가 생기는 것은 그다지 우려가 되지
않지만 PM,PL과 개발자 사이에 대화가 없으면
투입을 주저 합니다.
서로 대화가 없으면 솔직히 그프로젝트는 끝나다고 봅니다.
그 얘기는 개발자를 단지 도구나 툴로 밖에는 생각 하지
않는 다는 것입니다. 자 프로젝트 리스크를 제일 정확하고
잘알고 있는 사람이 누구일까요?
1.PM 2.PL 3.AA 4.개발자
정답은 전 개발자라고 생각 합니다. 개발자끼리 모여서
담배 피면 아마도 십중팔구
"이 프로젝트 큰일이다 답이 없다 답이" 이런 말들을
합니다.
개발자가 네거티브한거 인정 합니다. 하지만 틀린 얘기는
아닙니다. 일정만 강요하는 프로젝트에서는 절대로
왜 답이 없는지 말을 하지 않을 것입니다.

누가 고급이고 누가 중급인가?

가끔 개발을 하게 되면 누가 고급이고 중급인지 분간을
할 수가 없습니다. 개인적으로 한분야에서 7년차까지는
구분이 필요하다고 생각합니다. 하지만 그 이상이 넘어가면
경력은 무의미 하다고 봅니다. 예전 개발 환경은 잘하는 사람,
못하는 사람 별 차이가 없었습니다.
하지만 최근에는 업무적/기술적 규모나 복잡도가 예전에
비해서 비교도 할 수 없을 정도로 커졌습니다.
즉 개개인의 능력 차이가 엄청나게 커졌습니다.
프로젝트 전문가 얘기를 들어보면 잘 하는 사람과
못하는 사람의 본수가 10본이상 차이가 난다고 합니다.
앞으로 인력을 선별할때 단순 년차 비교가 아니라
이전 플젝 PM이나 아니면 인맥 정보를 동원해서
그만큼 스킬이 있다면 중급이더라도 고급 대우를
해야 한다고 생각 합니다.
즉 경력보다는 인재를 확보해야 합니다.

왜? 리스크가 있음에도 불구하고 그걸 바보처럼 한다고
한 담당자에게만 책임을 몰빵하는가?

한번은 DA (Data Architecture)와 업무적으로 다툼적이 있었습니다.
Date형을 전부 varchar2(14)로 수정했다는 얘기 입니다.
그 런 큰 이슈를 전체 공지나 이슈화 하지 않았냐고 하니
"저번에 말씀 드렸잖아요. 그리고 개발문서에도 있구여"
그말을 듣는 순간 이단 옆차기 하고 싶은 충동이....
프로젝트하는 곳이 가정법원인가? 그래 나랑 개발팀이
몰랐다 글면 자기 혼자 사는 것인가? 어떻게 대놓고
책임을 회피하는 발언을 하는지...
그리고 한번은 PL이 저한테
"저 김과장님 이거 하는데 잘안되네..."
"내 제가 잠깐 볼게요"
다음날...
"그거 언제 되요? 늦어도 이번주까지는 되야 하는데"
음..................

왜? 우리는 많은 경험을 하고도 또 경험을 해야 하는 것일까?

현실적으로 SI 프로젝트에 대해서 A~Z까지
다 알수는 없지만 각자 말못한 고충과
일들이 있을 것입니다.

무 조건 "갑",PM,PL,개발자 들을 비난할수는
없 습니다. 하지만 체질 개선은 반드시
필요하다고 생각 합니다.

사실 SI 프로젝트라는 것이 고객의 needs를 잘 분석해서
끈끈한 팀웍과 훌륭한 조직원들이서로 공유하고
리스크 최소화 하면서 결국 최고의 시스템을
고객에게 주는 것인데 무엇이 우리를 힘들게 하는 것인지
참...우리 모두 고민을 해야 할 것 같습니다. 마지막으로
"SI Project (전문가로 가는길)"이란 책에서 발췌한
"성공적인 프로젝트의 요건"에 대해서 말씀 드리고
마무리 하겠습니다.

1. 고객을 프로젝트에 최대한 깊이참여 하도록 한다.
2. 고객 경영진의 적극적인 후원을 얻어야 한다.
3. 인수인계를 위한 대비를 일찌감치 시작한다.
4. 80:20(인재) 률을 최대한 활용하라.
5. 고객의 속마음을 읽어라
6. 프로젝트팀을 잘 관리하라.

모드 성공적은 SI 프로젝트가 되길 바랍니다.

XP의 핵심 실천 사항

2010-04-19T07:20:00.000-07:00

최근에 "SI Project (전무가로 가는길)" 책을 읽으면서
XP(eXtreme Programming)의 핵심 실천 사항이
잘 정리가 되어 있어서 발췌해 봅니다.
참고로 SI 개발자 분들께서는 반드시
꼭 필독서라고 생각 합니다.

전체가 한 팀이다 (whole team)

XP 프로젝트를 위한 프로젝트팀은 고객과 개발자
그리고 프로젝트 관리자로 구성된다.
이들 구성원들은 기존 프로젝트 관리방법론에서 개발을
위해 여러 파트로 구분하던 것을 하나의 팀으로 운영 하면서
User Story를 중심으로 개발 계획 및 배포계획을 작성하고
이에 따라 반복적 개발 방식으로 개발을 추진한다.

계획 게임 (planning game)

고객과 함께 하는 게임이다. 고객이 User Story를 작성하면
개발자는 이를 분석하여 개발에 필요한 시간을
구하고 고객은 여러 User Story들에 대해 개발에
우선순위를 부여하고 개발을 위한 배포계획을 개발자와
함께 수립하여 개발을 진행 한다.

고객이 테스트 한다 (customer tests)

모든 User Story들은 개발이 완료되면 단위 테스트를 거치고 인수
테스트를 수행한다.
이때 인수 테스트를 위한 기준을 고객이 지정하고 인수 테스트에
고객이 참여함으로써 User Story의 구현이 완벽하게 되었는가를
검증 한다.

작은 배포 (small release)

모든 XP에서의 시스템 개발은 시스템 규모에 관계없이 일정한
크기의 User Story로부터 시작되면 이러한 작은 User
Story들이 모여 하나의 시스템을 구성한다.
따라서 User Story의 구현에 따른 작은 배포가 수없이
많은 횟수로 이루어지며 이 때마다 자동화된 테스트 환경에
의해 시스템의 통합 테스트가 이루어지게 된다. XP의
기본 사상으로서 테스트의 반복은 시스템 품질
향상을 위한 초석이다.

단순한 설계 (simple design)

프로그램을 하기 위한 설계의 일환으로 기립회의를 추진 한다.
개발자들이 둥글게 둘러서서 시스템의 설계를 검토하는
짧은 회의를 설계안에 대한 의견을 공유하며 여러
설계안 중에서 가장 단순한 설계안을 채택함으로써 시스템
의 복잡도를 낮추고 품질을 높이는 전략을 채택하고 있다.

짝 프로그래밍 (pair programming)

팀원들 간에 교대로 두 명의 프로그래머가 짝을 이루어 하나의
User Story를 설계하고 구현함으로써 팀 의사소통 활성화
및 시스템 전반에 대한 품질 향상과 팀원들의 기술력
확산에 긍정적인 결과를 유도할 수 있다.

테스트 중심 개발 (test-driven development)

테스트 케이스를 기반으로 자동화된 테스트 환경을 프로그램
이전에 구축하고 프로그램 과정에서 지속적인 테스트를
수행하여 프로그램의 품질을 높인다. 효율적인
테스트 환경의 구축을 위해 자동화된 테스트 도구의
활용은 필수적이다.

설계의 개선 (design improvement)

리팩토링으로 대표되는 XP의 지속적인 설계의 개선은 모든 객체에
대해 가능한 가장 효율적인 기능으로 재구성하는 것을 권장한다.
리팩토링의 지향점은 객체의 기능을 유지하면서 가능한 단순한
설계와 기능의 프로그램으로 재구성하는 것이다.

지속적인 통합 (continuos intergration)

수 많은 User Story로 세분화된 개발 단위 중심의 배포 계획에
의한 지속적인 시스템 통합 및 테스트는 시스템을
보다 안정적으로 개발할 수 있는 환경을 제공 한다.
계속되는 작은 배포와 이에 따른 지속적인 통합 절차 및
테스트의 수행으로 프로그램에서 오류는 제거되고
프로그램 설계의 개선으로 효율성 및 성능은 향상된다.

선택적 코드 소유권한 (collective code ownership)

여러 개발자들이 자유로이 다른 개발자의 소스코드에 대한
수정 권한을 갖도록 함으로써 다양한 관점에서의
프로그램 설계 개선이 이루어진다. 또한 이 과정에서
중복되는 프로그램의 기능이 제거되며
프로그램 간의 인터페이스 문제들이 최소화되고 개발자의
안목이 향상 된다.

코딩 표준 (coding standard)

XP에서의 프로그램은 프로젝트 전체 개발팀에 대한 코딩의
표준 준수를 기준으로 수행한다.
이 방침은 다른 개발 방법론에서도 주요한 개발 전략이다.
그러나 XP에서는 짝 프로그래밍,선택적 코드 소유권한,
설계의 개선 등의 전략을 통해 어떠한 다른 개발방법론보다
코딩 표준이 효율적으로 적용될 수 있는 환경을 제공한다. 이 코딩
표준은 전체 시스템을 마치 한명의 뛰어난 프로그래머가 개발
한 것과 같은 효과를 가져온다.

은유법 (metaphor)

프로젝트 팀 내에서 개발하고 있는 기능들에 대한 설명을 누구나 이해할
수 있는 은유적인 기법을 통해 표현하려고 노력 한다.
딱딱한 설명 대신 전체 시스템의 기능을 상징적으로
표현할 수 있는 쉬운 표현의 작성을 위해 노력하는 과정에서 시스템의
기능에 대한 보다 깊은 이해를 불러 오는 효과가 있다.

주당 40시간 (40 hour/week)

소프트웨어의 개발을 지속적인 행보로 오랜 시간 계속
수행할 수 있도록 한다.마치 마라톤을 하듯이 순간의
스퍼트로 전체적인 리듬과 페이스를 잃지 않도록
꾸준하면서도 지치지 않는 시스템 개발을 위해 주당
40시간의 개발 작업을 준수하도록 한다. 무리한 야근은
개발자들의 생선성을 저하하며 시스템의 품질을 떨어
뜨리고 장기간의 프로젝트 수행을 어렵게 만든다.

SSC-RPC 데모 동영상

2010-04-14T11:14:00.000-07:00

마이크가 허접한 관계로 이어폰을
이용해야 할 듯 합니다.
궁금한 사항은 메일(springorg@gmail.com) 또는
댓글을 남겨 주시기 바랍니다.
총 7Par로 구성 되었습니다.

[Part1]
[Part2]
[Part3]
[Part4]
[Part5]
[Part6]
[Part7]

SpringShowcase Epilogue

2010-04-14T10:00:00.000-07:00

2주동안 개발자로써 평소 하고 싶은 오픈소스를
마음껏 즐겼습니다.
하지만 막상 시작을 해보니 생각보다 힘들고 때론
지루함 마져 들었습니다.

하지만 개발자는 예술가란 말을 느낄수 있는 계기가
되었습니다. 단순 획일된 프로그램이 아닌
테마를 가지고 창작을 하면서 고뇌하고
때로는 외로움마져 느끼는...
그리고 완성 되었을때 희열과 다음 작품에 대한
구상을 하는 것이 개발이란 원래 이런 것이
아닌가 싶습니다.

그러고 보면 참 좋은 오픈 소스를 제공하는 개발자분들께
정말 고맙다는 생각이 들었습니다.
그리고 오픈 소스 참여라는 것이 꼭 개발만 하는 것이
아니라 메일이나 댓글을 통해서 관심을 갖는 그자체가
참여라는 것을 느꼈습니다.

개인적으로는 SpringDM서버 기반에 JPA를
이용한 Domain Driven Develop를 구상했는데
일단은 가장 많이 사용하고 있고 제일 관심이 많은
웹 MVC에 대해서 구현 했습니다.
시간이 된다면 SSC-SI (현재 실무형 샘플),
SSC-AnyFrame ,SSC-Lafj, SSC-egovFrame
SSC-GAUSE 이런것도 구현하고 싶은데..
척박한 한국 개발 현실에서 한다는 것이
쉽지만은 않을 것 같습니다.
일단 다음 프로젝트는 변태적(?)인 것이 아니라
최근에 웹 서비스의 대세 REST에 대해서
샘플작업을 하려고 합니다.
그리고 곧 새로운 일을 시작해서 지금처럼
집중적으로 개발을 하기가 싶지 않아서
언제쯤 만들지 장담을 못할듯 합니다.

혹시나 필요한 기능이나 요청이 있다면
저한테 메일로 주시면 최대한 반영하도록
하겠습니다.

마지막으로 어디서 돈을 받고 이짓(?)을 하는 것이
아닙니다. 저또한 일반 개발자 분들이랑
동일한 조건에서 틈틈히
블로깅하고 개발하고 있습니다.
지치지 않게 많은 참여와 응원 부탁 드립니다.
감사 합니다.

Spring3.0 기반 SSC-RPC RC1 릴리즈!! (개인 오픈소스:Like DWR)

2010-04-13T22:49:00.000-07:00

SSC-RPC RC1 버전을 릴리즈 했습니다.
제가 예전부터 구상한 컨셉이 있어서 이번에
개발을 했습니다.
SSC-RPC는 DWR 컨셉과 매우 흡사한
모델이라고 할 수 있습니다.
(제 개인적으로는 SPRING DWR이 아닐까
생각 합니다. ㅋㅋ)

Technologies

(1) JDK 1.6
(2) Tomcat 6.0
(3) Spring 3.0
(4) Tiles2
(5) jQuery
(6) JSR-303 Validation
(7) Json-Lib

DWR Issue

DWR은 원격에 있는 비지니스 컴포넌트(Service 클래스 같은)
를 "클래스명.메서드" 유사한 형태로 client에서
직접 호출해서 리턴값을 json 형태로 reponse 해주는
ajax 오픈 소스 입니다.
,즉 컨트롤러 없이 원격에서 직접 비지니스 컴포넌트를
다이렉트로 호출한다는 뜻입니다.
하지만 DWR이 실무에서 사용하기에는 몇가지 제약
사항이 있습니다. 그중에서 Validation,Exception 부분입니다.
내부적 DWR은 http status 정보를 전부 200 OK로
응답을 하기 때문에 클라언트에서 처리하기가
명확하지 않으며 Validation,Exception 메세지
처리가 거의 지원이 안된다고 볼 수 있습니다.
그리고 외국 블로그를 보면 spring security
연동할때 버그가 있다고 합니다.
(아무래도 범용적인 오픈 소스라서 그런듯...)

Just One Controller

ssc-rpc는 이런 부분에 대해서 DWR 컨셉과
유사하게 하되 위에 언급한 문제점을 해결 하도록
처리 했습니다.
단 원격 호출을 당하는 컴포넌트(Service 클래스와 같은)
클래스 생성 및 스프링빈 설정이 약간의 제약이
있지만 실무에서 사용하는데 큰 무리가 없도록
되어 있습니다. View를 위한 컨트롤러를 제외한
Ajax 호출 부분은 하나의 컨트롤러만 설정하면
되기 때문에 개발에 정말 많은 공수를 save 할 수 있습니다.

SSC-MVC 모든 기능 사용 가능

SSC-MVC의 모든 기능을 지원 하도록 구성 했습니다.

$(document).ready(function() {
$("#btnRequest").bind("click", function(e) {
$.ajax({
    type: "POST",
    url: APPLICATION_CONTEXT+"/rpc.json",
    dataType: "text",
    data:{
        "invoke":"dwrFacade.getUserList"
    },
    beforeSend:function(xhr) {
    },
    success:function(data, textStatus,xhr) {
        if(data == "{}") {
            alert('데이터가 존재 하지 않습니다.');
            return;
        }
        alert(data);
    },
    error:function(xhr, textStatus, errorThrown) {
        //invalid binding
        if(xhr.status == 400) {
            alert(xhr.responseText);
        }else{
            alert(xhr.responseText);
        }
    },
    complete:function(xhr, textStatus) {
    },
    timeout:1000
});//ajax of end
});
});

클라이언트에서는 별다른 Controller 설치 없이
위의 "invoke" 파라미터에 "스프링빈 아이디.메서드"라고
호출 하면 해당 메서드가 실행 되고 리터 값이
json 형태로 리턴 하게 되어 있습니다.

선택적 Validation

원격에서 호출되는 컴포넌트의 메서드를 "@Valid"을
선언 함으로써 선택적으로 validate를 수행 할 수 있
습니다.

@Valid
 public void createUser(User user) {
     dwrService.createUser(user);
 }

"@Valid" 어노테이션을 선언 하지 않으면 validate를
수행 하지 않습니다.

실행 방법

[SpringShowcase 실행하기] 을 참고 하고 아래의 svn 주소로
체크아웃 받으시면 됩니다.
https://springshowcase.googlecode.com/svn/trunk/ssc-rpc

SpringShowcase 개발 및 실행 환경 설정 (자바 개발환경 설정)

2010-04-10T08:43:00.002-07:00

SpringShowcase 오픈 소스 프로젝트 개발 환경 설정
방법에 대해서 동영상을 제작 했습니다.
(ㅋㅋ 허접함)
마이크기능이 허접해서 이어폰으로 들으셔야
할 것 같습니다.
동영상이 파일크기가 좀 되서 4개의 Part로
나누어서 만들었습니다.
꼭 오픈소스 개발 환경이 아니더라도
개발자분들 환경 셋팅 하는데 좀 도움이 되지 않을까
합니다.

Part1
http://video.nate.com/212458436

Part2
http://video.nate.com/212458528

Part3
http://video.nate.com/212458592

Part4
http://video.nate.com/212458639

Spring3.0 기반 SSC-MVC 릴리즈!! (개인 오픈소스:실무형 MVC)

2010-04-07T06:38:00.001-07:00

개인적으로 Spring3.0 기반 오픈소스 "SpringShowcase"
의 마이너 버전을 release 했습니다.
(최근에 개인적으로 백수인 관계로 놀기도 모하고 해서....ㅋㅋ)
이번 버전 컨셉은 Spring3.0 기반에 실무형 MVC
prototype 입니다.

Technologies

(1) JDK 1.6
(2) Tomcat 6.0
(3) Spring 3.0
(4) Tiles2
(5) jQuery
(6) JSR-303 Validation
(7) Json-Lib
(8) Apache Commons Configuration

New Feature

(1) Dynamic Tiles2 Layout
Html Layout을 무거운 sitemesh 대신 Tiles2를 적용
와일드 카드 설정으로 인해서 config 최소화

(2) compound configuration
System Properties,Application Properties,DB Code ..
등 실무에서 사용하는 config성 데이터를 한개의
compound형태의 spring bean으로 제공.

(3) trace log
개발기 디버깅을 위해서 각 구간별 (Controller,Facade,Service,Dao..)
수행 시간, binding data의 속성 정보,client 기본 정보
(요청 url,http method,parameter 정보)
등을 로그로 기록한다. 로그레벨 "Info"로 설정시
조회 가능.

(4) Form Type Validation with JSR-303
Form Type(전통적인 submit 방식)기반 Validation을
JSR-303 스펙으로 구현. Annotation 기반 컨트롤러에서
구현 (스타일은 이전 SimpleFormController 방식)

(5) Ajax Type Validation with JSR-303
Clinet에서 jQuery를 통해서 요청시 바인딩
Validation이 발생할 경우 json 형태로 invalid된
field 아이디: 에러메시지를 출력함.

(6) Global Locale
spring 3.0에 추가된"mvc:annotation-driven " 네임스페이스를
적용해서 구현

(7) Ajax View Support with Json-Lib
Spring3.0에서 제공 하는 "jackson" 라이브러리는 톰캣를
제외한 다른 서버에서 Verify Exception을 발생함.
보다 검증되고 다양한 형태의 "json-lib" 뷰로
구현함.

(8) 직관적인 Exception 메세지
exception이 발생 했을 경우 에러 메세지를 직관적으로
지원. 예를 들어서 메세지 번들에 Exception Short 명을
키로 하고 메세지를 입력하면 자동으로 파싱해서
출력함
exception_ko.properties
NullPointException=데이터값이 존재 하지 않습니다.
NotFoundUserException=회원이 존재 하지 않습니다.

(9) Exception Message Supported Ajax
Ajax 요청시 Exception 메세지를 json 형태로
에러메세지 뿐만 아니라 exception에 관련된
다양한 정보를 클라언트에게 전송 한다.

(10) Exception Log
exception이 발생하면 별도의 로그파일로 관리 합니다.
로그파일은 exception 발생 시 발생시간,trace ID,호출 URL
및 Http Parameter 정보, throw한 클래스들과 발생 line등을
제공 한다.
[로그파일 다운로드]

실행 방법

아래의 동영상을 참고 하시기 바랍니다.
[동영상 보기]

세미나

4월 24일에 ssc-mvc 관련해서 간략하게 세미나를
하려고 합니다.
관심 있으신분은 댓글이나 메일로 보내 주시기 바랍니다.
시간이 날때 기능별 User Guide를 만들려고 합니다.
아무래도 저도 돈받고 하는 사람이 아니라서
언제라고 장담은 못드리 겠네요 ^^

Spring 3.0 다국어 처리

2010-04-07T06:18:00.000-07:00

Spring3.0에서 다국어 처리 하는 방법에 대해서
말씀 드리겠습니다.
3.0이라고 해서 크게 변동된 것은 없습니다.
단지 새로 추가된 네임 스페이스 "

<mvc:annotation-driven />

"를 통한 설정이 조금 변경 되었습니다.
먼저 아래와 같이 Message Resource를 등록 합니다.

<bean id="messageSource"
     class="org.springframework.context.support.ResourceBundleMessageSource">
     <property name="basenames">
         <list>
             <value>messages.default
             </value>
             </list>
     </property>
 </bean>

아래와 같이 localeResolver를 설정 합니다.
실무에서는 다국어 처리를 세션으로 제일 많이
사용하기 때문에 SessionLocale를 설정 했습니다.

<bean id="localeResolver"
     class="org.springframework.web.servlet.i18n.SessionLocaleResolver" />

마지막으로 "mvc:annotation-driven" 네임스페이스에
interceptor를 적용 합니다.

<mvc:interceptors>
     <bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor">
         <property name="paramName" value="lang" />
     </bean>
 </mvc:interceptors>

아래와 같이 "lang"파라미터에 국가 코드를
넘기면 다국어가 변경 됩니다.
국문 : http://....../hello.htm?lang=ko
영문 : http://....../hello.htm?lang=en

Spring 3.0 Validation Part3

2010-04-04T19:27:00.000-07:00

Part1,Part2는 기본적인 스프링에서 JSR-303
Validation 사용 방법에 대해서 설명 드렸습니다.
이번 Part는 Custom Validation에 대해서
말씀 드리겠습니다.
먼저 User 도메인 클래스 보면 아래와
같습니다.

public class User {

@NotEmail
private String email;

.....
}

"@NotEmail"은 제가 직접 만든 검증
annotation 입니다.
이제 부터 작성 방법에 대해서 말씀 드리겠습니다.

NotEmail Annotation 작성 방법

custom validation을 만들려면 2개의 클래스가 필요 합니다.
첫번째는 검증 annotation 클래스 이며 나머지 하나는
annotation을 검증할 validator 클래스 입니다.
이 두클래스의 참조 관계는 서로 의존 하는 관계
입니다.

package org.springshowcase.mvc;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import javax.validation.Constraint;
import javax.validation.ConstraintPayload;

@Documented
//@Constraint(validatedBy = EmailValidator.class)
@Target( { ElementType.METHOD, ElementType.FIELD, ElementType.ANNOTATION_TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface NotEmail {
public abstract String message() default "Not Email Format!";
public abstract Class<?>[] groups() default {};
public abstract Class<? extends ConstraintPayload>[] payload() default {};
}

"@Contraint" 부분을 주석 처리 하고 compile을 합니다.
이유는 아직 "EmailValidator" 클래스가 존재 하지 않기
때문입니다.

EmailValidator 클래스 작성 방법

package org.springshowcase.mvc;

import java.util.regex.Pattern;

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;

public class EmailValidator implements ConstraintValidator<NotEmail, String> {

@Autowired
@Qualifier("emailPattern")
String pattern;

public void initialize(NotEmail constraintAnnotation) {
// nothing to initialize
}

public boolean isValid(String value, ConstraintValidatorContext context) {
Pattern EMAIL_PATTERN = Pattern.compile(this.pattern);
return EMAIL_PATTERN.matcher(value).matches();
}
}

반드시 "ContraintValidator" 인터페이스를 구현 해야 합니다
"@Autowired" 어노테이션을 보면 스프링 annotation 입니다.
이 얘기는 아래와 같이 스프링 빈을 선언 하면

<mvc:annotation-driven />

"ContraintValidator" 인터페이스를 구현한 모든 클래스는
스프링 ApplicationContext에서 이러한 클래스들을
스프링 빈으로 생성합니다.
이말은 Validator에 다른 스프링 빈을 injection을 할 수있다는
뜻 입니다.
예제를 통해서 email 정규식을 일부러 스프링 빈으로 설정하고
injection을 시켰습니다.
아래는 injection 당한 빈 입니다.

<bean id="emailPattern" class="java.lang.String">
<constructor-arg index="0" type="java.lang.String"
    value=".+@.+\\.[a-z]+" />
</bean>

NotEmail Annotation 재컴파일

이제 "EmailValidator"가 생성이 되었기 때문에
"NotEmail" 어노테이션 클래스의 주석을 해제하고
재컴파일 합니다.

package org.springshowcase.mvc;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import javax.validation.Constraint;
import javax.validation.ConstraintPayload;

@Documented
@Constraint(validatedBy = EmailValidator.class)
@Target( { ElementType.METHOD, ElementType.FIELD, ElementType.ANNOTATION_TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface NotEmail {
public abstract String message() default "Not Email Format!";
public abstract Class<?>[] groups() default {};
public abstract Class<? extends ConstraintPayload>[] payload() default {};
}

Message Bundle 작성 방법

이제 새로운 custom validator를 작성이 끝났습니다.
새로운 annotation을 적용할 도메인 클래스에
선언 하면 됩니다.
메세지 번들 작성 방법은 아래와 같이 하면 됩니다.
NotEmail.user.email=이메일 형식이 틀립니다.

Spring Validation VS JSR-303

JSR-303 스펙에 대해서 확정을 하기 위한 투표를
하려고 했을때 스프링 진영에서는 참석을 하지
않았다고 합니다. 그래서 jboss 진영에서 심기가
좋지 않았다는 얘기가 있습니다.
역시 둘은 앙숙인듯....
아무래도 스프링 입장에서 자기들 validation이
있는데 굳이 JSR-303 스펙을 넣는게 그다지
좋지는 않았을 것 같습니다.
anyway!
JSR-303은 제가 도메인 클래스를 얘를 들었지만
사실 도메인 클래스만 해당 되는 것은 아닙니다.
모든 클래스(Service,DAO,..)에서 적용이 가능
합니다.
직접 써보니 JSR-303은 장점이 상당히 많았습니다.
첫째 검증 로직의 중복이 없습니다.
대부분 스프링 validation은 매요청시 작성 한거에
반해서 JSR-303은 도메인에 설정 하기때문에
검증 로직이 좀더 명확하고 코딩수도 적다는 얘기
입니다. 그리고 메세지 작성 방법도 직관적이기
때문에 관리도 수월 합니다.
반면 단점이 한나 있습니다. 좀 유연하지 않는다는
문제 입니다.
무슨 얘기냐 예를 들어서 id,name,email 이런 3개의
속성이 있다고 하고 모두 NotNull 조건이라고
설정을 합니다.
insert일 경우야 당연히 NotNull이지만
name만 update를 할경우 id,name 두
속성만 있으면 되는데 validation 조건이
모두 NotNull 조건이기 때문에 굳이
필요 없는 email에 기존 값을 채워서
보내야 한다는 것입니다.
즉 케이스별 검증 체크를 선택적으로 할 수
없다는 것입니다.
이런 이유는 예측컨데 jboss 진영에 힘이
있었지 않나 생각 합니다.
hibernate인 경우는 전체 업데이트를
체크 하기 때문이죠..
그래서 제가 개인적으로 시간이 되면 선택적으로
validation을 수행하는 util 클래스를 만드려고 합니다.
(언제가 될지 모르지만..)
그리고 한가지 더 현재 JSR-303 라이브러리와 구현체
라이브러리가 release가 아닌 running 중이기 때문에
라이브러리의 버전 진행도 유심히 모니터링
할 필요가 있습니다.
개인적으로 JSR-303은 실무에서 사용해도
훌륭한 개발 도구가 될 것 같습니다.

소스 다운 로드

본 예제는 제가 진행하는 오픈 소스 "ssc-mvc"를 체크아웃
받으시면 됩니다.
자세한 내용은 오픈 소스 사이트를 참고 하시기 바랍니다.

Spring 3.0 Validation Part2

2010-04-04T18:14:00.000-07:00

"Spring 3.0 Validation Part1"에 이어서 설명 드리도록 하겠습니다.
먼저 이전에 작성한 User 도메인 클래스 입니다.

package org.springshowcase.mvc;

import javax.validation.constraints.Pattern;
import javax.validation.constraints.Size;
import org.hibernate.validation.constraints.NotEmpty;


public class User {

@NotEmpty()
@Size(min=1,max = 5)
@Pattern(regexp="[0-9a-zA-Z]")
private String id;

@NotEmpty()
private String name;

@NotEmail
private String email;

private Integer age;

...setter & getter method
}

Controller에서 Validation 사용 하는 방법

Controller 에서 사용 하는 방법은 의외로 간단 합니다.

@RequestMapping(method = RequestMethod.POST)
public ModelAndView processSubmit(@Valid @ModelAttribute("user") User user,
BindingResult result, SessionStatus status) {
ModelAndView mav = new ModelAndView();
if (result.hasErrors()) {
System.out.println(".....invalid");
}
return mav;
}

위의 소스를 보면 검증을 위해서 파라미터 부분에
"@Valid" 어노테이션을 설정하면 끝입니다.
즉 저말은 User 도메인에 검증 로직을 실행 하라
는 뜻입니다. 이미 검증이 끝났기 때문에
"result.hasErrors"를 통해서 validation
분기 로직을 적절하게 작성 하면 됩니다.

JSP 설정 방법

<form:input path="id" /> <br />
<font color="yellow"><form:errors path="id" /></font><br />
<label for="contact_email">Enter user name: </label> <br />
<form:input path="name" /><br />
<font color="yellow"><form:errors path="name" /></font><br />
<label for="contact_email">Enter email: </label> <br />
<form:input path="email" /><br />
<font color="yellow"><form:errors path="email" /></font><br />
<label for="contact_subject">Enter Age: </label> <br />
<form:input path="age" /> <br /><br />
<input type="button" value="Save Changes" onclick="doSave();" class="button" />
</form:form>

JSP 소스는 이전 버전과 동일 하게 위와 같이 코드를
작성 합니다.

Invalid시 Message 리소스 적용 하기

이 부분은 SpringSource 팀 블러그와 JSR-303 스펙을
보면서 알아낸 방법 입니다.매우 중요한 부분이니
잘 이해하시기 바랍니다.

먼저 아래와 같이 메세지 번들을 설정 합니다.

<bean id="messageSource"
  class="org.springframework.context.support.ResourceBundleMessageSource">
  <property name="basenames">
      <list>
          <value>messages.default</value>
      </list>
  </property>
</bean>

default_ko.properties
메세지 expression은 "검증 annotation명+도메인명+속성명"
으로 하며 key 작성 규칙은 java method 형식으로
합니다.
NotEmpty.user.id=아이디를 입력 하세요.
Size.user.id=아이디는 5자 이하 입니다.
Pattern.user.id=아이디는 반드시 영문 또는 숫자만 입력 가능 합니다.
NotEmpty.user.name=이름을 입력 하세요.
NotEmail.user.email=이메일 형식이 틀립니다.

public class User {

@NotEmpty()
@Size(min=1,max = 5)
@Pattern(regexp="[0-9a-zA-Z]")
private String id;

.....
}

예를 들어서 "@NotEmpty"의 경우 메세지 키는
NotEmpty(annotation 명) + "." + user(도메인 클래스명)
+"." + id(속성명) 그래서 전체 메세지 키는
"NotEmpty.user.id"가 되는 것입니다.

Part3에서는 Custom Validation 작성 방법에
대해서 말씀을 드리겠습니다.

Spring 3.0 Validation Part1

2010-04-02T07:57:00.000-07:00

Spring3.0 에서 Validation 기능을 보면 이전 버전
에서 사용했던 Validation 방법 뿐만 아니라
새로운 기능들이 추가가 되었습니다.
그중에서 단연 꽃은 JSR-303 스펙 입니다.
혹자는 이것을 Spring 3.0 Validation이라고 합니다.
JSR-303스펙은 쉽게 말해서 자바의 모든 클래스 자체에
검증 로직을 annotation으로 설정 해서 검증이
필요한 어느 곳이든 해당 검증을 수행 할 수 있도록
하는 J2EE Spec 입니다.
ㅋㅋ 저 답지 않게 유식한 척을 했군요
아래 코드를 보면서 간략 하게 설명 드리겠습니다.

public class PersonForm {

@NotNull
@Size(max=64)
private String name;

@Min(0)
private int age;

}

위에 코드를 보면 name 속성은 반드시 값이 존재 해야 하고,
length는 64자를 넘어서는 안된 다는 것입니다.
이렇게 클래스에 검증 로직을 넣고 검증이 필요한 곳
에서 실행을 하면 됩니다.

Library 설정

먼저 Spring 3.0 에서 JSR-303 스펙을 구현 하기 위해서는
아래의 라이브러리가 필요 합니다.
(1) jax-validation.jar (JSR-303 스펙 라이브러리)
(2) hibernate-validation.jar (JSR-303 구현체 라이브러리)
위 의 두개의 라이브러리를 다운 받아서 이클립스 classpath
를 설정 합니다.
만약 Maven을 사용 하시는 분들은 아래의 pom.xml을
추가 합니다.

<repositories>
<repository>
<id>jboss</id>
<url>http://repository.jboss.com/maven2</url>
<releases>
   <enabled>true</enabled>
</releases>
<snapshots>
   <enabled>false</enabled>
</snapshots>
</repository>
</repositories>

<dependencies>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>4.0.0.Beta2</version>
</dependency>
</dependencies>

스프링 3.0 full pom.xml 설정을 원하 시는 분들은
제 블러그 "Spring3.0 관련 라이브러리 (pom.xml)"
을 참조 하시면 됩니다.

검증 클래스 작성

package org.springshowcase.mvc;

import javax.validation.constraints.Pattern;
import javax.validation.constraints.Size;
import org.hibernate.validation.constraints.NotEmpty;


public class User {

@NotEmpty()
@Size(min=1,max = 5)
@Pattern(regexp="[0-9a-zA-Z]")
private String id;

@NotEmpty()
private String name;

@NotEmail
private String email;

private Integer age;

 ...setter & getter method
}

위의 소스를 보면 전형적인 일반 자바 빈즈
클래스 형태 입니다.
"id" 속성의 검증 로직은 아래와 같습니다.
- 반드시 값이 존재 해야함
- 반드시 길이는 1이상 5이하여야 함 (byte 기준 아님)
- 반드시 영문 또는 숫자 형태여야함
"email" 속성에서 "@NotEmail"은 제가 직접
만든 annotation입니다. 이부분은 뒤에서
설명 하도록 하겠습니다.

Spring 빈 설정

스프링에서 JSR-303 스펙을 적용 하기 위해서는
다소 복잡한 과정을 거쳐야 합니다.
"LocalValidatorFactoryBean" 빈을 설정 하고 또 이 빈을
"AnnotationMethodHandlerAdapter" 선언된 빈에
injection 해야 하고...
이런거 필요 없이 spring3.0 에서 아주 간단한
네임스페이스를 제공 합니다.

<mvc:annotation-driven />

위와 같이 선언 하면 스프링에서 JSR-303 적용은
끝입니다.

Comming Up Next...

- Controller에서 Validation 사용 하는 방법
- JSR-303 기반 Message 번들 적용 방법
- JSP 설정 방법
- 커스컴 Validation Annotation 작성 방법
- Spring Validation VS JSR 303

너무 졸려서 다음에 포스팅 하도록 하겠습니다.

Validation 정책에 대해서....

2010-04-01T01:59:00.000-07:00

오늘의 주제는 데이터 Validation에 대한 내용이며 개발적인
측명 보다는 QA팀이나 보안검수팀에서 한번 정도 고려
해야 할 정책적인 얘기를 하고자 합니다.
데이터 Validation은 클라이언 사이드의 자바 스크립트
검증과 서버사이드 검증이 있습니다.
쿨 하게 결론 부터 말하자면
"서버 검증만 하자는 것입니다."

View Validation을 꼭 사용 하는 경우

(1) 서버 Validation 구현을 기술적으로 자신이 없어서
View Validation만 하는걸로 현업과 협의 된경우

(2) 포털 사이트와 같이 많은 사용자가 있는 곳에서
이벤트 같은 페이지일 경우 (서버로드 최소화 하기 위해서)

(3) 일정에 쪼겨서 검수 항목에 서버 Validation은 제외한 경우

이렇게 3가지 경우 외에는 굳이 View Validation을 할 필요가
없다고생각 합니다.

한번은 제가 보안 검증팀에 View Validation을 빼고
서버 Validation만 하자고 했더니 절대 안된다고 했습니다.
그래서 제가 why? you hate me?
했더니 이해 할수 없는 두가지 답변을 친절하게
해주었습니다.
보안적인 문제와 서버로드 최소를 위한 목적이였습니다.

그래서 저는 위 의 2가지에 대한 반론을 제시 했습니다.
첫번째 보안적인 문제
ㅋㅋ 갑자기 웃음이 나오네요 언제부터 자바 스크립트가
보안 스크립트 였습니까.
HTML 다운 받아서 검증 스크립트 주석 처리하고
submit 하면 안날라 갑니까
도대체 모가 보안 인지 알 수가 없습니다.

두번째 서버 로드 최소화 문제
제가 질문 했던 시스템은 일반 사용자 상대로
외부 노출되는 시스템이 아닌 내부 시스템
이였습니다. 사용자가 정말 많아 봤자 천명이
되지를 않습니다. 그리고 서버에서 Validation은
무거운 작업(DB Connection,XML Parsing,TCP connet)
없이 데이터 검증만 하면 바로 리턴 됩니다.
즉 서버에 라이트한 작업을 요청 하는 것이지요
그리고 일반적으로 데이터를 submit 할 경우
아무 생각없이 글을 작성하지 않습니다.
다들 신중하게 작성을 하기 때문에 경험상
동시에 많은 request가 집중 되지 않습니다.
정말 아파트 분양 입력 화면이나 대박 이벤트
화면이 아니고서는 대부분 서버 사이드에서
처리 해도 됩니다.

Server Validation의 장점

프로젝트를 하다 보면 대부분이 서버 컴포넌트
개발 보다 뷰 개발에 더 시간이 올래 걸립니다.
특히나 View 검증 로직에 대한 공수는 은근히
걸립니다.
Server Validation을 하게 되면 View 검증 로직에
대한 공수를 줄일 수 있습니다.
또한 한번에 전체 입력에 대한 검증 실패 메세지
를 보여줄수가 있습니다.
"아이디를 입력 하세요" alert 뜨고 - 다시 입력 후 저장 합니다.
"아이디는 영문이여야 합니다." 또 alert 뜨고
아니 한번에 다 보여주면 얼마나 친절 합니까
외국 사이트는 많이들 이런 컨셉으로 Validation
을 진행 하고 있습니다.

둘다 만족하는 방법 (valang,apache validation)

Server Side에서 Validation 로직을 View에서도 적용 할수
있는 기술적인 것들이 있습니다. 대표적인 것이
apache에서 제공하는 validation과 valang 입니다.
전 개인적으로 이건 최악 입니다.
너무 시스템을 복잡하고 지저분하게 만듭니다.
어떨때는 안하는 것만 못하게 되어 버립니다.
굳이 저렇게 까지 복잡하게 공수를 투자해야
한다는건 개발자의기술적 욕심입니다.

Spring 기반 오픈 소스 프로젝트에 참여 하실분!!

2010-03-31T06:31:00.000-07:00

예전 부터 오픈 소스를 정말 해보고 싶었는데 현실적인
바쁜 일정 과 게으름 때문에 마음 속으로만 생각을 하고
있었습니다.
그러던 중 최근에 프로젝트가 끝나고 개인적인 시간이
조금 생기면서 아~~ 지금아니면 다시는 못할 것 같은
생각이 들어서 일단 고고씽 하기로 했습니다.

틈틈히 일주일동안 google code에서 프로젝트를 생성하고
개발에 관련된 웹 문서 작업(개발자 가이드,프로젝트 소개..)
과 SVN 설정 및 개발 템플릿 개발까지...
일단 기본적인 셋팅은 완료가 되었습니다.

막상 준비를 해보니 Open Source 를 하시는 분들이나 또는 좋은 정보를
블로그나 책을통해서 전달 하신 분들이 정말 대단하는 걸
느끼게 되었습니다. 뛰어난 개발 스킬 과 아키텍쳐도
대단 하지만 그것보다 더 대단한건 개발에 대한 애정
과 열정 같습니다.
(이분들에 비하면 아직 멀었음)

Consider

프로젝트를 시작 하기 앞서 과연 어떤 프로젝트를 해야 할지
정말 고민을 많이 했습니다.

작은 단위의 개발 규모
무엇보다 척박한 우리 나라 개발 현실 속에서 과연 심신이 지친
개발자 분들이 일 외에 또다른 개발에 참여 한다는 것은
제가 생각해도 가혹한 일이라고 생각이 듭니다.
그래서 되도록 참여하 시는분들이 작은 단위로
참여 해야 한다고 생각을 했습니다.

헙업없이 최대한 자유 스러운 개발
첫번째와 비슷한 맥락 입니다. 개발 참여 하는것도
쉽지 않은데 서로 간에 협업 하면서 하는 것보가 프로젝트의
컨셉은 지키되 되도록 참여하는 개개인이 간섭 없이
독고다이 할 수있는 컨셉으로 가야 한다고 생각 했습니다.

실무에서 바로 써먹을 수 있어야 한다는 것입니다.
정말 마음 같아서는 spring container나 hibernate
같은 훌륭한 오픈 소스를 만들어서 세계적으로
한국의 위상을 세우고 싶지만 현실과 너무
괴리감이 있습니다.

Concept (스프링 기반 Best Practice 프로젝트)

개발 리딩 과 프레임웍 구축 업무를 주로
하고 있는 저는 자세히 생각해 보니깐 반복된
일을 매 프로젝트마다 하고 있었습니다.
이미 이것저것 다 붙은 무거운 프로젝트에서
필요한 부분 빼서 또 재구축 하는 것이 였습니다.
그리고 구현해야 할 부분을 찾다 보면
대다수의 블러그들이 부분적으로 코드를
설명해서 결국에는 스프링 메뉴얼을 보고
구축 하게 되었습니다.
이러한 반복적인 시간 낭비를 줄이기 위해서
스프링 기반에 Best Practice를 위한 오픈 소스를
생각을 했습니다. 만약 DWR + Spring MVC 연동에
대한 Best Practice를 만들면 굳이 db 붙이고 Service,
DAO 필요없이 컨트롤러 테스트만 하면 끝 입니다.
물론 DB가 필요한 JPA Best Practice라면 틀리 겠지만
어쨌든 딱 필요한 Spring 기반 Best Practice를
모은 오픈 소스를 진행 하면 서로 반복을 줄이고
그 시간에 미구현된 Best Practice를 만드는 것이
훨씬 낫다고 생각 합니다.

Participation

컨셉 자체가 스프링을 스터드 하기 위한 성향이 강하고
저 또한 아직 허접한 개발자 입니다. 잘하고 못하고를
떠나서 열정과 관심 있는 분들은 누구나 참여 가능 합니다.
관심 있으신 분들은 오픈소스 웹사이트(http://code.google.com/p/springshowcase/)
를 참고 하시고 springorg@gmail.com으로 메일 부탁 드립니다.
4월 중순 경에 간단하게 오픈 소스 개발 관련해서 강남역에서
세미나를 할 예정입니다.

Spring3.0 + Tiles2 Intergration Part3

2010-03-28T22:00:00.000-07:00

Part2 까지는 tiles2가 구동하기 위한 스프링 환경 설정
이였다면 이번 Part는 tiles 설정 및 활용 방안에
대해서 말씀 드리겠습니다.

Tiles Definition

Paste your text here.<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE tiles-definitions PUBLIC
  "-//Apache Software Foundation//DTD Tiles Configuration 2.1//EN"
  "http://tiles.apache.org/dtds/tiles-config_2_1.dtd">

<tiles-definitions>

<!-- = Abstract root definition ============ -->
<!-- default -->
<definition name=".default"
   template="/WEB-INF/views/jsp/layout/defaultLayout.jsp">
   <put-attribute name="title" value="CHANGE-ME" />
   <put-attribute name="meta" value="/WEB-INF/views/jsp/layout/meta.jsp" />
   <put-attribute name="left" value="/WEB-INF/views/jsp/layout/left.jsp" />
   <put-attribute name="footer"
       value="/WEB-INF/views/jsp/layout/footer.jsp" />
</definition>

<!-- empty -->
<definition name=".empty" template="/WEB-INF/views/jsp/layout/emptyLayout.jsp">
   <put-attribute name="meta" value="/WEB-INF/views/jsp/layout/meta.jsp" />
</definition>


<!-- = implement definition ============ -->
<!-- default depth3 -->
<definition name="*/*/*" extends=".default">
   <put-attribute name="title" value="Tiles2 Test" />
   <put-attribute name="body" value="/WEB-INF/views/jsp/{1}/{2}/{3}.jsp" />
</definition>
<!-- default depth2 -->
<definition name="*/*" extends=".default">
   <put-attribute name="title" value="Tiles2 Test" />
   <put-attribute name="body" value="/WEB-INF/views/jsp/{1}/{2}.jsp" />
</definition>
   <!-- default depth1 -->
<definition name="*" extends=".default">
   <put-attribute name="title" value="Tiles2 Test" />
   <put-attribute name="body" value="/WEB-INF/views/jsp/{1}.jsp" />
</definition>

<!-- empty -->
<definition name="dummy/empty" extends=".empty">
   <put-attribute name="body"
       value="/WEB-INF/views/jsp/dummy/empty.jsp" />
</definition>


</tiles-definitions>

definition name이 ".default"는 전체 layout을
선언하는 부분 입니다.

definition name이 ".empty" 부분은 web application에서
보면 기본 Layout을 적용이 되지 않고 싶을때 (팝업,iframe 등)
에서 사용할때 필요한 말 그대로 빈 페이지를 위한 레이 아웃입니다.

위에 설명한 2개의 설정은 layout 템플릿 설정이고 이제부터는
실제로 요청시 body 부분을 설정 하도록 해보겠습니다.

원래는 tiles는 매번 요청 마다 definition name를 설정해야
하는 엄청난 노가다를 해야 했습니다. 물론 spring examples
같은 곳에서 만든 라이브러리를 사용하면 일정부분
해결이 되긴 하지만 tiles2 부터는 와이들 카드로
설정 할수가 있습니다.

definition name이 "*/*/*"인 경우 위에서 extends=".default"
를 통해서 속성을 상속 받습니다.
그리고 호출 URL이 3 depth일 경우 해당 definition이
적용 됩니다.
예를 들어서
http://localhost:8080/dummy/depth1/depth2.ssc
라고 호출하면 스프링은 자동으로 view name을
"dummy/depth1/depth2.ssc" 변환 해서
해당 ViewResolver를 찾습니다.
"UrlBasedViewResolver"에 해당하기 때문에 tiles2 뷰로
포워딩 됩니다.
Tiles2 View에 도착한 View는 해당 definition을 찾습니다.
위의 view name은 "*/*/*" 패턴에 해당 하기 때문에
이 definition을 사용합니다.
요청 URL을 순서별로 body로 선언된 jsp를 찾습니다.

{1}:dummy,{2}:depth1,{3}:depth2.ssc
결국 /WEB-INF/views/jsp/dummy/depth1/depth2.jsp
로 포워딩이 됩니다.

"*/*" 이것도 위와 동일한 메커니즘 입니다.
마지막으로 "dummy/empty"로 선언된 것은 빈 페이지
layout template를 타기 위해서 선언된 것으로
이렇게 명시적으로 선언하면 wild card로 선언된
것은 무시하고 명시된 body를 찾습니다.

샘플 다운로드 받기

해당 소스를 받기 위해서 아래와 같이
svn 주소로 full checkout 받으시면 됩니다.
소스 다운로드 : (https://springshowcase.googlecode.com/svn/trunk/ssc-webtemplate)
실행 하기 앞서서 참고로 JDK1.6 과 tomcat 6.0 에서 개발했습니다.
실행 방법은 "http://localhost:8080/" 치면 화면이 열리고
왼쪽 메뉴에 케이스별로 링크를 걸어 놓았습니다.
앞으로 spring best practice를 위한 오픈 소스를 개인적으로
하려고 합니다. 관심있는 분들은 springorg@gmail.com
로 주시면 감사 하겠습니다.
앞으로 되도록 샘플 소스를 이런식으로 배포 하고자 합니다.

Spring3.0 + Tiles2 Intergration Part2

2010-03-28T20:44:00.000-07:00

Part2에서는 Spring3.0 기반에서 Tiles2 연동에
대해서 말씀 드리겠습니다.

필요한 라이브러리

tiles2를 연동하기 위해서 필요한 라이브러리는 아래와 같습니다.

<dependency>
<groupId>org.apache.tiles</groupId>
<artifactId>tiles-api</artifactId>
<version>2.1.4</version>
</dependency>
<dependency>
<groupId>org.apache.tiles</groupId>
<artifactId>tiles-compat</artifactId>
<version>2.1.4</version>
</dependency>
<dependency>
<groupId>org.apache.tiles</groupId>
<artifactId>tiles-core</artifactId>
<version>2.1.4</version>
</dependency>

제 블러그 "Spring3.0 관련 라이브러리 (pom.xml)" pom.xml을
참고 하시면 됩니다.
※여기서 중요한 부분이 tiles2 버전 2.1.4로 하셔야 합니다.
새로 나온 2.2.1 버전은 아직 spring3.0과
호환성 문제가 있습니다.구글링을 통해서 알아보니
외국애들도 이 문제에 대해서 이슈화 하고 있습니다.

Controller 설정

@Controller
@RequestMapping("/dummy")
public class DummyController {

// ---------------------------------------------------------------------
// Class Variable Declaration
// ---------------------------------------------------------------------
/** The Constant logger. */
private static final Logger logger = LoggerFactory
.getLogger(DummyController.class);

// ---------------------------------------------------------------------
// Constructor Method Declaration
// ---------------------------------------------------------------------
/**
* Instantiates a new config controller.
*/
public DummyController(){}

// ---------------------------------------------------------------------
// DI Method (setter,getter) Declaration
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// this Method (public/private) Declaration
// ---------------------------------------------------------------------
/**
* Gets the config.
*
* @param model the model
* @param request the request
*
* @return the config
*/
@RequestMapping(value = "/index")
public ModelAndView getMain() {
logger.info("========= DummyController.getMain");
return new ModelAndView();
}

/**
* Gets the show case tiles.
*
* @param model the model
* @param request the request
*
* @return the show case tiles
*/
@RequestMapping(value = "/list")
public ModelAndView getList() {
logger.info("========= DummyController.getList");
return new ModelAndView();
}

/**
* Gets the empty.
*
* @param model the model
* @param request the request
*
* @return the empty
*/
@RequestMapping(value = "/form")
public ModelAndView getForm() {
logger.info("==TilesController.getForm");
return new ModelAndView();
}

/**
* Handler empty.
*
* @return the model and view
*/
@RequestMapping(value = "/empty")
public ModelAndView getEmpty() {
logger.info("==TilesController.getEmpty");
return new ModelAndView();
}

// ---------------------------------------------------------------------
// interface implement Method (public/private) Declaration
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// abstract implement Method (public/private) Declaration
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// abstract Method (public/private) Declaration
// ---------------------------------------------------------------------


}

각각의 메서드들은 아래와 같은 요청시 처리 됩니다.

※참고로 호출 URL 확장자명은 "ssc" 입니다.
getMain : http://localhost:8080/dummy/index.ssc
getList :http://localhost:8080/dummy/list.ssc
getForm :http://localhost:8080/dummy/form.ssc
getEmpty : http://localhost:8080/dummy/empty.ssc
컨트롤러는 기본적인 annotation 기반 컨트롤러 입니다.

spring 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:util="http://www.springframework.org/schema/util"
xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">

<!-- annotation config & scan -->
<context:annotation-config />
<context:component-scan base-package="org.ssc">
<context:include-filter type="annotation"
  expression="org.springframework.stereotype.Controller" />
</context:component-scan>

<!--
JSR-303 support will be detected on classpath and enabled
automatically
-->
<mvc:annotation-driven />

<!-- convert request data  -->
<bean
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
<property name="cacheSeconds" value="0" />
</bean>

<!-- tiles2 layout config -->
<bean id="tilesConfigurer"
class="org.springframework.web.servlet.view.tiles2.TilesConfigurer">
<property name="definitions">
  <list>
      <value>classpath:/tiles2/tiles2.cfg.xml</value>
  </list>
</property>
</bean>

<!-- view name tanslator -->
<bean id="viewNameTranslator"
class="org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator" />

<!-- view resolver -->
<bean
class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
<property name="mediaTypes">
  <map>
      <entry key="atom" value="application/atom+xml" />
      <entry key="ssc" value="text/html" />
      <entry key="json" value="application/json" />
  </map>
</property>
<property name="viewResolvers">
  <list>
      <bean class="org.springframework.web.servlet.view.BeanNameViewResolver" />
      <bean class="org.springframework.web.servlet.view.UrlBasedViewResolver">
          <property name="viewClass"
              value="org.springframework.web.servlet.view.tiles2.TilesView" />
      </bean>
      <bean
          class="org.springframework.web.servlet.view.InternalResourceViewResolver">
          <property name="prefix" value="/WEB-INF/views/jsp/" />
          <property name="suffix" value=".jsp" />
      </bean>
  </list>
</property>
<property name="defaultViews">
  <list>
      <bean
          class="org.springframework.web.servlet.view.json.MappingJacksonJsonView">
          <property name="prefixJson" value="true" />
      </bean>
  </list>
</property>
</bean>
</beans>

빈 아이디 "viewNameTranslator"는 요청 URL과 같은 형태로
View Name을 변환해 주는 빈입니다.
즉 "http://localhost:8080/dummy/index.ssc"로
호출하면 View Name은 "dummy/index"로 변환 됩니다.

빈 아이디 "tilesConfigurer"는 tiles2 초기화 하는
빈입니다. 파라미터로 초기화에 필요한 tiles2 설정
파일을 입력 합니다.

"ContentNegotiatingViewResolver" 빈이 제일
중요 합니다.
Spring3.0 부터 지원 합니다. 이 Resolver는 스스로
View를 resolving 할 수 있는 능력이 없습니다.
단 이름에서 알수 있듯이 여러 ViewResolver를
중에서 케이스별로 처리 할 수 있도록 resolving
logic을 해주는 resolver 입니다.
"mediaTypes"를 보면 "ssc"되는 부분이 있습니다.
전 뷰 형태의 호출 URL을 ".do" 또는 ".action"
이아닌 ".ssc"로 하고 있습니다.
저 말은 ".ssc"로 오는 요청은 "text/html"
타입을 처리 할 수 있는 "UrlBasedViewResolver"
또는 "InternalResourceViewResolver" 으로
포워딩 하라는 뜻 입니다.
".json" 형태로 오면 "MappingJacksonJsonView"
처리하게 되어 있습니다.
"viewResolvers" properties를 보면 "list" 형태로
되어 있습니다. 이것은 2.5.6의 "order" 태그와
같습니다. 컨트롤러에서 리턴된 view name을
위의 순서되로 찾아 갑니다.

tiles2 설정은 Part3에서 설명 드리겠습니다.

Spring3.0 + Tiles2 Intergration Part1

2010-03-28T18:50:00.001-07:00

WebApplication 프로젝트를 할때 View Layout 오픈 소스를
많이 사용 하고 있습니다.
그중에서 대표적인 것들은 단연 sitemesh 와 tiles일 것입니다.
초창기 스트럿츠+Tiles 궁합으로 많이 사용을 했었습니다.
하지만 기능적인 제한이 많이 발생을 했습니다.
이러한 문제점을 보완할 오픈소스가 sitemesh 였습니다.
현재 대부분 spring으로 프로젝트를 진행 하는 곳에서는
대부분 sitemesh를 사용하고 있을 것입니다.
(지극히 개인적인 생각^^)
하지만 이러한 sitemesh도 문제점이 있습니다.

SiteMesh's Problem

첫번째는 속도가 느립니다.

sitemesh의 기본 컨셉은 Filter 기반의 decorator 패턴 입니다.
이패턴은 layout을 꾸미는데 있어서 매우 강력하지만
반면 각 조각 페이지들이 매번 요청시 파싱 작업이
일어 납니다.이로 인해서 랜덩링 속도가 느립니다.

두번째는 뷰 디버깅이 어렵습니다.

filter 기반이다 보니 JSP 또는 컨트롤러에서 에러가
발생시 디버깅을 힘들게 합니다.
이건 경험해 보신분들은 이해 하실것입니다.

Comback Tiles2

이런 sitemesh 문제점을 보완하기 위해서 tiles가 버전업
되어서 다시 돌아 왔습니다. 이름 하여 tiles2....
tiles2는 기본적으로 composite 패턴을 사용함으로
body부분만 변경 하기 때문에 속도가 뛰어납니다.
그리고 기존 tiles는 body 페이지 마다 definition을
하나씩 선언을 하게 되어서 많은 부분을
xml에 설정을 해야 했습니다. 하지만 tiles2는
wildcard를지원 함으로써 많은 부분을
생략 할 수있도록 되어 있습니다.

실제 Spring3.0 + Tile2 연동에 대해서는 Part2 에서
설명 하겠습니다.

스프링에서 Ajax 사용 하기 (Use JsonLib) 정정

2010-03-28T18:33:00.000-07:00

한가지 설정 부분을 빠뜨렸네요
"ViewResolver 설정" 파트를 추가 했습니다.
스프링에서 Ajax 사용 하기 (Use JsonLib) 바로 가기

블로그 공사중

2010-03-25T03:24:00.000-07:00

아 소스 보는 플러그인이 깨졌네요...
으.. 빨리 고쳐야겠습니다.

Spring3.0 MVC에서 Ajax 구현하기

2010-03-22T23:10:00.001-07:00

스프링 2.5.6 버전에서는 Ajax를 사용 하려면
View 인터페이스를 구현해서 별도의 Ajax전용 View
만들어서 사용 해야 했습니다.
솔직히 Ajax에 지원에 대해서 많이 미흡했습니다.
이유인즉 기술력 문제는 아니고 스프링 진영에서
Ajax가 J2EE스펙이 아니기 때문이라고
SpringSource 웹 사이트에서 본적이 있습니다.
하지만 Spring 3.0이 나오면서 파워풀한 기능이
추가 되었습니다. 그중에서 Spring3.0 기반에서
Ajax 구현 방법에 대해서 말씀 드리겠습니다.

web.xml

<servlet>
<servlet-name>springDispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>
  classpath:/spring/application/spring.mvc.xml
</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springDispatcher</servlet-name>
<url-pattern>*.htm</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>springDispatcher</servlet-name>
<url-pattern>*.json</url-pattern>
</servlet-mapping>

"servlet-mapping" 맵핑 태그에 보면 두개를 설정 했습니다.
하나는 View 호출을 위한 "*.htm",다른 하나는 "*.json"
입니다. 예를 들어서 입력 화면을 호출할때는
확장명이 "htm"으로 호출 하고 값을 입력 하고
넘길때는 "json"으로 호출 합니다.

Controller

@Controller
public class HelloWorldController {
  @RequestMapping("/helloWorld")
  public ModelAndView helloWorld() {
    ModelAndView mav = new ModelAndView();
    System.out.println("===================");
    mav.setViewName("/helloWorld");
    return mav;
  }

@RequestMapping("/ajax")
  public Map get() {
    System.out.println("===get");
    Map map = new HashMap();
    map.put("key","value");
    return map;
  }
}

spring.mvc.xml


  <!-- annotation config -->
<context:annotation-config />
<context:component-scan package="org.beyondj2ee">
    <context:include-filter type="regex" expression=".*Controller" />
</context:component-scan>

    <!-- handler mapping -->
<bean id="handlerMapping"
    class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" />

    <!-- view resolver -->
<bean
    class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
    <property name="mediaTypes">
        <map>
            <entry key="atom" value="application/atom+xml" />
            <entry key="html" value="text/html" />
            <entry key="json" value="application/json" />
        </map>
    </property>
    <property name="viewResolvers">
        <list>
            <bean class="org.springframework.web.servlet.view.BeanNameViewResolver" />
            <bean
                class="org.springframework.web.servlet.view.InternalResourceViewResolver">
                <property name="prefix" value="/WEB-INF/views/jsp" />
                <property name="suffix" value=".jsp" />
            </bean>
        </list>
    </property>
    <property name="defaultViews">
        <list>
            <bean
                class="org.springframework.web.servlet.view.json.MappingJacksonJsonView">
                <property name="prefixJson" value="true" />
            </bean>
        </list>
    </property>
</bean>

스프링 MVC 설정을 합니다.
나머지 부분은 spring2.5.6에 나온 것들이라 생략 하겠습니다.
"view resolver" 파트르를 보면 뷰에 대해서 chain을
형성 합니다.
먼저 "htm"으로 오면 response의 content type을
"text/html" 응답 합니다. "json"은 "application/json"
content type으로 응답 합니다.
스프링 "DispatcherServlet"은 모든 MVC process를
관장 하는데 먼저 "defaultViews"를 찾아서
해당 viewName이 없을 경우 리턴 합니다.
만약 viewName이 있을경우 "viewResolvers"
property에 선언된 순서로 찾아 갑니다.
예를 들어서
"http://localhost:8080/org-beyondj2ee-web/helloWorld.htm"
을 하면 처리하는 메서드에서 viewName을 가지고 있기
때문에 "InternalResourceViewResolver"로 빠지게 되고
"http://localhost:8080/org-beyondj2ee-web/ajax.json"
으로 호출하면 리턴 메서드가 없기 때문에
"MappingJacksonJsonView"로 빠지게 되어 있습니다.
Controller의 설정과 무관하게 decoupling 되게
구성이 되어 있습니다.
아... 주석 플러그인이 자꾸 XML이 깨지네요
죄송 합니다. 안깨지는 플러그인좀 있으면
추천좀 해주세요 ㅠ.ㅠ

Spring3.0 관련 라이브러리 (pom.xml)

2010-03-22T22:55:00.000-07:00

최근에 스프링 3.0을 테스트 하기 위해서 pom.xml을
설정 해봤습니다.
tiles2 때문에 고생좀 했네요
순수하게 spring framework 3.0 은 스프링 레파지토리
(http://www.springsource.com/repository/app/)에서 가져왔고
참조하는 라이브러리는 전부 Maven 레파지토리
(http://mvnrepository.com/)
에서 가져 왔습니다.
이런 이유는 스프링 레파지토리와 Maven 레파지토리가
서로 artifactid만 틀리고 동일한 라이브러리를
가져와서 정책을 이렇게 정했습니다.


<project 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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.springshowcase</groupId>
    <artifactId>ssc-org</artifactId>
    <packaging>pom</packaging>
    <version>0.0.1-SNAPSHOT</version>
    <url>http://code.google.com/p/springshowcase/</url>
    <properties>
        <spring.version>3.0.0.RELEASE</spring.version>
    </properties>
    <repositories>
        <!-- spring bundle repository -->
        <repository>
            <id>com.springsource.repository.bundles.release</id>
            <name>SpringSource Enterprise Bundle Repository - SpringSource Bundle
                Releases</name>
            <url>http://repository.springsource.com/maven/bundles/release</url>
        </repository>
        <repository>
            <id>com.springsource.repository.bundles.external</id>
            <name>SpringSource Enterprise Bundle Repository - External Bundle
                Releases</name>
            <url>http://repository.springsource.com/maven/bundles/external</url>
        </repository>
        <!-- jboss Repository -->
        <repository>
            <id>JBoss</id>
            <name>JBoss Repsitory</name>
            <layout>default</layout>
            <url>http://repository.jboss.org/maven2</url>
        </repository>
        <repository>
            <id>springbyexample.org</id>
            <name>Spring by Example</name>
            <url>http://www.springbyexample.org/maven/repo</url>
        </repository>
    </repositories>
    <dependencies>


        <!-- == get SBR ======================= -->
        <!-- spring libarary -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>org.springframework.aop</artifactId>
            <version>3.0.0.RELEASE</version>
            <exclusions>
                <exclusion>
                    <groupId>org.aopalliance</groupId>
                    <artifactId>com.springsource.org.aopalliance</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>org.springframework.asm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>org.springframework.aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>org.springframework.beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>org.springframework.context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>org.springframework.context.support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>org.springframework.core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>org.springframework.expression</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>org.springframework.jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>org.springframework.jms</artifactId>
            <version>${spring.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.aopalliance</groupId>
                    <artifactId>com.springsource.org.aopalliance</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>org.springframework.orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>org.springframework.oxm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>org.springframework.transaction</artifactId>
            <version>${spring.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.aopalliance</groupId>
                    <artifactId>com.springsource.org.aopalliance</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>org.springframework.web</artifactId>
            <version>${spring.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.aopalliance</groupId>
                    <artifactId>com.springsource.org.aopalliance</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>org.springframework.web.servlet</artifactId>
            <version>${spring.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.aopalliance</groupId>
                    <artifactId>com.springsource.org.aopalliance</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>org.springframework.web.portlet</artifactId>
            <version>${spring.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>javax.servlet</groupId>
                    <artifactId>com.springsource.javax.servlet</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>org.springframework.instrument</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>org.springframework.instrument.tomcat</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- == get Maven Repository ======================= -->
        <!-- servlet libarary -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>com.springsource.javax.servlet</artifactId>
            <version>2.5.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>com.springsource.javax.servlet.jsp</artifactId>
            <version>2.1.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>com.springsource.javax.servlet.jsp.jstl</artifactId>
            <version>1.2.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.taglibs</groupId>
            <artifactId>com.springsource.org.apache.taglibs.standard</artifactId>
            <version>1.1.2</version>
        </dependency>

        <!-- log libarary -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>1.5.8</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.5.8</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.5.8</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.14</version>
            <scope>runtime</scope>
        </dependency>

        <!-- junit libarary -->
        <dependency>
            <groupId>org.junit</groupId>
            <artifactId>com.springsource.org.junit</artifactId>
            <version>4.7.0</version>
        </dependency>

        <!-- j2ee libarary -->
        <dependency>
            <groupId>javax.mail</groupId>
            <artifactId>com.springsource.javax.mail</artifactId>
            <version>1.4.1</version>
        </dependency>
        <dependency>
            <groupId>javax.portlet</groupId>
            <artifactId>portlet-api</artifactId>
            <version>2.0</version>
        </dependency>

        <!--        <dependency>-->
        <!--            <groupId>javax.validation</groupId>-->
        <!--            <artifactId>validation-api</artifactId>-->
        <!--            <version>1.0.0.GA</version>-->
        <!--        </dependency>-->

        <!-- apache commons library -->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.2.1</version>
        </dependency>
        <dependency>
            <groupId>commons-net</groupId>
            <artifactId>commons-net</artifactId>
            <version>2.1</version>
        </dependency>
        <dependency>
            <groupId>commons-chain</groupId>
            <artifactId>commons-chain</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>commons-configuration</groupId>
            <artifactId>commons-configuration</artifactId>
            <version>1.6</version>
        </dependency>
        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
            <version>3.2.1</version>
        </dependency>
        <dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>1.8.2</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>commons-pool</groupId>
            <artifactId>commons-pool</artifactId>
            <version>1.5.4</version>
        </dependency>
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>oro</groupId>
            <artifactId>oro</artifactId>
            <version>2.0.8</version>
        </dependency>
        <dependency>
            <groupId>commons-digester</groupId>
            <artifactId>commons-digester</artifactId>
            <version>2.0</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.1.1</version>
        </dependency>

        <!-- aspectj library-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjlib</artifactId>
            <version>1.6.2</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.6.8</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjtools</artifactId>
            <version>1.6.8</version>
        </dependency>

        <!-- json libarary -->
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-core-lgpl</artifactId>
            <version>1.5.0</version>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-lgpl</artifactId>
            <version>1.5.0</version>
        </dependency>
        <dependency>
            <groupId>net.sf.ezmorph</groupId>
            <artifactId>ezmorph</artifactId>
            <version>1.0.6</version>
        </dependency>
        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.2.3</version>
        </dependency>

        <!-- xml libarary -->
        <dependency>
            <groupId>org.codehaus.castor</groupId>
            <artifactId>com.springsource.org.exolab.castor.xml</artifactId>
            <version>1.2.0</version>
        </dependency>
        <dependency>
            <groupId>org.jdom</groupId>
            <artifactId>jdom</artifactId>
            <version>1.1</version>
        </dependency>

        <!-- tiles2 libarary -->
        <dependency>
            <groupId>org.apache.tiles</groupId>
            <artifactId>tiles-api</artifactId>
            <version>2.1.4</version>
        </dependency>
        <dependency>
            <groupId>org.apache.tiles</groupId>
            <artifactId>tiles-compat</artifactId>
            <version>2.1.4</version>
        </dependency>
        <dependency>
            <groupId>org.apache.tiles</groupId>
            <artifactId>tiles-core</artifactId>
            <version>2.1.4</version>
        </dependency>
        <dependency>
            <groupId>org.apache.tiles</groupId>
            <artifactId>tiles-jsp</artifactId>
            <version>2.1.4</version>
        </dependency>
        <dependency>
            <groupId>org.apache.tiles</groupId>
            <artifactId>tiles-portlet</artifactId>
            <version>2.1.4</version>
        </dependency>

        <!-- asm libarary -->
        <dependency>
            <groupId>asm</groupId>
            <artifactId>asm-commons</artifactId>
            <version>2.2.3</version>
        </dependency>
        <dependency>
            <groupId>asm</groupId>
            <artifactId>asm</artifactId>
            <version>2.2.3</version>
        </dependency>

        <!-- cglib libarary -->
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib-nodep</artifactId>
            <version>2.2</version>
        </dependency>

        <!-- antlr libarary -->
        <dependency>
            <groupId>antlr</groupId>
            <artifactId>antlr</artifactId>
            <version>2.7.7</version>
        </dependency>
        <dependency>
            <groupId>org.antlr</groupId>
            <artifactId>antlr</artifactId>
            <version>3.0.1</version>
        </dependency>

        <!-- ibatis -->
        <dependency>
            <groupId>org.apache.ibatis</groupId>
            <artifactId>ibatis-sqlmap</artifactId>
            <version>2.3.4.726</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>

        <!-- hibernate -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>4.0.0.Beta2</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>3.3.2.GA</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-annotations</artifactId>
            <version>3.4.0.GA</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-commons-annotations</artifactId>
            <version>3.3.0.ga</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>3.4.0.GA</version>
        </dependency>

        <!-- aop -->
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>

    </dependencies>
    <build>
        <finalName>org-beyondj2ee-web</finalName>
    </build>
</project>

PropertyPlaceholderConfigurer 활용 방법

2010-03-22T18:15:00.001-07:00

스프링에서 config로 되어 있는 properties를 사용할때
"PropertyPlaceholderConfigurer"를 사용 합니다.
이 클래스는 해당 경로에 있는 properties 파을을
읽어서 스프링 xml 안에서 Ant 변수처럼 사용 해서
value값을 injection 해주는 클래스 입니다.
하지만 가끔 이 클래스를 빈으로 설정 할때
"ContextLoaderListener"으로 선언된 ApplicationContext
에서는 사용이 가능하지만 "DispatcherServlet" 으로
선언된 ApplicationContext에서는 인식이 안되는
문제가 발생 합니다.
이러한 문제가 무엇이면 해결 방법에 대해서 말씀
드리겠습니다.

PropertyPlaceholderConfigurer 이해

먼저 "PropertyPlaceholderConfigurer" 클래스를 이해 하기 위해서
ApplicationContext에 대해서 간략 하게 설명 드리겠습니다.
WebApplication에서 ApplicationContext가 한 개이상
존재 할 수 있습니다.
첫 번째는 "ContextLoaderListener" 클래스를 통한 생성과
두번째는 "DispatcherServlet" 클래스를 통한 생성 입니다.
그리고 아래의 그림 처럼 "DispatcherServlet"로
생성된 ApplicationContext가 "ContextLoaderListener"으로
생성된 ApplicationContext를 참조 하고 있습니다.
즉 부모(listener)-자식(servlet) 관계 입니다.

"PropertyPlaceholderConfigurer" 클래스는 각 ApplicationContext
가 load시 위 의 클래스를 lookup 합니다. 만약 존재하면
명시된 경로의 properties 파일들을 읽어서 참조 하는 빈들의
value값에 injection 합니다.
다시 말해서 ApplicationContext마다 한개씩 존재 해야
합니다.WebApplication에서는 최소 2개 이상
필요 합니다.
위에서의 문제점은 "ContextLoaderListener" 로드된
ApplicationContext에만 설정을 하고 Servlet으로 로드된
Context에는 설정을 하지 않았기 때문에 인식이
되지 않은 것입니다.

해결 방법

web.xml



<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
 classpath:/spring/application/spring.cfg.xml
</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<servlet>
<servlet-name>springDispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<init-param>
 <param-name>contextConfigLocation</param-name>
 <param-value>
     classpath:/spring/application/spring.mvc.xml
 </param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>

spring.cfg.xml

<bean id="beyondj2ee.configPath" class="java.lang.String">
<constructor-arg index="0" type="java.lang.String"
 value="classpath*:/**/*.properties" />
</bean>
<!-- application context placeholder -->
<bean
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"
ref="beyondj2ee.configPath" />

spring.mvc.xml

<bean
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"
ref="beyondj2ee.configPath" />

<bean id="beyondj2ee.testBean" class="org.beyondj2ee.core.bean.TestBean">
<property name="url" value="${jdbc.datasource.url}" />
</bean>

test.properties
jdbc.datasource.url=xxxxxxx

"spring.cfg.xml"에서 String 빈을 설정 한 이유는 경로를 집중화
하기 위해서 사용 했습니다.
properties 파일이 추가 되거나 수정 할경우 한 곳에서만
관리 하기 위해서 입니다.

일정만 기억하는 더러운 세상

2010-03-18T22:30:00.001-07:00

프로젝트를 처음 시작할때 PM한테 일정을 물어 봅니다.

ME : "이번 프로젝트 일정이 어떻게 됩니까?"
PM : "분석/설계 2개월,개발 3개월"
ME : "일정에 대한 근거는 모죠?"
"전 이세상에서 그게 제일 궁금해서요"
PM : "대충 프로젝트 scope이 그정도돼"
ME : "대충? 글면 프로젝트 scope 과 일정의 척도는 뭐죠?"
PM : "그래서 경험이 중요한거야"
ME : "네에? "
"일정을 소화할 설계자/개발자와 협의 해야 하는것 아닌가요?"
PM : (슬슬 짜증내면서) 왜그래 프로젝트 처음하는 사람 처럼
ME : ............
"설계가 밀리면 일정도 밀리나요?"
PM : "안돼 무조건 끝내야해."

여러분들도 "프로젝트 일정 산정 법칙"
궁금하시지 않습니까?
만약 프로젝트가 일정내에 완료가 되면 둘중 하나 입니다.
정말 운이 좋았거나 아니면 개발자들이 고생해서 일정을
맞추어 준 것입니다. 오히려 고마워 해야죠.

일정을 사람에 맞추자

여기서 하나 게임을 해보겠습니다.
"회원정보를 가져오는 로직이 있는 소스가 있습니다. 1분안에 위의 로직이 필요한 30개 함수에 반드시 적용해야 합니다".
준비 시작~~~~~~~~~~
저 일정을 소화 하려면 100%로 Copy&Paste 할 것입니다.
"제임스 고슬링" 아저씨가 오던 "로드존스"형이 와도
아마도 CTRL+C,CTRL+V를 누르면서 소스에
화려하게 수를 놓고 계실 것입니다.
공통 함수 만들 생각조차 못할 것입니다.
다소 극단적인 표현을 이기는 하지만
일정을 사람에 맞추지 않고 사람이 일정을 맞추면
그 고객에게 전달될 제품의 퀄리티는 굳이 얘기 하지
않아도 아실듯 합니다.

몸에 맞지 않은 옷

최근에 스프링이 대세도 아닌 필수가 되어서 열공하시는
분들이 엄청 많아 졌습니다.
그런데 왜 우리는 Spring을 써야만 할까요?
경력에 도움이 되어서,아니면 쓰라고 하니깐..
가끔 EJB 시절 묻지마 개발을 떠올리면
Spring도 그전철을 밡을수도 있다는 생각을
하면 씁쓸해 집니다.
Spring을 사용하는 이유는 많겠지만
그중에서 제일 중요한 부분은
테스트주도 개발 입니다.
즉 제품의 퀄리티는 높이고
고객의 요구 사항에 빠르게 응대를 함으로서
유지 보수를 극대화 하는 것입니다.
이러한 철학과 사상은 애자일적인 생각이죠,
(로드존슨 형은 애자일 신봉자..)
하지만 실무에서는 이러한 순수성은
없어지고 오직 일정을 지켜기 위해서 라면
오히려 느슨한 연결과 오픈 소스들이 짐이 되는 것 같습니다.
그냥 날 JSP+도메인 대신 Map 으로 개발하는 것이
더 낫다고 생각합니다.
절대로 현재의 개발 인프라와 Only waterfall 방법론은
재앙으로 다가 올것입니다.

파일럿을 하자

제 개인적으로 비판만 있고 대안이 없는걸 싫어해서
말씀 드립니다.
우리나라 개발 환경 특성상 100% 애자일 도입은
사실상 힘듭니다. 하지만 부분적으로 적용할
필요는 있습니다. 특히 순환 방법 개발 입니다.
일단 프로젝트가 시작하면 scope을 줄여서
한 사이클을 2~ 3개월단위로 파일럿 플젝을 진행해야 한다고
생각 합니다. 그래야 어떤것이 부족하고 개발 공수에
대한 예측이 가능하니깐요.
불과 몇년전과 지금 환경은 너무나도 다릅니다.
업무도 복잡해지고 기술또한 오픈 소스의
홍수속에서 살고 있습니다.
그 만큼 변수가 몇년전에 비해서 너무 많다는 것입니다.
하지만 대부분 프로젝트가 완료일이 가까이 되어서야
한사이클이 됩니다. (그나마 한사이클 돌면 다행이죠..)
엄청난 요구 사항과 기술적인 설계의 결함등이 쓰나미처럼
밀려오죠. 옛날은 몸빵이라도 했지만 지금은
그냥 프로젝트가 정지가 되어버린 상태로 되죠.

품질로 승부하자

제발 프로젝트를 제안 할때 단가 또는 일정으로 후리지
않았으면 좋겠습니다.
고객들에게 다소 단가가 높거나 일정이 길수는 있어도
품질만은 확실하게 보장한다고 제안 해야 합니다.
이제는 품질로 승부해야 한다고 생각 합니다.
실제로 이런 부분을 몸소 체험한 몇몇 회사에서는
많이 개선하려고 노력하고 있습니다.

커뮤니케이션을 통해서 시간을 Save 하자

개인적으로 프리랜서 활동을 하고 있어서 가끔 프로젝트
중간에 투입이 될 경우가 있습니다.
그럴때 제가 제일 먼저 체크하는건 프로젝트 인력들과의
릴레이션 쉽입니다. 아무리 설계가 안되고 프레임웍이 꼬여도
프로젝트 팀원간의 유대관계가 좋으면 힘들거나 두렵지
않습니다. 제가 제일 두려운건 설계도 프레임웍도 아닌
프로젝트 인력간의 유대 관계입니다.
사실 유대 관계가 좋으면 상황이 나뻐지지도 않습니다.
개발자들 매우 감성적인 사람들 입니다.
지속적인 커뮤니케이션을 통해서 이해하고 유대감을 형성하면
야근,주말근무 알아서들 나와서 도와 줍니다.
왜냐면 일하는게 즐겁기 때문이죠.
지속적인 커뮤니케이션을 통해서 생산성을 높이고
최적의 방안을 논의 한다면 상당수 시간을 줄일수 있다고
생각 합니다.

Spring Annotation 설정시 유의 사항

2010-03-18T22:04:00.001-07:00

Spring을 Web Application에서 사용할때 ApplicationContext가
두개의 Context로 관리 됩니다.
각각의 ApplicationContext 설정 방법중
하나는 ServletListener를 구현한 "ContextLoaderListener"
와 나머지 하나는 Servlet을 구현한 "DispatcherServlet"
입니다.

 <listener>
 <listener-lass>org.springframework.web.context.ContextLoaderListener
       </listener-lass>
 </listener>
         .....   
<servlet>
  <servlet-name>webAppServlet</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <init-param>
   <param-name>contextConfigLocation</param-name>
   <param-value>
     classpath:/webapp-servlet.xml
   </param-value>
  </init-param>
  <load-on-startup>1</load-on-startup>
 </servlet>

이 두 ApplicationContext는
부모(ContextLoaderListener)-> 자식(DispatcherServlet)
관계로 되어 있습니다.
이런 구조를 가지고 있어서 주로 부모 ApplicationContext
에는 Service,DAO,DataSource,Transaction 클래스들을
설정하고 자식 ApplicationContext에는
Controller를 설정 합니다.

※단 부모에서는 자식을 참조 할수 없음

스프링을 설정할때 Annotation을 설정하려면 아래와
같이 설정을 해야 합니다.

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

하지만 위와 같은 선언은 반드시 같은 ApplicationContext
에 위치하는 것에만 적용이 됩니다.
즉 "DispatcherServlet"에 위와 같은
xml을 설정하게 되면 "@Autowired"를 통해서
빈을 검색할때 부모 ApplicationContext에 존재하는 빈들을
참조 할 수 없습니다.
즉 Service,DAO 빈들을 참조 할 수 없다는 얘기 입니다.
그래서 반드시 저 선언은 "ContextLoaderListener" 에
선언을 해야 합니다.
참고 하시기 바랍니다.

Spring Bean Seesion,Request Scope

2010-03-18T00:57:00.000-07:00

스프링에서 제공하는 bean은 아래와 같이 life cycle를
가지고 있습니다.
singleton,prototype,request,session,global session
오늘 이중에서 request와 session scope에 대해서 말씀
드리겠습니다.
먼 저 두 scope에 대해서 간단히 설명하면 이름에서
알 수 있듯이 bean의 생명 주기를 말합니다.
즉 request scope은 HTTP Request 요청시 생성이 되며,
Response할 때 빈이 소멸 됩니다.
Session도 Http 세션에서 생성시 생성되면 세션이
종료되면 소멸 됩니다.
그러면 이런한 bean scope은 언제 설정해야 할까요?
개발을 하다 보면 HttpServletRequest 객체를

Use Case Request Scope

Controller 에서 Service로 넘길 때가 있습니다.
(물론 Controller에서 도메인으로 auto binding을 하겠죠^^)
일 반적으로 2가지 방법을 사용 할 것입니다.
하나는 request객체를 Service로 직접 넘기는 방법과
request 객체를 도메인 객체에 setter 함수를 통해서
Service로 넘길 것입니다.




@RequestMapping("/member.beyondje22")
public String list(HttpServletRequest request) {
// case1....
this.memberService.list(request);
// case2....
HttpDomain httpDomain = new HttpDomain();
httpDomain.setId(request.getParameter("id"));
this.memberService.list(httpDomain);
return "/member/list.jsp";
}

먼 저 첫번째 방법은 개인적으로 비추입니다.
이유인즉 Service 객체는 pure하게 설계가
되어야 하기 때문이죠 .
두 번째 방법은 좀 고급 스럽지가 못하죠
그래서 좀더 고급 스럽게 유연하게 request
scope을 통해서 구현해 보겠습니다.

==MemberController 클래스

   private HttpDomain httpDomain;

public void setHttpDomain(BaseDao httpDomain) {
this.httpDomain = httpDomain;
}

@RequestMapping("/member.beyondje22")
public String list(HttpServletRequest request) {
this.httpDomain.setId(request.getParameter("id"));
this.memberService.list();
return "/member/list.jsp";
}

== MemberService 클래스

   private HttpDomain httpDomain;

public void setHttpDomain(BaseDao httpDomain) {
this.httpDomain = httpDomain;
}

public void list() {
System.out.println("====" + this.httpDomain.getId());
}

빈 설정을 아래와 같이 합니다.

<bean id="httpDomain" class="org.beyondj2ee.HttpDomain" scope="session">
<aop:scoped-proxy/>
</bean>


<bean id="memberController" class="org.beyondj2ee.MemberController">
<property name="httpDomain" ref="httpDomain">
</property>
........
</bean>

<bean id="memberService" class="org.beyondj2ee.MemberServiceImpl">
<property name="httpDomain" ref="httpDomain">
</property>
</bean>

소스를 보시면 서로 간에 coupling 없이 injection을
통해서 Controller,Service,DAO 클래스에서
참조가 가능 합니다.Session Scope Bean도
단지 생명 주기가 차이날뿐 똑같이 사용할 수 있습니다.

설정 방법

request와 session scope을 사용 하려면 웹 어플리케이션에서만
사용해야 합니다. standalone 형태의 스프링 어플리케이션에서는
지원을 하지 않습니다.
스프링 IoC 컨테이너에게 나는 웹 어플리케이션 이라고
선언을 web.xml에서 선언 해야 합니다.
기본적으로 Spring MVC를 사용한다면 별다른 설정이
필요 없습니다. 이유인즉 "DispatcherServlet" 에서
자동으로 설정하기 때문입니다. 만약 다른 MVC
(struts,struts2,webwork)를 사용하고
Servlet2.4 버전일 경우
아래와 같이설정 합니다.



<web-app>
...
<listener>
<listener-class>
org.springframework.web.context.request.RequestContextListener
</listener-class>
</listener>
...
</web-app>

2.3 버전일 경우

<web-app>
..
<filter>
<filter-name>requestContextFilter</filter-name>
<filter-class>org.springframework.web.filter.RequestContextFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>requestContextFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
...
</web-app>

빈 설정 하기

반드시 "aop:scoped-proxy" 태그를 설정해야 합니다.
이유인즉은 이 빈들을 참조하는 빈들이 생성될때
같이 생성이 됩니다. 그럴경우 Http 객체를
참조 할 수 없습니다. 그래서 이러한 빈들은
http 이벤트가 발생시 proxy 객체를 통해서
생성이 됩니다.
그리고 위와같이 선언하면 반드시
"CGLIB" 라이브러리가 클래스 패스로 잡혀 있어야 합니다.
만약 JDK에서 지원되는 proxy를 사용 하려면

<aop:scoped-proxy class="false"/>

선언 합니다.
개인적인 의견은 request scope은 잘 사용되지 않을 것
같지만 session scope은 매우 유용할 듯 합니다.

Spring Bean Alias 사용예

2010-03-17T05:05:00.000-07:00

Spring 에서 bean을 xml로 설정 할때 "id" 또는 "name"
attribute에 값을 설정 합니다.
이 설정된 값은 IoC 컨테이너에 유일한
bean 식별자 됩니다.
하지만 가끔 bean 한개에 식별자를 한 개이상
설 정을 할때가 있습니다.
그때 사용하는 attribute가 바로 "alias"입니다.
즉 나는 하나지만 이름은 여러개란 뜻입니다.
그러면 이런 alias는 어떤 case일때 사용해야
하는지 말씀 드리겠습니다.

만약 A라는 시스템이 있습니다.
여기서 데이터 소스 빈 설정은 아래와 같이
되어 있습니다.

<bean id="dataSourceA" class="org.beyondj2ee.DataSource"/>

A시스템에 있는 DAO 클래스는 ref="dataSourceA"
로 설정이 되어 있습니다.

이제 B라는 시스템이 있습니다.

<bean id="dataSourceB" class="org.beyondj2ee.DataSource"/>

역시 마찬가지로
B시스템에 있는 DAO 클래스는 ref="dataSourceB"
로 설정이 되어 있습니다.

어느날 Intergration이라는 A,B를 통합 하는
시스템을 구축하려고 합니다.
A시스템과 B 시스템은 각각 별도의 DB를
가지고 있습니다. 그래서 양쪽 DB를
하나의 통합 DB로 마이그레이션을 했습니다.
이 통합 DB를 보는 bean 설정은 아래와 같습니다.

<bean id="dataSourceTotal" class="org.beyondj2ee.DataSource"/>

그런데 Application을 통합하는 과정에서
문제가 발생 했습니다.
각 시스템에서 데이터 소스의 bean id가
제 각각 틀리게 구성되었습니다.
그래서 각각 DAO로 선언된 bean들이
참조하는 "ref" 속성을 전부 수정해야 합니다
이때 "alias"태그를 사용합니다.
아래와 같이 설정을 해서 통합 합니다.

<alias name="dataSourceTotal" alias="dataSourceA"/>
<alias name="dataSourceTotal" alias="dataSourceB"/>

이런면 각 시스템에 DataSource를 참조하는 bean들을
수정 없이 해결 할 수있습니다.
bean 설계시 고려 하시기를 바랍니다.

한국형 J2EE 스펙 (egovFrame 기반)

2010-03-15T21:14:00.000-07:00

최근에 정부에서 스프링 기반에 "egovFrame" 이라는
전자 정부 프레임웍을 만들었습니다.
개인적으로 프레임웍을 만들었다는 의의 보단
정부 차원에서 오픈 소스 사용에 대해서 인정을 했다는 점과
그러한 오픈 소스들을 마치 한국형 J2EE 스펙화 했다는
점이 제일 맘에 듭니다.
그래서 제가 "egovFrame"을 기준 + 개인적으로 추천하는 오픈소스
를 추가해서 한국형 J2EE 스펙(? ㅋㅋ) 을 그려 봤습니다.

이클립스에서 Derby 사용 하기

2010-03-08T23:13:00.001-08:00

DBMS 관련되 오픈 소스들이 많이 나와 있습니다.
HSQL,SQLLight,Apache Derby 등이 있습니다.
이들 DB의 사용하는 이유는 오픈 소스라는 점과
생각 보다 높은 퍼포먼스와 트랜잭션을
안전성 있게 보장한다는 점이 매력이 있습니다.
개인적으로는 Hibernate와 같은 JPA 테스트를
위해서 사용 하고 있습니다.
그래서 Apache Derby에 대한 내용 보다는
(please.. googling!)
테스트를 위해서 이클립스에서 쉽게
설치하고 구동 및 사용법에 대해서 말씀
드리려고 합니다.
본 내용은 Derby 사이트에서 제공한 내용을
재구성 했습니다.
(http://db.apache.org/derby/integrate/plugin_help/start_toc.html)

설치하기 (Derby & Eclipse)

Apache Derby 다운로드 사이트에 접속 합니다.
(http://db.apache.org/derby/derby_downloads.html#How+to+build+Derby)
Derby 최신 버전의 다운로드 링크를 선택 합니다.
(글을 쓰고 있는 시점에서 "10.5.3.0"이 최근 버전이네요)

이동한 페이지 하단 부분에 보면 아래와 같이 zip 파일을
볼수 있습니다.
두개 파일을 다운 로드 받습니다.
(derby_core_plugin_10.5.3.zip,derby_ui_doc_plugin_1.1.2.zip)

각 파일들을 압축 해제 하면 각각 "plugin" 디렉토리가 존재 합니다.
이 디렉토리를 이클립스 "plugin" 디렉토리로 덮어씌기를 합니다.
예상을 한분들도 있겠지만 이클립스 플러그인 추가하는 것입니다.
적용이 끝나면 이클립스를 리붓 합니다.

서버 기동하기

새롭게 적용된 이클립스가 실행 되면
개발 하고자 하는 신규 프로젝트를 생성 합니다.
(Maven 프로젝트를 하던 WTP로 생성하던 일반 자바 프로젝트던
상관없습니다.)
생선된 프로젝트를 선택 후 "Right Click" 하면 서브 메뉴바에
"Apache Derby" - "Add Apache Derby nature"를 선택 합니다.

적용 하고 나면 "Apache Derby" 메뉴에 추가로 서브 메뉴들이
추가 된것을 볼 수 있습니다.
"Start Derby Network Server"를 실행 합니다.

기동 하게 되면 아래와 같은 메세지 창이 출력 됩니다. Derby는 기본 Port
는 1527번을 사용 합니다.

"OK" 버튼을 선택하면 서버가 기동 됩니다.
즉 오라클일 경우 DB 인스턴스가 Startup에서 리스너가
대기중인 상태라고 볼 수 있습니다.

SQL 실행 하기

이제 Apache Derby를 사용하는 환경 설정을 끝났습니다.
그러면 과연 어떻게 접속하고 SQL를 질의하는 방법에
대해서 말씀 드리겠습니다.
오라클에서 SQL를 실행 하려면 "SqlPlus"를 사용해서
질의를 할 수 있습니다.(물론 다른툴 쓰시겠죠^^)
이러한 콘솔을 제공하는 것이 "IJ"란 유틸리티 입니다.
서브 메뉴를 오픈 합니다.
"Apache Derby" - "Run SQL Script using 'ij'"를 실행 합니다.

실행 하면 "IJ>" 커서 명령을 기다리고 있습니다.
아래와 같이 SQL 스크립트를 질의 합니다.


connect 'jdbc:derby://localhost:1527/myDB;create=true;user=me;password=mine';
insert into restaurants values (4, 'Grande Burrito', 'Oakland');
update restaurants set city = 'Ukiah' where name = 'Irifunes';
select * from restaurants;
disconnect;
exit;

질의 후 결과 화면이 아래와 같이 출력 됩니다.

김연아 선수와 팀에서 배워야 할 점

2010-03-02T03:05:00.000-08:00

요새 김연아 선수때문에 한국이 난리가 났죠 ..
다시 한번 개인적으로 축하를 전하고 싶습니다.
어떻게 이런한 성과를 얻었는지 조직이든 개인이든
벤치 마킹할 필요가 있습니다.
아래는 그와 관련된 블러그 입니다.
꼭 한번 읽어 보세요
김연아 선수와 브라이언 오서 코치의 "행복" 리더십