잊지 않겠습니다.

* 사내 강의용으로 사용한 자료를 Blog에 공유합니다. Spring을 이용한 Web 개발에 대한 전반적인 내용에 대해서 다루고 있습니다.


지금까지 Jdbc, Hibernate, MyBatis와 같이 DB에 접근하는 다양한 방법에 대해서 알아봤습니다. 

각각의 DB를 다루는 기술들은 다양한 장점과 단점을 가지고 있습니다. 특히 myBatis는 기존의 sql의 재사용 또는 sql query만으로 Business Logic을 만들던 개발자들이 쉽게 접근할 수 있다는 장점이 있는것 같습니다. 그리고 Mapper를 이용하는 경우, Dao에 대한 구현 객체 생성을 거의 하지 않아도 된다는 장점을 가지고 있고요. 또 다른 장점은 무엇이 있을까요? 이 부분에 대해서는 코드를 보면서 서로간에 토론을 해보는것도 좋을 것 같습니다.

지금까지 우리는 MVC 모델의 M에 대한 기술적인 접근을 알아봤습니다. DB에 sql적 접근을 하는 Jdbc는 좀 다른 영역이라고 할 수 있고, myBatis와 Hibernate는 결국은 Jdbc를 한번 wrapping 한 형태라고도 할 수 있습니다. 제가 한번 질문을 던져보도록 하겠습니다. myBatis는 ORM일까요?

myBatis는 ORM이 아닙니다. ORM은 DB가 갖는 relation 관계에 대한 객체화에 주목합니다. 그렇지만, myBatis는 DB에 대한 query값에 대한 표현에 주목하고 있는 형태의 query에 대한 관리 포인트에 중점을 두고 있습니다. 이 둘의 차이는 조금 있습니다. 이 부분에 대해서 다시한번 알아보도록 하겠습니다.
Hibernate에서 사용된 ORM 객체들은 Entity object라고 불리웁니다. 그렇지만, myBatis의 객체는 VO, DTO라고 불리웁니다.
이에 대한 정의는 다음과 같습니다.

Entity Object
프로세스 상에 존재하는 데이터 개체로 물리적이거나 추상적인 것을 모두 포함합니다. 실제 DB의 코드에서 동작이 가능한 객체입니다. 지금 저희가 만든 예제에서는 Book, User, UserHistory 등이 각 객체로서 동작할 수 있습니다. 객체는 method를 가질 수 있으며, 생명 주기 및 객체간의 관계를 갖습니다.

VO(Value Object), DTO(Data Transfer Object)
단순히 값을 저장하는 객체입니다. Layer에서 Layer로 값을 전달할 때 주로 사용이 되며, 값에 대한 재 사용이 이루어지지 못합니다. 실제 Object에 대한 Model을 표현하기보다는 데이터를 저장하고, 전달하는데에 초점이 맞춰져 있습니다. VO, DTO를 사용하기 보다는 Map을 이용한 Dictionary 구조의 객체를 사용해도 동일한 결과를 가지고 올 수 있습니다. Entity Object를 화면에 보이기 위해서 또는 DB의 특정 query 결과를 다른 Layer에서 사용하기 위해 주로 사용됩니다.
차이를 아시겠나요? 단순히 Hibernate에서는 DB에 대한 값의 전달 뿐 아니라, 객체의 주기와 객체와 객체간의 관계까지 가지고 있는 Instance되어 있는 객체로서 움직입니다. 그렇지만, VO에서는 단순한 query값에 대한 return값을 의미하게 됩니다. 이 부분의 차이는 매우 큽니다. VO로 주로 작업을 하게 되면 결국은 절차 지향적 프로그래밍으로 동작하게 됩니다. Flow가 흐르듯이 method1 call, method2 call 식으로요. 그렇지만, 객체를 이용하게 되는 경우, 객체간의 상호 동작에 의하여 프로그램이 개발이 되게 됩니다. 이 두 객체의 사용 문제는 국내에서만 뜨거운 감자입니다. 외국은 이미 Entity가 평정을 한 상태이지만, 국내는 무척 말이 많군요. 전에 Daum에서 조사한 결과로는 해외는 8:2, 국내는 2:8 수준이라고 했습니다. 이 부분에 대한 논쟁을 따로 정리해봤습니다. 코드를 한줄 더 짜는 것보다, 이 부분에 대한 내용을 한번 정리해보는 것은 개발자들에게 있어서 굉장히 중요한 시간입니다. 다들 읽어보시고, 같이 이야기해보는 시간을 갖도록 하겠습니다.


Entity vs DTO, VO - 국내의 myBatis와 Hibernate 사용 논쟁에 대해서.


myBatis, Hibernate에 대한 사용빈도를  명확하게 측정할 수는 없지만, 검색 빈도로 간접적으로 사용빈도의 %를 알아볼 수 있습니다. 







그리고, 개발 기술에 대한 Trend를 한눈에 보기에 편한 indeed 사이트의 job trend입니다.  (참고삼아 PowerBuilder도 한번 넣어봤습니다.)
먼저, java와 C#에 대해서 알아보기 위해서 한번 indeed.com에서의 결과를 확인해보도록 하겠습니다.


전세계적으로도 역시 java가 C#보다 2배 이상의 우위를 갖는 것을 알 수 있습니다. 여기서 파란 라인이 Hibernate입니다. 밑에 0점에 깔려 있는 애들은 myBatis, iBatis, JPA를 의미하고요.

자, 이제 Hibernate와 myBatis, iBatis, JPA, powerbuilder를 비교해보도록 하겠습니다. 


일단 JPA가 너무 낮은 것에 대해서는 전문가들의 의견은 JPA가 Hibernate를 기반으로 구성이 되는 것이 일반적이기 때문에 JPA 대신에 Hibernate를 적는 경우가 많기 때문이라는 말을 하고 있습니다. 이제 Hibernate, iBatis, myBatis를 한번 비교해보도록 하지요. 이 정도면 해외에서는 iBatis와 myBatis는 거의 죽은 기술입니다. 그런데 왜 국내는? 이라는 것은 상당한 논쟁을 가지고 옵니다. 이 부분에 대한 java community에서의 논쟁입니다. 

IBatis와 Hibernate 기술적 트렌드에 대한 작은 생각입니다.
제가 알고 있기에는 세계적으로는 HIbernate가 대세이고
한국은 IBatis가 대세 정도로 알고 있습니다.
물론 제 개인적인 생각일수도 있을것 같습니다.
제 생각에는 Hibernate 프레임웍의 특성을 보면 비교적 잘 설계되고 복잡도가 상대적으로 높은편인것 같고,
반면에 IBatis는 기능은 간단하지만 SQL을 직접쓰기가 편리하고,
많은 학습없이 쉽게 사용할 수 있는것 같습니다.
그래서 전 여러분은 이 두가지 프레임웍크에 대한 생각을 듣고 싶습니다.
여러분이 이 두가지 프레임웍을 선택 하실 기회가 되거나 선택하셔야 한다면 어떤것을 왜 선택하시겠습니까?

단연 Hibernate 아닐까요?
iBatis는 2년 정도 사용했습니다만 효용성으로 따져서는 Hibernate가 압도적인거 같습니다.
진짜 개발자의 칼퇴근을 도와주는 도구는 Hibernate라고 생각되네요.
Hibernate가 초기 학습비용이 크지만 개발자 전원이 모두 알아야 할 필요는 없다고 생각됩니다.
몆몆 사람들이 Db설계와 매핑을 해준다면 나머지 분들이 도메인 설계를 하면 됩니다.
문제는 Hibernate 매핑을 다루는 사람이 고객의 신뢰와, DBA급의 권한과, Hibernate를 이해하며, 클래스설계에도 익숙해야 할듯 한데
한국에서는 그게 쉽지 않을듯 하네요.

현재 스프링으로 프로젝트를 진행중인데 Spring 2.5.6 + iBatis 조합으로 개발하고 있습니다.
초기에 Hibernate도 고려해봤는데 아직 사용법에 익숙하지 않고 여러개의 테이블을 조인해야 되는 상황에다
또 다양한 통계쿼리를 직접 작성해야 될 경우가 많아서 iBatis를 선택했습니다.
iBatis만 선택해도 어느정도의 장점을 누릴수 있지만 진정한 OR Mapping의 장점을 얻으려면 Hibernate가 해답일 거라는 생각이 드네요.
물론 DB설계가 깔금해야 되고 관련 framework에 대한 지식이 있다라는 전제가 깔려야 겠지요.
OR Mapping과 Sql mapping은 완전 개념이 틀린 것 같습니다.

약간 지나친 생각일 수도 있겠으나 전 iBatis를 쓸 꺼면 그냥 Spring JDBC를 쓰는 게 나을 꺼라 생각합니다.
CoC 스타일로 RowMapper와 SqlParameterSource를 쓰면 웬만한 SQL 매핑 문제는 해결할 수 있고, 동적 쿼리 작성 부분만 잘 잡아놓으면 iBatis가 제공하는 거의 대부분을 Spring JDBC로 커버할 수 있을 것 같습니다.
iBatis는 쿼리를 xml 파일로 따로 빼놓아서 일종의 추상화를 시키려고 하는 데 이 부분은 쓸데없는 오버헤드가 되기 쉽지 않나 생각합니다.

이 내용에 대한 이야기는 참 자주 나오네요. KSUG 에서 논의한 것만 해도 벌써 여러번 인 듯 합니다.
근데 한가지 궁금한게, Hibernate 를 SI 프로젝트에서도 사용하나요?
회사 내부 프로젝트나 자체 솔루션 개발 같은 경우 개발 조직이 공부해서 Hibernate 를 사용하면 되겠지만,
(Hibernate 에 대한 교육 비용이 존재하는 것은 모두 공감하고 계시다고 생각합니다.)
SI 프로젝트에 투입된 외주 개발자들에게 비용과 시간까지 들여가며 Hibernate 를 교육시키긴 어렵지 않나 생각합니다.
또한 iBatis 같은 경우 XML 이 따로 떨어져 있으므로 엉성한 query 를 잡아내기가 약간은 더 수월한데
Hibernate 의 경우 소스를 일일이 까 봐야 알 수 있을 것으로 생각하고, 또한 까봐도 잘 알아보기가 힘들것 같아요.
제 경우 6개월 정도 되는 프로젝트 표준을 잡을 때 Hibernate 는 위의 이유 등으로 아얘 처음부터 제외를 하고 시작했습니다.
개발자 구할 때 "Hibernate 가능자" 를 조건에 내걸었다면야 가능하겠지만, SI 프로젝트가 많은 우리나라 상황에서는
Hibernate 가 확산되기 어렵다고 생각합니다. 혹시 SI 프로젝트에서 Hibernate 를 적용해 보셨나요? 그런 경험이 있으셨다면 경험담을 듣고 싶네요.

상황에 따라 다르겠지만, 개발 업체가 기술셋 결정하는 사람과 다른 회사에서 오고
유지보수 담당자와 다른 경우라면, 더군다나 누가 들어올지 모르는 프로젝트라면 Hibernate 적용은 엄두도 못낼 일이죠.
개발자 입장에서 그다지 필요성을 느끼지 못하는 EA니 TRM 등을 논하는 이유나 '변화관리' 등의 이슈가 무관하지 않은 내용인데...
그런 이야기를 꺼내지 않더라도 종종 책임감 없는 인사가 개인적인 선호(?)로 기술만 선정해놓고 제대로 가이드도 하지 못해 프로젝트에 고통을 심어놓고, 시스템엔 버그를 심어놓고 나가는 경우가 있습니다.

이런 얘기가 나오면 항상 질문하시고 싶은 두가지가 있습니다.
- 하이버네이트는 정말 학습비용이 높나요?
- 하이버네이트를 안쓰는 이유가 여러 테이블 조인이나, 리포트(통계)쿼리가 있기 때문이라는 것이 과연 타당한 이유인가요?
저는 둘 다 아니라고 봅니다.
일반 DBA와 같은 역할을 해주는 하이버네이트의 매핑 담당자가 있다면 개별 개발자들은 별로 학습할 게 없습니다. 하이버네이트 매핑이 만들어져 있다면 90%이상의 쿼리들은 자바도 알고 SQL도 아는 개발자라면 1-2일 교육이면 충분히 다 작성합니다. HQL이 SQL에 비해서 뭐가 어렵나요? 게다가 하이버네이트의 튜닝은 개발 후 별도로 해도 그만이니까 오히려 초보자들이 덜 부담을 가지고 개발도 가능합니다. 어짜피 초대형 DB의 초고성능 쿼리가 필요한 상황이라면 SQL도 DBA가 미리 작성을 해주고 그것을 가져다 사용하는 식일테니까, 하이버네이트도 HQL이랑 최적화된 매핑 만들어서 개발자들에게 제공하면 됩니다.
나머지 10%의 리포트 쿼리나 DB의 특수한 기능을 사용하는 쿼리도, 그냥 하이버네이트의 Native SQL 쿼리매핑을 사용해서 SQL 그대로 쓰면 됩니다. 하이버네이트 안에서 일반 SQL을 사용할 수 있게 된 것은 언제부터인지 기억도 안날만큼 오래전부터 지원됐습니다. iBatis만큼 편리하게 Native SQL/XML-Entity(또는 DTO) 매핑도 해줍니다. 당연히 Stored Procedure도 호출해서 사용할 수 있습니다.

> - 하이버네이트는 정말 학습비용이 높나요?
제 생각에 하이버네이트의 전체 학습 비용이 ibatis를 배우는 다 비용보다 크다고 생각하지는 않습니다.
다만 사람들이 ibatis를 다 알고 쓰지 않는 다는 거...
아마 대부분 SI 개발자들은 ibatis의 dynamic sql이나 cache 기능도 모를 거에요.
결과를 객체에 담지도 않을 거고요.
결국 이미 알고 있는 SQL 지식을 활용해서 뭔가 앞선 기술(처럼 보이는) 뭔가를 쓴다는 이미지를 노리는 것 아닐지...
사실 생짜 JDBC 작업을 하는 것 보다는 ibatis가 편하니까요. 다만 우리에게는 spring jdbc가 있지요. ㅎㅎ

> - 하이버네이트를 안쓰는 이유가 여러 테이블 조인이나, 리포트(통계)쿼리가 있기 때문이라는 것이 과연 타당한 이유인가요?
하이버네이트 안 쓰는 이유로 이런 이유는 별로 들어보지 못했습니다.
> HQL이 SQL에 비해서 뭐가 어렵나요?
사실 별로 어렵지 않지요. 다만 이미 개발자들이 SQL은 친숙한데 HQL은 새로 배워야 한다는 것이 문제지요. SI는 프로젝트
는 파견 개발자가 대부분인데 이 친구들이 참 대책없는 경우가 많습니다. struts나 spring의 아주 기본 내용만 교육해도
그 걸 이해 못해서 버벅이는 일이 많지요.
hibernate가 native sql로 쿼리할 수 있는 기능도 가지고 있지만 그거 설명하면 10명 중 한두명 이해하면 다행일것 같아요.
사실 전 ibatis가 세상에 없었다면 참 좋았겠다는 생각입니다. 꼭 hibernate를 써야만 하는 건 아니지만 분명히 jdbc를 직접 쓰는 것 보다 hibernate 같은 orm을 쓰면 비용이 훨씬 줄어드는 임계점이 있는데 ibatis가 그 임계점을 훨씬 뒤로 밀어버린 것 같아요. 기존에 습득한 기술을 우려 먹을 수 있는 기간이 늘어나는 거죠.
제가 hibernate를 쓰지 않는 상황이 아쉬운 건 단순히 hibernate라는 좋은 기술을 쓰지 못하기 때문이 아니라 ORM의 보급이 늦어짐과 동시에 객체지향 기술도 보급이 되지 못하는 것 아닌지 생각이 들어서 입니다.

> - 하이버네이트는 정말 학습비용이 높나요?
제 생각에 하이버네이트의 전체 학습 비용이 ibatis를 배우는 다 비용보다 크다고 생각하지는 않습니다.
ibatis랑 비교해서가 아니라 하이버네이트라는 기술자체가 높은 초기 학습비용을 가진 것인가 하는 질문이었습니다. ResultSet을 뷰단까지 직접 끌고 가서 사용하던 10+년전 방식이 아니라면 대부분 DTO에 결과를 담아서 주고 받는 DAO 패턴에 익숙할 것입니다. iBatis도 마찬가지지요. 요즘은 맵을 선호하기도 한다지만 그렇다고 객체에 담는 걸 모를까요? (설마...) 정보를 의미있는 자바 객체에 담아서 전달하고 매핑하는 것은 이미 익숙한 작업입니다. 그런면에서 하이버네이트와 같은 ORM이 그다지 특별한 이해력을 요구한다고 보지 않습니다.
다만 사람들이 ibatis를 다 알고 쓰지 않는 다는 거...
아마 대부분 SI 개발자들은 ibatis의 dynamic sql이나 cache 기능도 모를 거에요.
결과를 객체에 담지도 않을 거고요.
저는 ibatis의 고급기능이 하이버네이트보다 어렵더라고요. 하이버네이트 2시절에도 xdoclet, 3에선 annotation을 이용해서 매핑정보를 넣다보니, XML로 만든 매핑정보는 보기만 해도 머리에 쥐가 나더군요.
> HQL이 SQL에 비해서 뭐가 어렵나요?
사실 별로 어렵지 않지요. 다만 이미 개발자들이 SQL은 친숙한데 HQL은 새로 배워야 한다는 것이 문제지요. SI는 프로젝트
는 파견 개발자가 대부분인데 이 친구들이 참 대책없는 경우가 많습니다. struts나 spring의 아주 기본 내용만 교육해도
그 걸 이해 못해서 버벅이는 일이 많지요.
대책없는 개발자들은 SQL가지고도 동작은 하지만 성능문제를 일으키는 각종 악성 쿼리를 만들어 냅니다. 대책없는 개발자는 뭘 해도 대책없습니다.
hibernate가 native sql로 쿼리할 수 있는 기능도 가지고 있지만 그거 설명하면 10명 중 한두명 이해하면 다행일것 같아요.

하이버네이트의 Query 오브젝트를 사용할 줄 안다면 native SQLQuiery를 사용하는 방법은 쉽게 마스터 할 수 있다고 봅니다. Native SQL을 오브젝트 매핑 안하고 scalar(List of array)로 가져올거라면 아래와 같이 한줄이면 충분합니다. 이미 존재하는 Entity에 매핑하는 것은 메소드 하나 더 붙이면 되고, 리포트 쿼리라 임의의 DTO로 매핑하는 것도 두 줄이면 충분합니다. 저는 예제 보여주고 10분 설명하면 10명 모두 "간단하네" 하더군요.

sess.createSQLQuery("SELECT * FROM CATS").list();

사실 전 ibatis가 세상에 없었다면 참 좋았겠다는 생각입니다. 꼭 hibernate를 써야만 하는 건 아니지만 분명히
jdbc를 직접 쓰는 것 보다 hibernate 같은 orm을 쓰면 비용이 훨씬 줄어드는 임계점이 있는데 ibatis가 그 임계
점을 훨씬 뒤로 밀어버린 것 같아요. 기존에 습득한 기술을 우려 먹을 수 있는 기간이 늘어나는 거죠.
제가 hibernate를 쓰지 않는 상황이 아쉬운 건 단순히 hibernate라는 좋은 기술을 쓰지 못하기 때문이 아니라 ORM
의 보급이 늦어짐과 동시에 객체지향 기술도 보급이 되지 못하는 것 아닌지 생각이 들어서 입니다.
저는 ibatis 쓰지 말고 하이버네이트 쓰자는 얘기는 별로 하고 싶지 않습니다. 개발만 잘 한다면 뭐 기술이야 입맛대로 또는 영업&정치적인 이유에 따라서 쓰면 되는 것이고요.
다만 하이버네이트를 사용하지 않는 이유를 하이버네이트 자체에 심각한 문제가 있기 때문인 듯이 둘러대는 것은 맘에 안듭니다.

전 솔직히 Hibernate는 어렵습니다.
특히나 쿼리를 생성하기 위한 'Criteria' 사용법이 너무 어렵습니다. 일반적인 조인관계는 그렇다쳐도
사용하기 위해선 맵핑 설정을 충분히 고려해서 사용해야하고 차근차근 개발하기에는 무리가 있더군요.
iBatis는..초기에 조금 사용해봐서 고급기능까지는 안해봤지만, 어렵게 접근은 안해도 되더군요.
그래서 앞으로는 좀더 Hibernate를 공부하면서 Spring JDBC를 사용해보려 합니다. ㅎㅎ

> 좀더 진실해지자면,
Hibernate를 어렵게 느끼는것은 객체지향 프로그래밍에 익숙하지 않아서가 아닐까요?
iBatis가 쉽게 느껴지는건 내가 좀더 절차지향을 편하게 느껴지는 습관 때문일거라는 생각 입니다.
그러면 사실 나는 OOP가 가능한 JAVA를 사용하면서 절차지향적인 면을 더 편하게 느끼고 있는 것입니다.
앨런 홀럽의 말처럼, JAVA를 절차지향적으로 작성하면 JAVA를 사용할 이유가 없습니다.
차라리 절차지향 언어로 작성하는것이 더 효율적일지도 모릅니다.

왜 iBatis 가 절차지향적이고 Hibernate 가 객체지향적이라고 생각하시는지 궁금해요.
sql 들어가면서 나름 OOP 개념으로 의욕적으로 설계를 하다가 깨지는 경향 (껍데기뿐인 모델 등등) 이 있다, 그리고 Hibernate 와 같은 ORM 도구를 "잘" 활용할 경우 OOP 적으로 좀 더 탄탄한 설계를 할 수 있다고 하는 글은 본 것 같은데 절차지향과 연관하여 이야기 하신 것은 잘 모르겠어요. 앞부분을 이해를 하지 못하여, 뒷 단락에 하신 말씀도 이해가 되지 않습니다. 절차지향보다는 OO - relation DB 컨셉의 짬뽕이 문제가 아닐까 해요.
다시 되돌아와서 ORM 도구를 잘 활용하면 더 OOP적으로 좋은 설계를 이끌어 낸다는 점에는 동의합니다.

밑에 강명성님 글을 보고 생각난 것인데 Join 때문에 Hibernate를 못 쓰겠다는 말이 나오는 이유가 성한님 말씀 처럼 객체지향에 익숙하지 않은 것과 관계 있다고 생각이 듭니다.
이건 사실 제가 iBatis를 사용해서 쿼리 결과를 객체에 담는 방법을 개발자들에게 설명하면서 받은 질문 때문에 알게 된 건데요.

RDBMS에서는 DB의 table 평면 공간에 배치되어 있고 서로 동등한 수준에서 관계를 맺는 구조이고 객체 지향에서는 여러 클
래스들이 상속이나 구성을 통해서 관계를 맺는 구조인데 이 두 구조 간의 차이가 생각보다 큰 것 같습니다.
간단히 말해서 RDBMS에서 SQL을 사용하면 이런 저런 테이블을 어떻게 복잡하게 조인해서든 원하는 컬럼 한 두개를 평면적으로
읽어 올 수 있는데 객체를 사용하면 입체적인 구조로 담아와야 한다는 거죠. 뭔가 미리 계획을 잘 세워야 하고 거추장스럽다는 인상을 갖는 듯 했습니다.

단순히 join때문이 아니라 HQL을 토드나 오렌지에서 테스트해 볼 수 없어서 싫어하시는게 아닐까요?
전 프로젝트에서 개발자분들은 HQL보다는 flush같은걸 잘 모르셔서 문제가 생기더군요

따지자면 생명 주기도 있고 lazy loading도 있고 여러가지 걸림돌(?)들이 있지요.
위에서 토비님이 질문하신 것 중 두번째에서 제가 join은 별 문제 없는 것 같다고 말을 하고 보니 이런 생각이 나더라고요. 그
래서 말씀드려 봤습니다. ^^
HQL이야 LOG에 찍히는 sql 구분 사용해서 토드(이 비싼 놈)에서 돌려보면 되기는 하지만 일단 ORMap 담당자가 이런 일
을 해주면 개발자들은 신경 안 써도 되겠죠.
ORMap 담당자는 필수 같아요. ^^

토드처럼 모델(엔티티) 구조를 보면서 HQL을 이클립스 등에서 직접 만들고, 실행 해볼 수 있는 하이버네이트 툴도 꽤 오래전부터 사용되고 있습니다.

Hibernate 사용에 있어 테이블 조인 결과를 어떻게 object에 매핑하느냐와 같은 사용법 문제는 큰 이슈가 아니라고 봅니다. 오히려 많은 SI 프로젝트를 보면, 새로운 시스템 도입 과정에서 업무 분석도 불충분한데 온갖 방법론이나 기술 도입을 통해 결과적으로 만든 시스템에 대해 누구도 만족하지 못하는 경우를 경험합니다. '최종 사용자'는 물론이고 '유지보수 담당자'도 일관성을 찾기 힘든 시스템을 마지못해 인수받는 모습을 어렵지 않게 찾아볼 수 있습니다. 공교롭게 규모가 커서 예산이 충분할수록 이런 현상은 더 심해지는 듯도 보입니다.
정보 시스템 개발을 할 경우 시스템 핵심정보라 할 수 있는 "모델"은 주로 ERD에 녹아듭니다. 현장에서 객체 모델 필요성(?)을 주장한지 5년째이던 2007년 즈음에 현실을 인정했습니다. 넓은 강당에서 고객과 ER 모델러가 커다란 ERD를 펴놓고 격론을 벌이는 모습을 보고서 단념했죠. 과연 객체 모델을 가지고 키맨 사이에 논쟁을 벌이는 날이 언제 올까요? 일회성으로 진행하는 프로젝트에선 요원할 일일 지도 모릅니다.
성철님이 말씀하신 바대로 능력(?)을 전혀 가늠할 수 없는 외주 개발자가 무척 많습니다. 거기에 연차까지 많으면 설득에도 오랜 시간과 노력이 필요합니다. 그런 분을 이끌고 촉박한 시간 안에 프로젝트를 하는데 Hibernate를 쓰자고 하는 일은 헛심쓰기에 가까운 경우가 많습니다. 특히, 업무 설계가 엉성한 경우는 Sub-query와 UNION 없이는 화면 하나도 구현이 불가한데, 이런 경우 굳이 Hibernate를 도입이 주는 이점이 별로 없습니다.

RDB의 join만큼 기껏 설계한 ERD의 가치를 떨어뜨리는 것도 없다고 봅니다.
1:n을 join해서 한방에 가져오면 catersian product에 theta-join이 일어나 1:n의 릴레이션의 의미는 사라진 전혀 새로운 포맷을 가진 직관적이지 않은 결과가 돌아옵니다. 과연 그게 이해하기 쉬운 것인가요? 차라리 ERD에 나타난 엔티티 릴레이션의 구조대로 1:n의 관계를 유지해서 가져오는 하이버네이트와 같은 ORM이 ERD의 개념을 더 충실하게 나타내고 있다고 봅니다.
서브쿼리건 UNION이건 어짜피 SQL을 쓰나 Hibernate를 쓰나 쿼리작성 복잡도는 비슷합니다. 차라리 join의 갯수가 증가하면 HQL이 SQL보다 훨씬 이해하기도 편하고, 역시 ERD에도 잘 부합됩니다.
구지 ORM의 특징이라고 하는 상속개념도 ERD에서 다 나타납니다. 그걸 물리적인 스키마로 표현하면 명시적으로 드러나지 않을 뿐이지, 원래 ERD에 있던 개념이 사라지는 것은 아닙니다. 하이버네이트가 ORM으로 성공한 이유는 백그라운드의 RDB를 무시하지 않고, 그 특징을 적극 활용하면서 프로그래밍 인터페이스 적인 측면을 강조했기 때문이지, 무슨 RDB의 ERD설계와 개념을 제치고 다른 걸 들고 나와서가 아닙니다. 하이버네이트를 마치 ODB처럼 생각하는 것은 완전 잘못된 이해입니다. 하이버네이트는 RDB에 최적화된 또다른 접근방법의 하나일 뿐입니다. 테이블과 인덱스로 구성된 RDB에 SQL이라는 추상적인 인터페이스를 도입한 것과 다를바 없다고 봅니다.
이미 익숙한 기술을 고집해서 새롭고 보다 나은 기술에 저항했던 것은 ISAM에서 RDB로 넘어올 때도 마찬가지였고, 4GL을 도입할 때도, 자바가 메인스트림에 등장했을 때도, 웹 프로그램이 주류가 되려고 할 때도 마찬가지였습니다. 가치를 아는 사람들이 늘어가고 언젠가 임계점을 넘으면 ORM이나 post-RDB 기술이 SQL을 밀어내고 주류가 될겁니다. 아마 그때까지는 "ERD가 기업에는 중요하니 하이버네이트는 안된다"는 FUD가 계속 나타나겠지만요. 차라리 우리는 제대로된 ERD도 없고, 그때마다 주먹구구식으로 만들어서 테이블이 엉망진창이라 매핑할 엄두도 못내겠다라고 하면 차라리 이해가 갈텐데 말이죠.

온라인 상에 Hibernate에 대한 FUD를 퍼뜨리는 사람이 있을 순 있겠지만, 실제 현장에서 FUD 탓에 Hibernate 도입을 꺼리지는 않는다 생각합니다.
본질은 SI 프로젝트에서 주로 형식적인 부분과 절차적인 면은 중요시하지만, 내용에 해당하는 설계 자체에 대해서는 심각하게 다뤄지지 않는다는 점이죠. 외주 개발을 하는 SI 특성상 시스템을 사용하는 고객사 환경을 감안하지 않을 수 있습니다. 이를 위해 EA니 ITA 등을 논합니다. 수 년전부터 금융, 공공 등을 필수로 수행을 했죠. EA 안에서도 DA와 AA는 두드러진 연계점을 찾아보기 힘들더군요.
ERD는 데이터에 대한 정적인 뷰이기 때문에 실제 최종 사용자가 애플리케이션을 사용하는 시점에서 어떻게 데이터를 쓰는지. 가령, 어떻게 묶여서(가령 객체 형태로) 쓰이는지,수정이나 노출(조회) 빈도는 어떤지 등등 동적인 측면에 대해서도 충분히 고민을 해야 합니다. 만일, 이런 내용을 협의하고 고민하고, 그에 따라 시스템 속성을 변경할 필요가 있다면... 객체모델(UML로 그렸든.. 사람들 머리속에 있든)은 강력한 도구가 될 것입니다. 이런 곳에서라면 Hibernate는 정말 좋은 솔루션이라고 생각합니다. 그리고, 추후 그럴 가능성이 있는 곳이라면 학습 비용이나 변화에 대한 저항이 존재하더라도 충분히 대가를 치를 가치가 있겠죠.

하이버네이트 적용 성공에 대한 관건은 RDB의 DBA와 같은 역할을 하는 ORMA가 있어야 한다고 생각됩니다.
그래서 개발자 개개인의 기술에 대한 학습부담을 줄여주어야 합니다. 필요에 따라 HQL이나 페칭 전략 등에 대한 검증과 조언을 해주고, 개발자들의 코드에 나온 Raw SQL을 분석해서 모델레벨의 튜닝을 최적화 해주는 독립적인 작업을 지속적으로 수행해줘야 하죠.
하이버네이트의 장점은 모델레벨에서 페칭, JOIN 방식이나 캐슁 등에 영향을 주는 설정을 개발된 코드나 HQL에 영향을 주지 않고도 조절이 가능하다는 점입니다. 그런면에서 SQL보다 개발자들 수준에 영향을 덜 받을 수 있는 장점이 있습니다만, 그만큼 숙련된 하이버네이트+RDB를 모두 잘아는 뛰어난 전문가가 한명씩은 필요하다는 부담이 될 수도 있습니다.
물론 페칭 방식, 세컨레벨 엔티티 캐쉬에 따라서 HQL에서 한번에 가져올 것이냐, 일부를 가져온 뒤에 캐쉬에서 lazy loading을 하게 할 것이냐의 결정은 코딩 구조에 영향을 주기도 합니다. 그런 결정은 대부분 초반에 어느정도 내려져야 할것입니다. 가장 손쉬운 것은 리드온리성 레퍼런스 정보는 캐슁을 한다는 정도면 되겠죠. 쿼리 캐슁은 나중에도 얼마든지 조정이 가능하니까 뭐 상관없습니다만. 그런 정도 팁들은 JPWH 책 한권만 봐도 아주 자세하게 잘 나와있습니다.
HQL은 복잡한 쿼리 위주라면 named query로 해서 XML로 뺀 후 ORMA/DBA가 관리하게 하는 것도 좋은 방법입니다. "데이터가 회사의 가장 중요한 자산이다"라고 생각하는 기업이라면 SQL에는 개발자가 손도 못대게 하고, DBA들이 미리 만들어서 제공하는 경우가 많을 겁니다. HQL도 마찬가지의 접근을 할 수 있죠.

SI현실을 가지고 얘기하면 사실 끝이 없습니다. 엉망인 것도 워낙 제각각이라서 말이죠. 친한 DB컨설턴트의 말을 들어보면 ERD보고 SQL도 제대로 못만드는 개발자들도 여전히 많이 있다고 합니다.
SI현실을 까놓고 보자면 스프링을 왜썼나 모르겠다 싶은 프로젝도 많이 보입니다. 개발자 수준은 안되고, 학습부담은 크고, 유지보수에 대한 대책이나 후속조치도 불분명하고, 현 상황에서 썼을 때 그다지 장점도 없어보이는 대표적인게 스프링이라고 생각됩니다. 친숙한 JSP Model1이나 개발자들이 제법 익숙한 스트럿츠1+헬퍼 클래스 또는 벤더 지원과 툴도 빵빵한 EJB를 쓰면 되는데 굳이 장점이 좀 있다고 SI현실에 부합하지 않는 어려운 스프링을 도입해야 할까요?
물론 스프링을 안쓰는 곳은 FUD 때문이거나 다른 기술적인 이유가 아닌, 더 현실적인 타당한 이유가 있겠죠.
그래도 "EJB는 표준기술이니까 다들 익숙하고, 스프링은 오픈소스니까 학습비용도 크고, 서버도 톰캣에서밖에 안돌고 메인프레임 연결도 할 수 없고 어쩌고 등등" 하면 곱게 못넘어갈 것 같습니다.
또는 현실적인 문제는 극복할 의지와 가능성이 있는데, FUD 때문에 꺼리는 사람이 있다면 잘못이해하고 있는 것을 바로 잡아주는 것이랑 "SI 현실을 무시하고 스프링 써라"라고 말하는 것은 분명히 다릅니다.
저는 스프링을 쓰고 싶으나 분산트랜잭션이 필요해서 스프링을 도입못하고 있다는 사람을 만나본 적이 있습니다. 스프링에서도 훨씬 세련된 방식으로 분산트랜잭션을 사용할 수 있다고 설명해줬더니 아주 좋아하더군요. 물론 당장에는 다른 현실적인 한계로 인해서 스프링을 도입 안할 수 있습니다. 하지만 다음 번에는 좀 더 도입할 의욕을 가지고 장애물을 극복하고 도전할 용기를 그만큼 더 낼 수 있을 거라고 기대합니다.
하이버네이트에 대해서도 마찬가지 생각입니다. 현실적으로는 무리다라고 말하는 것과 기술적인 오해를 가지고 힘들겠다라고 말하는 것은 분명 다릅니다.
솔직히 한국에서 하이버네이트에 대한 제대로된 기술적인 비판이나 분석이 진행된 것을 본 기억이 없습니다. 그냥 "성능이 떨어져서..", "데이터 모델이 복잡해서..", "복잡한 조인 쿼리가 있어서..", "개발자들이 배우기 힘들어서.." 라는 식입니다. 좀 구체적인 내용을 가지고 얘기를 하면 좋겠는데 말이죠. 그러면 충분히 답변 가능한 것들이고 반박도 할 수 있고, 증거도 보일 수 있을텐데 말이죠.
그런데 하이버네이트 제법 쓰이는 것 같습니다. 상대적으로 아직 미미할지는 모르겠지만, 수십억원 급 또는 그 이하의 중소규모 프로젝트들을 중심으로 제법 쓰이고, 만족스럽게 결과를 냈다는 얘기도 종종 들리더군요. 작년에 벌써 200여군데의 현장에 적용했다고 하는 SDS의 애니프레임도 하이버네이트를 사용하지 않았나요? 하이버네이트는 스프링과 비슷하게 한번 제대로 쓰면 계속 쓰고 싶어지는 중독성이 있는 것 같습니다. 어쩌면 생각보다 빨리 주류기술로 올라설지 모르죠.
* FUD (Fear, Uncertainty, and Doubt)

이 글을 보니 위에 제가 애매하게 쓴 제 생각을 더 명확히 정리할 수 있네요.
ORM이 ERD 구조를 더 충실하게 유지한다고 하셨는데 맞습니다. 그런데 그런 특성이 ORM 도입을 힘들어하는 이유가 되는 것 같습니다.
우리나라 개발자들을 결과를 빨리 얻기 원하는 것 같습니다.
쿼리 하나 날려서 원하는 결과를 얻고 이 결과를 기계적으로 화면 단에 전달에 표시하기를 원하는 거죠. Data가 구조화된 상태
로 관리되는 것은 DB로 충분하지 굳이 메모리에까지 구조화된 상태로 가지고 오기를, 그래서 그 자료를 다시 어떤 로직으로 처리하
기를 원하지 않는 것 같습니다.
데카르트 곱이 ERD의 구조를 깨트린다고 하셨는데 데카르트 곱의 결과를 가지고 어떤 처리를 할 것이 아니라 그것 자체가 결과라
면 사실 그런 구조 파괴가 문제되지는 않으니까요.
저는 이렇게 SQL에 대부분의 주요 로직이 들어가고 Java 코드는 단순히 인자를 전달하고 결과를 반환하는 일을 주로 하는 방식의 개발 관행이 바뀌지 않는다면 ORM은 일할 양이 늘어나는 번거로운 기술로 받아들여질 듯 합니다.

결과를 빨리 얻기를 원하는 점은 개발자에 국한한 이야기는 아닌 듯 합니다.
그리고, 팀 단위 작업이라면 ERD는 아무 개발자에게나 맡기지 않잖아요.
ERD를 구성하는 어휘도 관리하고, 여력이 있는 경우 모델링과 검증을 위한 전문 인력을 두기도 하고
논리와 물리로 단계를 나누어 정규화도 하고, 이후에도 ERD에 입각해서 DB 객체를 만들어내고 관리하는 과정에 상당한 공수를 투입합니다.
즉, 중요하게 취급하죠.
하지만, ORM에 대해서도 그럴까요? ORM은 EA/ITA, SOA처럼 큰 돈을 보장하는 fancy한 기술이 아니기 때문에
지속적으로 노하우나 이점을 실제로 맛 보고, 이를 공유하고 가시화 되어지는 긴 과정이 필요한지 모릅니다.
어떤 면에서는 Spring이 주류로 올라선 과정을 ORM도 겪어야 하지 않나 싶고, 이미 그런 과정 중에 있는지도 모르죠.

하이버네이트가 결과를 빨리 얻는데는 더 낫다는 것을 알면 좋을텐데 말이죠.
lazy loading이랑 object navigation을 써서.. 대충 엔티티 하나 가져와서 뷰단에서 마구 관련 정보를 다 끌어와 붙이고 추가해도 되자나요. 매번 가져올 필드랑 조인할 테이블이 생기면 SQL을 고치고 화면도 고치고 하는 것보다 훨씬 편한데 말이죠.

애니프레임에 대해 말씀하신 부분에 오해의 소지가 있어 관련 조직에 몸담고 있는 제가 다시 부연 설명을 드리면,
일단 작년 한해동안 SDS 에서 자체적으로 수행한 프로젝트가 200 여군데가 되지는 않습니다^^; 아마도 예전의 SYSTEMiER 를 포함하여 SDS에서 수주하여 Framework 지원까지 발생한 프로젝트 수로 생각됩니다.
또한 대부분의 현장 프로젝트에는 SQL Mapper 류인 QueryService 가 사용되었고, ORM 기술로 현장 프로젝트를 진행한 사례는 많지 않은걸로 알고 있습니다. 위에서 여러분들이 말씀하신 SI 프로젝트의 대표적인 사례겠죠. 동일한 유형의 단순 CRUD App. 를 코드 제너레이션 기반으로 찍어낼 때는 확실히 ORM 이 장점이 있고 사용 사례도 있습니다만..
애니프레임에서는 Hibernate 에 대한 문서화나 일부 기능 확장 및 Sample App. 등에 레퍼런스를 제공하기도 하고, 내부적으로 진행되는 프레임워크 기능 영역에 현재 JPA 기반으로 진행중인 부분도 있습니다만, 아직까지 현장에서 ORM 을 채택하는 데는 진입장벽이 있는것 같습니다. 최근에 릴리즈된 AnyframeGen 에서는 JPA 기반의 persistence 영역을 동등한 레벨에서 지원하고 있고 계속적으로 ORM 에 대한 가이드를 강화하려고 노력은 하고 있습니다.
개인적으로 ORM 를 현장에서 사용할 때 가장 문제가 되는 부분은 relation 관계를 nested 형태의 객체로 작성하는 것 자체가 아닐까 합니다. SQL 을 직접 사용하는 경우 객체 맵핑을 한다 하더라도(그냥 Map을 쓰는 경우가 현장에서는 더 많죠) flat 한 형태로 대부분 처리하였을 것인데 이 부분의 변경은 영향이 가장 큰것 같습니다. 특히 데이터를 담고 있는 객체는 UI 를 비롯한 전체 레이어에서 사용되므로 변경 영향이 큰것 같습니다. 특히 우리나라에서 많이 사용되는 X-Internet 류의 데이터 처리 객체로 컨버전을 해야하는 경우가 상당히 많은데 이런 부분도 어려움이 존재하고요..
SQL 을 직접 사용하는 경우보다는 transaction 발생이 미뤄질 때 exception 에 대한 처리, fetching 전략, lazy loading, clustering 환경에서의 cache sync. 문제 등 고려할 것들이 더 많아지므로 저부터도 쉽게 접근하기는 어려운 것 같습니다.
점차로 우리나라에서도 ORM 이 많이 사용될 것은 의심치 않습니다. 그렇게 되려면 현장의 성공사례가 많아지고 이에 대해 제대로 리드할 줄 아는 기술자가 많아져야 하겠죠.


정말로 많은 이야기들이 나옵니다. 이러한 이야기들은 전에 서과장님과 저랑 자주 하던 이야기이기도 했고요. 



아래는 토비의 스프링 3.1로 유명한 토비의 글입니다. 


내가 가장 좋아하고 많이 사용하는 자바 프레임워크는 스프링과 하이버네이트다. 거의 5년전 이 두개의 프레임워크를 처음 접했을 때의 충격과 감동은 지금도 잊혀지지 않는다. 두가지 다 내가 가졌던 오랜 고정관념을 확실히 깨뜨려주었고, 자바 프로그래머로서의 정체성을 다시금 확인할 수 있게 해주었다. 자바가 객체지향언어이며 비록 웹 개발을 한다고 할지라도 구지 ASP인지 JSP인지 구분이 안가는 JSP+스크립트성 자바코드 방식이 아닌 진정한 자바의 객체지향언어로서의 장점을 지키며 개발할 수 있다는 것을 분명 확인할 수 있었다. DB지상주의자들의 오만한 주장처럼 자바(또는 일반 프로그래밍 언어)는 그저 DB를 호출하고 UI랑 연동시켜주는데 사용하는 껍데기 인터페이스 뿐이다라는 수십년된 구닥다리 생각이 얼마나 시대에 뒤떨어지고 무지에서 나온 것인지도 분명히 깨닫게 되었다.

특히 하이버네이트는 당시 10년이 넘도록 매진해온 RDB의 경험과 매력을 사실 한층 더 가치있게 활용하는 법을 알려준 가장 고마운 프레임워크이다. 80년데 DBase시리즈로 출발해서 클리퍼,폭스베이스,폭스프로 등을 경험하다 93년에 처음 오라클7.3을 대형 프로젝트에서 처음 경험 했을 때 알게된 RDB의 매력과 능력이 당시에는 존재하지도 않았던 자바라는 멋진 언어와 이렇게 잘 조화되어서 양쪽의 장점을 다 살려서 빠르고 정확하고 멋지게 개발할 수 있구나라는 생각을 하게 만들어주었다. 당시 하이버네이트는 버전 2.6이었고, Gavin King이 호주 멜번에서 주로 EJB기반의 프로젝트에 참여하던 시절에 그의 매일 밤과 주말 시간을 모두 희생해서 열정적으로 개발하고 지원하던 사실상 1인 개발 프레임워크였던 시절이었다. 그럼에도 I모사의 책상 앞에서만 똑똑한 연구진들이 만들어내, 기업의 덩치로 밀어붙여 억지로 표준기술로 만들어버린 EntityBean이라는 자바역사상 가장 웃음거리가 된 기술보다 백만배쯤 낫다고 느껴졌다. 사용자들의 반응도 뜨거웠다. 결국 Gaving King은 JBoss에 영입되어 하이버네이트 개발을 책임지는 풀타임 오픈소스 개발자가 되었다.

그 당시 Hibernate vs JDBC와 관련된 논쟁이 많이 있었다. 그때 나름 공감을 받던 주장은 이렇다.
만약 애플리케이션 개발자가 DB설계를 직접 할 수 있거나, 영향력을 줄 수 있는 위치에 있다면 하이버네이트가 좋고, 아니고 DBA팀을 비롯한 애플리케이션 쪽은 전혀 모르고 DB만 고려하고 설계하거나 이미 오래전에 만들어져서 운영준인 레거시DB라는 JDBC를 선택하는 것이 낫다
이유가 뭘까? 왜 같은 DB이고 같은 애플리케이션이 결국 사용할 것인데 개발자들이 직접 DB를 관장하면 하이버네이트에 적합하고, 아니라면 부적합한 것일까? 어떤 이들은 이것을 하이버네이트는 객체DB스타일의 설계가 필요하기 때문에 ODB적인 구조로 DB를 특별하게 만들어야 하기 때문에 객체설계 후 그에 따른 DB스키마 작성이 필요하기 때문이라고 말한다. 하이버네이트의 기본도 모르는 바보들의 주장이다. 

하이버네이트는 순수 객체기반 영속성 솔루션인 엔티티빈에 대한 반감과 저항으로 등장한 기술이다. 하이버네이트가 지향하는 것은 진정한 O"R"M이다. 저 R이 관계형DB의 R이라는 것을 모르지는 않을텐데 말이다. 왜 DB를 써서 ODM이라고 하지 않고 ORM이라고 구지 관계형DB라는 것을 명시했을까? 그 이유는 하이버네이트는 관계형DB와 자바의 매핑이 목적인 프레임워크이기 때문이다. 그 말은 하이버네이트에 적합하게 따로 설계된 DB가 아닌, 가장 관계형DB다운 DB라면 하이버네이트와 완벽하게 연동이 될 수 있다는 말이다.

레거시DB와 하이버네이트 2.x가 함께 사용하기에 부적합했던 이유는 딱 한가지이다. 무식한 DBA나 DB설계자들 탓에 정규화도 제대로 되지 않은 엉망인 구조의 DB들인 경우가 있었기 때문이다. 물론 필요에 따라 비정규화를 한 경우도 있겠지만, 국내 한 유명 DB컨설턴트의 푸념처럼 정규화를 거치지도 안고 처음부터 그냥 생각없이 퍼포먼스를 위해서라는 근거도 없는 명분으로 비정규화부터 하는 식의 엉터리 DB설계들이 판을 치기 때문이라는 것이다. 하이버네티는 2.x조차도 RDB의 바른 설계원칙을 따라 만들어진 DB라면 완벽하게 매핑시킬 수 있다.

또 한가지 주장은 퍼포먼스이다. ORM은 JDBC를 그대로 가져다가 사용하는 것에 비해서 분명 퍼포먼스의 손해가 있다. 하지만 이 가정은 아주 단순한 기본적인 아이디어일 뿐이다. 혹 하이버네이트 1.x라면 들어맞을지도 모르겠다. 하지만 하이버네이트는 수많은 ORM의 퍼포먼스 향상 기법을 도입했고, 단지 매핑된 객체와 하이버네이트의 기반 HQL을 이용해서 거의 완벽에 가깝게 그것이 만들어 내는 SQL을 제어할 수 있다. 초기 ORM기술의 바보같은 n+1 퀴리 문제 같은 것은 더 이상 하이버네이트에서는 아무 문제가 아니다. 모델은 그대로 1tom 이더라도 그 정보를 조인해서 한번에 가져오는 것은 아주 간단한 일이다. 혹 하이버네이트에 무지한 자들이 하이버네이트는 JDBC/SQL을 사용하지 않는 것처럼 착각하는데 하이버네이트도 결국 JDBC를 이용해서 SQL로 DB와 커뮤니케이션 한다. 숙련된 하이버네이트 개발자들은 엔티티 객체를 다루면서 그것이 백그라운드에서 만들어 내는 SQL을 완벽하게 함께 머리로 그릴 수 있는 능력이 있다. 게다가 하이버네이트는 매우 간단한 설정만으로 객체베렐, 퀴리 레벨의 다양한 캐슁을 지원한다. 그것도 분산서버에서 트랜잭션까지 지원하는 캐슁도 아무런 문제없이 지원한다. DB스타일에 따라 캐슁이 적절히 사용되면 별다른 캐슁기술을 적용하지 않은 JDBC코드와 비교해서 훨씬 나은 성능을 보여줄 수도 있다.

JDBC를 이용한 애플리케이션도 이전처럼 ResultSet을 jsp까지 끌어가서 화면에 바로 출력하는 미련한 짓은 하지 않을 것이다. 다 DAO레이어를 만들고, 어떤 스타일이든 DTO를 사용해서 객체에 정보를 담는다. 그런 오버헤드가 사실상 전체 퍼포먼스에 미치는 영향은 극히 미미한데다 그것으로 얻을 수 있는 개발생산성과 버그의 위험도를 줄일 수 있는 가능성등의 장점이 워낙 크기 때문에 당연히 다들 DTO를 사용한다. 그런데 왜 하이버네이트의 매핑은 무슨 엄청난 오버헤드가 있어서 별 대단한 것도 아닌 시스템에서조차 성능때문에 못쓴다라고 하는 것일까?

DB의 성능에 대한 요구는 DB자체의 발전만으로는 커버가 불가능하다. 경험해본 사람들은 DB의 스케일업과 아웃이 얼마나 큰 비용이 드는지는 잘 알것이다. 클러스터링이 가장 어렵고, 된다고 해도 엄청난 비용이 드는 것이 DB이다. 작년엔가 모 금융사에서 메인메모리만 수백G짜리 수십억(백억이 넘던가..) 대의 초대형 DB서버를 구입해서 콘솔리데이션 프로젝트를 했었는데 얼마나 끔찍하게 고생했는지 거기에 참여했던 컨설턴트를 통해서 들은 적이 있다. 그래서 이제는 각종 Data Grid 와 같은 분산 기술들이 자바와 같은 객체지향언어와 결합해서 엄청난 속도로 발전하고 있다. DB의 절대왕좌를 차지하고 있는 오라클 조차 Coherence의 Tangosol을 인수했다는 것을 모르는가? Coherence는 수백대의 클러스터 그리드를 이용해서 미국의 한 금융 벤치마크에서 백만 TPS를 기록했다고도 한다. 국내의 경우에도 리니어하게 스케일링되는 구조에서 노드당 1500TPS이상을 가뿐하게 기록했다고 나와있다. 리니어스케일이 되는 이런 기술들이 하이버네이트와 얼마나 잘 결합되는지는 하이버네이트-Coherence의 역사를 보면 아주 잘 알 수 있을 것이다. 시대가 이렇게 빠르게 흘러가는데 아직도 기업의 DB관리는 보수적이고 어쩌고 저쩌고 하면서 한번 배운 기술 마르고 닳도록 울궈먹기 모드로 꼭 들어가야 하는 것일까?

스프링의 초기에도 그랬던 것처럼 그런 이유는 무지해서 그렇다. 잘 모르거나, 어설픈 얕은 지식으로 그냥 자신의 무지를 성능탓으로 돌리는 것이다. 그것은 마치 스프링으로 개발하면 메인프레임과 연동은 불가능하다(EJB만 된다)는 헛소리와 마찬가지 주장이다.

다시 위의 DB설계의 책임이 누구에게 있냐에 따른 하이버네이트 적용의 판단기준을 살펴보자. 하이버네이트 팀은 저런 상황을 잘 파악하고 있었다. 그리고 이상적인 모델만 현실에 존재하지 않는다는 것을 잘 파악했다. 그래서 하이버네이트 3.0이 나온 것이다. 이미 3년 전에 말이다. 하이버네이트3.0은 정규화가 잘된 깔끔한 DB뿐 아니라 바보 DB모델러들이 어설프게 설계한 레거시 DB도 매핑하는데 아무런 문제가 없게 만들어졌다. 게다가 엔티티 단위가 아닌 각종 복잡한 프로젝션 쿼리(일명 리포트 쿼리)도 완벽하게 지원한다. 역시 객체 단위가 아닌 벌그 업데이트도 당연히 지원한다. 사실상 SQL레벨에서 하던 거의 모든 작업을 하이버네이트의 OR매핑 장점을 그대로 살린채로 다 적요할 수 있다. 심지어 DB에 아주아주 specific한 네이티브 쿼리를 사용해야 하는 경우도 얼마든지 적용된다. iBatis못지않은 SQL-객체 바인딩도 지원한다. 심지어 그 결과를 DTO가 아닌 엔티티로 가져와서 작업하는 것도 가능하다. 하이버네이트를 쓰면 못쓰는 DB특화된 SQL이 있어서라는 엉터리 주장을 하는 사람들을 보면 한심하기 짝이 없다. 

오늘 아침에 읽은 글이다.
"스터디 끝나고, 간단히 식사를 하면서 왜 국내에서는 하이버네이트 보다 iBatis가 더 각광 받느냐에 대한 의견 교환이 있었습니다. 비즈니스 모델링 단계에서 개발자 혹은 설계자가 자료 구조에 대한 고민을 하고 되는데, 객체지향 분석/설계에 충실하다면 객체 모델링을 통해 도출된 데이터 구조 자체를 저장소(repository)로 손쉽게 매핑(mapping)할 수 있는 하이버네이트가 유리하다는 점에서는 동의했습니다. (사실 제 첫번째 직장이 객체형 데이터베이스 회사였기 때문에 충분히 수긍할 만한 의견이었습니다.)
하지만 국내 IT 현장에서 가장 큰 발언권을 가진 사람들은 개발자가 아니라 시스템 운영자들 혹은 데이터베이스 관리자들입니다. IT를 잘 모르는 경영진 입장에서는 아무래도 회사의 자산이라고 여겨지는 것이 바로 데이터베이스이고 프로그램은 덜 중요해 보이거든요. 그러다 보니, 시스템 개발 현장에서 가장 먼저 그리고 중요하게 분석/설계되는 것은 업무 요건이 아니라 바로 데이터베이스 설계입니다. 데이터 구조가 먼저 설계되고 쿼리를 만들고 그 위에 어플리케이션을 탑재하는 순서로 개발하니 당연히 하이버네이트는 적합한 프레임워크로 고려될 수 없게 되는 것입니다."
제대로 DB설계가 된다면 왜 그것이 하이버네이트에는 적합하지 않다는 말인가? 참 답답하다. 이 글을 읽다가 답답한 마음이 들어 이 글을 쓰기 시작했다.

물론 나도 하이버네이트가 모든 곳에 항상 적용가능하고 낫다고 보지는 않는다. 예를 들어, DB는 간단하고 부하만 큰 포탈의 게시판, 블로그 등은 ORM이 적합한 곳이 당연히 아니다. 객체 매핑 해봐야 무슨 이득이 있겠는가. 사실상 저런데는 RDB조차 적합하지 않다. 4억명의 회원을 보유한 ebay는 잘 알려진대로 DB트랜잭션조차 사용하지 않는다고 한다. 올바른 선택이다. 또 데이터의 입출력은 거의 없는 분석위주의 OLAP시스템도 하이버네이트 쓰는 것이 불가능하지는 않으나 별 장점이 없다. 그럴땐 OLAP쿼리 관리나 깔끔히 하면서 iBatis 같은게 낫다고 하겠다. 고객이 정말 무식과 고집을 겸비하고 있는데다, 밉보이면 향후 프로젝트에 지장이 있을 것 같은데 무조건 JDBC기반 DAO를 쓰겠다고 주장하면 살금살금 꼬셔서 SpringJDBC정도만 어찌 도입해보는게 나을 것이다. 정치적인 이유지만 어쨌든 시스템을 원활히 개발하기 위한 어쩔 수 없는 선택이 있다는 것도 안다. 또 애플리케이션은 DB의 인터페이스 용으로만 쓰고 모든 로직이 다 Stored Procedure에 저장되어있는 구닥다리 시스템이고 그것을 고칠 마음이 전혀 없다면 역시 하이버네이트는 선택의 대상이 아니다. 하지만 그 외의 모든 경우라면 하이버네이트는 충분히 적합하고 적용할 수 있고 많은 장점이 있다. 하지만 개발자들이 먼저 나서서 하이버네이트는 성능이 어쩌고, 적합하지 않아서 어쩌고 하는 것은 정말 아니다. 제대로 검증해보고 타당한 증몀을 해봤는가? 장단점을 충분히 진지하게 따져봤는가?

대형사이트? 더욱 더 적극 도입해야 한다. 물론 개발자가 많으면 평균 수준이 떨어지고, 각자 가진 기술수준이 차이가 많이 나서 기술수준 자체를 낮춰야 할 수도 있겠다. SQL만 달랑 넣으면 DTO부터 전 레이어의 기본코드가 딱 만들어지는 초간단 툴들이 요즘 인기있는 이유가 그것이라고 한다. 그만큼 다른 많은 것을 손해를 보고 가야함은 당연한 것이지만. 그렇다고 언제고 SQL만 알고 자바 문법만 아는 사람들로만 시스템 개발을 할 것인가? 오픈소스는 안돼라고 외치던 많은 곳에서 이미 스트럿츠1을 시작으로 이미 스프링과 iBatis 같은 고급 프레임워크 까지 적용이 이뤄지고 있다. 적절한 전략과 충분한 준비와 시간이 있다면 얼마든지 도입 할 수 있다. 개발자가 많으면 구현방식의 통일이 어렵고, 버그의 발생가능성이 높아진다. 하이버네이트와 같은 자바에 충실한 개발방식이 얼마나 개발자의 스트레스를 덜어주고, 생산성을 높이며 버그발생을 줄여주고, DB와 자바, UI까지 왔다갔다 정신없는 것을 충실하게 자바 모델에만 집중해서 개발할 수 있게 해주는지 안다면, 대형사이트일 수록 과감한 도입이 필요할지도 모른다. 그 비싸고 많은 모델러와 컨털선트는 왜 쓰는데…

내가 실무 프로젝트를 초기에 경험 할때는 코볼에 ISAM에 익숙한 노땅 개발자들의 전성시대에서 RDB와 같은 신기술이 막 떠오르려고 하던 때이다. 또 틈새를 비집고 UniSQL과 같은 허접 ODB도 설쳐대던 때다. 그때 ISAM에 익숙한 선배 개발자들의 푸념이 기억난다. 메인프레임에서 ISAM으로 했으면 이 정도는 순식간에 완벽하게 착착 다 만들었을 텐데 이게 무슨 장난감 같은 유닉스에, 복잡한 언어인 C에, 배우기도 힘든 3-Tier기술에, 성능도 떨어지는 RAD툴에 RDB까지 정신이 없다고 투덜대던 시절이다. 왜 복잡하고 지저분한 SQL을 이용하는, ISAM에 비해 성능도 떨어지는 RDB를 써야 하냐는 그때 그 사람들의 모습이 바로 지금 SQL에 익숙한데 왜 하이버네이트와 같은 새로운 기술을 또 공부해야 하냐라고 저항하는 개발자들의 모습과 꼭 닮았다.

물론 하이버네이트가 좋으니 당장 바꿔라라고 말하고 싶지 않다. 심지어 하이버네이트 사이트에도 프로젝트 1개월 남았는데 갑자기 하이버네이트로 바꾸자 따위의 생각은 꿈도 꾸지 마라라고 FAQ에 나와있었다. 개발 패러다임의 변화이니 충분한 시간을 가지고 학습하고 최적화된 기술을 익히는 과도기를 거쳐야 할 것이다. 그런 이유에서라면 당장 도입을 지연하는 것은 이해한다. 하지만 별 것도 아닌 중소형 사이트에 시간도 있고, 새로운 프레임워크도 익힌다면서 하이버네이트는 "그거 한국에서는 안돼"라는 말로 아무런 근거도 검증도 없이 그냥 iBatis나 쓰자라는 식으로 가는 모습은 정말 안타깝다. 제발이지 좀 근거를 가지고 구체적으로 비판을 하려면 했으면 좋겠다. 제발이지 나도 화딱지 나서 외국의 개발자들에게 "한국 개발자들은 무식하고 겁쟁이라 하이버네이트는 쓸 줄도 모릅니다"라고 하지 않도록…


참고자료입니다.  (출처 : http://www.slideshare.net/daumdna/devon-2012-b4-orm)

이렇게 된 이유는 과연 무엇일까요??



저작자 표시 비영리 변경 금지
신고
Posted by xyzlast Y2K

* 사내 강의용으로 사용한 자료를 Blog에 공유합니다. Spring을 이용한 Web 개발에 대한 전반적인 내용에 대해서 다루고 있습니다.


지금까지 우리는 DB에 접속을 하고, DB에 있는 내용을 이용해서 Service를 구성하는 방법에 대해서 알아봤습니다. 
기술들은 다들 자신만의 색깔을 가지고, 개발자들을 좀 더 편하게 하기 위해서 발전되어 왔습니다. 그렇기 때문에 개발자들마다 자신이 선호하는 기술들이 따로 있는 것이고요.
그렇지만, 우리가 지금까지 Model을 하는 부분에 대해서는 한가지만은 확실히 나올 수 있습니다. 

"각자의 영역으로 분리"

이것은 DB를 다루는 Model 뿐 아니라, 모든 객체와 개발에서의 Layer가 지켜야지 되는 원칙이라고 할 수 있습니다. 

일반적으로 우리가 사용한 Model은 다음과 같은 package로 나뉠 수 있습니다. 

com.xyzlast.bookstore.entities
com.xyzlast.bookstore.vo
com.xyzlast.bookstore.dto
com.xyzlast.bookstore.dao
com.xyzlast.bookstore.repositories
com.xyzlast.bookstore.services

구성될 수 있는 package에 대해서 다시 정리하고, 최종적인 web application의 데이터의 흐름에 대해서 알아보도록 하겠습니다. 

Packages

entities package

Hibernate와 같은 ORM framework를 사용하는 경우, object와 persistence model간의 관계를 구성한 ORM 객체가 위치하는 영역입니다. 또는 Table에 1:1 mapping을 해서 구성하는 경우도 있습니다. 그렇지만, entities를 사용한다는 것은 기본적으로 DDD를 사용하는 것과 동일합니다. 객체과 그 객체의 관계에 대한 구성을 코드에 녹여내는 방식을 주로 사용하게 됩니다. 

vo package / dto package

vo(value object), dto(data transfer object)의 경우에는 일반적으로 persistence model에서 넘어오는 값들을 단순 parsing할 때 사용됩니다. 여기에 가장 대표적인 기술로 mybatis를 소개하였고, 이는 db에서 얻어오는 값을 view에서 단순 표시하기 위한 방법으로도 자주 사용하게 됩니다. 
이 두 package는 myBatis를 Domain Layer의 Framework로 사용하는 경우에는 거의 필수로 사용됩니다. 또는 개발시에 Model 영역에서 Controller/View 로 데이터를 넘길때, DTO 객체를 만들어서 넘길때 사용되기도 합니다. 이때는 vo가 View Object의 의미로 사용되기도 합니다.

dao

직접 DB에 query를 보내고, entity, vo, dto를 얻어오는 영역입니다. DB를 사용하는 기술에 따라 다르게 구성이 되는 것이 일반적이며, CRUD에 대한 모음으로도 구성될 수 있습니다. 단순 CRUD가 이루어진다고 해도, DB에 대한 기술적 영역이 바뀌게 될 가능성은 항상 열어두고 작업을 하는 것이 좋을 것 같습니다. 그렇기 위해서는 interface로 정의된 dao를 사용하는 것이 보다더 효과적으로 구성이 가능하게 됩니다. dao로 지정하게 되는 것은 controller, domain 모두에서 dao를 사용하겠다는 의미입니다. Hibernate와 같은 ORM을 사용하는 경우에는 repository pattern으로 접근하는 것이 더 좋습니다.

repositories

Repository는 Dao와 매우 유사한 개념입니다. 이 두 용어의 차이점은 기능이 아닌, 사용되는 코드의 위치입니다. Domain Layer에서만 사용되는 경우에는 repository, Domain뿐 아니라 모든 영역에서 사용된다면 dao로 개발하게 됩니다. 이 둘의 차이는 Model을 풀어가는 pattern의 차이입니다. 보다더 pattern 상위적인 개념이 Repository이고, Dao는 database 적 개념이 강한 Object라고 생각하면 좀 더 이해가 쉬울 것 같습니다. 

services

business logic 영역입니다. 여러개의 dao object들과 entity 또는 vo/dto object들을 얻어내고, 그 객체들간의 로직이 구성되는 영역입니다. 일반적으로 transaction의 단위 영역이 된다는 것을 명심해주세요. 
위의 구성에서 결국은 model은 3개 이상의 package로 구성이 됨을 알 수 있습니다. 남의 코드를 보더라도 대부분 위와 비슷한 구성으로 package가 구성된 경우가 많으니 참고바랍니다. 

Domain Framework의 비교

다음은 지금까지 알아본 Model을 접근하는 Framework의 조합에 대해서 한번 정리해보도록 하겠습니다. 
Framework특징장점단점
No Framework - PreparedStatement 를 이용하는 방법1. Native Query 구성1. native query를 이용한 학습 시간의 단축1. 오타가 발생하는 경우, query를 실행하기 전까지 에러를 확인할 수 없다.
2. 중복 코드가 많이 발생된다.
3. connection의 관리를 비롯한 Transaction의 처리를 모두 수동으로 해줘야지 된다.
4. java 코드에 sql 코드가 들어가기 때문에 관리 및 debug가 힘들다.
JdbcTemplate1. Spring JdbcTemplate 이용
2. DataSource 이용
3. Native Query

1. native query를 이용한 학습 시간의 단축
2. connection 관리
3. Transaction 관리
1. 오타가 발생한 경우, query를 실행하기 전까지 에러를 확인할 수 없다.
2. 중복 코드가 많이 발생된다.
3. java 코드에 sql 코드가 들어가기 때문에 관리 및 debug가 힘들다.
Hibernate1. HQL, Criteria
2. DataSource
3. Spring Transaction
1. 다양한 reference
2. 객체를 이용한 query의 처리로 인하여, 코드양을 줄일 수 있다.
3. 프로그램 설계 및 구성 부분에 대해서 장점을 갖는다. (DDD와 같은 객체 지향적 구성 가능)
4. Table의 변경 또는 DB의 변경에 유연한 장점을 갖고 있다.
5. 동적 query가 자유스럽다.
1. 학습 시간의 소요
2. criteria, HQL 모두 오타에 취약한 구조
3. 단순 CRUD에 대한 코드양 증가 - 1, 2번 항목 보다는 코드 양이 적다.
Hibernate + queryDSL1. JQL, Criteria
2. DataSource
3. type-safe
4. code generate
1. 다양한 reference
2. 객체를 이용한 query의 처리로 인하여, 코드양을 줄일 수 있다.
3. 프로그램 설계 및 구성 부분에 대해서 장점을 갖는다. (DDD와 같은 객체 지향적 구성 가능)
4. Table의 변경 또는 DB의 변경에 유연한 장점을 갖고 있다.
5. 오타가 발생할 수 없는 type-safe 한 query를 작성할 수 있다.
6. sql query와 비슷한 문법으로, 학습에 도움을 줄 수 있다.
1. 학습시간의 소요
2. 단순 CRUD에 대한 코드양 증가
2. 설정이 까다롭다.
Hibernate + JPA + queryDSL + Spring Data JPA
1. JQL, Criteria
2. DataSource
3. type-safe
4. code generate
1. JPA - java 표준
2. 객체를 이용한 query의 처리로 인하여, 코드양을 줄일 수 있다.
3. 프로그램 설계 및 구성 부분에 대해서 장점을 갖는다. (DDD와 같은 객체 지향적 구성 가능)
4. Table의 변경 또는 DB의 변경에 유연한 장점을 갖고 있다.
5. 오타가 발생할 수 없는 type-safe 한 query를 작성할 수 있다.
6. sql query와 비슷한 문법으로, 학습에 도움을 줄 수 있다.
7. CUD, select 문의 코딩양이 현격하게 줄어든다.
8. Hibernate 코드 역시 사용 가능하고 유연한 방법으로 대처가 가능하다.
9. Repository Interface code에 의한 가독성 향상
10. Spring @MVC의 @InitBinder와의 연동이 가능하기 때문에, Converter를 작성하는 시간을 줄일 수 있다.
1. 학습 시간의 소요
2. 설정이 까다롭다.
3. repository 객체를 두개를 만드는 것이 필요하다. (repository, repositorysupport)

myBatis (iBatis)1. Native Query
2. DataSource
3. ibatis-spring 이용
1. 국내의 많은 사용자
2. sql query의 관리를 하는 것이 가능하다.
1. 객체가 아닌 VO type의 이용으로 인한, 프로그램 architecture의 발전 가능성이 낮아짐
2. java 언어 뿐 아니라, sql 로의 확장으로 인하여 관리 코드가 늘어남

지금 전 이정도로 정리를 해봤는데, 다른 분들은 어떻게 정리를 할 수 있을까요? 각 방법에 대한 장/단점을 파악하는 것이 중요합니다. 적어도 이곳에 있는 분들만이라도요.
그리고, 만약에 외부 Project에 참여하게 되는 경우에는, 그 Project에 맞는 개발 방법을 이용해서 개발을 하는 것이 중요합니다.


Domain Framework 구성시의 pom.xml 구성

각각 Spring을 이용한 Domain Framework를 사용시의 pom.xml의 구성을 한번 알아보도록 하겠습니다. 
먼저 DataSource는 기본적으로 BoneCP를 사용합니다. BoneCP를 사용하는 경우, pom.xml은 다음과 같이 구성이 되어야지 됩니다. 

    <dependency>
      <groupId>com.jolbox</groupId>
      <artifactId>bonecp</artifactId>
      <version>0.7.1.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>com.google.guava</groupId>
      <artifactId>guava</artifactId>
      <version>14.0</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.7.2</version>
    </dependency>

Spring JdbcTemplate
: spring core, spring bean, spring jdbc, spring tx 를 이용합니다. 

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
    </dependency>

Spring + Hibernate 
: spring core, spring bean, spring jdbc, spring transaction, spring orm + hibernate core

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
        </dependency>

Spring + Hibernate + queryDSL
: spring core, spring jdbc, spring transaction, spring orm, spring context, spring context support + hibernate core + querydsl apt, querydsl query, querydsl jpa
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>com.mysema.querydsl</groupId>
            <artifactId>querydsl-apt</artifactId>
        </dependency>
        <dependency>
            <groupId>com.mysema.querydsl</groupId>
            <artifactId>querydsl-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>com.mysema.querydsl</groupId>
            <artifactId>querydsl-sql</artifactId>
        </dependency>


Spring + Hibernate + queryDSL + Spring Data JPA
: spring core, spring jdbc, spring transaction, spring orm, spring context, spring context support + hibernate core, hibernate-entitymanagement + querydsl apt, querydsl query, querydsl jpa + spring data jpa

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
        </dependency>
        <dependency>
            <groupId>com.mysema.querydsl</groupId>
            <artifactId>querydsl-apt</artifactId>
        </dependency>
        <dependency>
            <groupId>com.mysema.querydsl</groupId>
            <artifactId>querydsl-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>com.mysema.querydsl</groupId>
            <artifactId>querydsl-sql</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
        </dependency>

Spring + myBatis
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.1.1</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.1.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
        </dependency>

자, 지금까지 같이 공부했던 모든 Persistence Framework들의 pom 정보를 알아보셨습니다. 이제 마지막으로 Web Application에서의 데이터의 흐름을 한번 알아보도록 하겠습니다. 

Web Application에서의 데이터의 흐름 

Domain Model을 이용해서 Web Application을 구성하는 방법은 두가지가 있습니다. 원칙을 지키고자 하는 Pure Domain Model과 Domain Model의 자유로운 사용이 특징인 Domain Model Everywhere입니다. 
먼저 Domain Model Everywhere에 대해서 알아보도록 하겠습니다. 

Domain Model Everywhere





Repository, Service, Controller, View가 모두 Entity Model을 가지고 동작하는 방식입니다. 이 방식은 Domain의 Entity 객체가 Repository 뿐 아니라, Controller, View에 표현되는 방법까지 가지게 되게 됩니다. 이렇게 되면 Entity Model이 매우 커지게 됩니다. 그리고 객체의 "단일책임원칙"을 위반하게 되는 단점을 가지고 있습니다. 이 방법의 장단은 다음과 같습니다. 

장점 :
# 개발하기에 빠르고 편리함

단점 : 
# 복잡한 View의 표현이 매우 힘듭니다.
# Domain Model에서 View Logic이 포함되기 때문에 Domain Model의 순수성이 떨어지고 객체의 단일 책임원칙을 위반하게 됩니다.
# REST 서버와 같이 외부와의 통신 API에 사용하게 되는 경우에는 Domain Model이 변경되면 API가 바뀌게 되기 때문에 큰 문제를 야기할 수 있습니다.

장점보다는 단점이 좀더 많아보입니다. 보시면 전에 제가 .NET으로 만든 mobile framework가 바로 이 모습입니다. 원칙상으로는 다음 방법을 더 권장하는 편입니다. 


Pure Domain Model


Domain Model은 서비스와 Repository에서만 사용하고, Controller와 View에서는 DTO를 새로 만들어서 사용하는 방법입니다. 이는 Domain의 순수성을 지키게 되는 큰 장점을 가지고 있습니다. View에서만 DTO를 사용하는 것이 BL의 변화에 따른 View의 변경을 격리할 수 있는 좋은 방법이 됩니다. 

장점 : 
# 순수한 Domain Model - 객체지향적인 OOP 모델

단점
# DTO를 따로 만드는 것이 귀찮고, 성가시고, 괴롭다.
# DTO는 또 다른 중복 코드를 만들어낸다. 
# DTO와 Domain Model간의 Convert를 따로 만들어줘야지 된다. 
# anti-pattern 중 하나입니다. 사용하지 않아야지 된다고들 이야기합니다.

Domain Model Everywhere pattern의 경우에는 anti-pattern이라고도 말하는 사람이 있을정도로 호불호가 매우 강하게 갈리는 pattern중 하나입니다. 개인적으로도 최대한 Pure Domain Model을 이용해서 개발하는 것이 좋다고 생각합니다. 



............................................................................ 현실은 ? OTL

지금까지 개발을 해본 결과. 다음과 같은 상황에서는 반드시 DTO를 사용해야지 됩니다. 

1. REST 서버와 같은 API의 response.
: Domain Model은 자주 바뀔 수 있습니다. 그렇지만, client와 통신을 하게 되는 API의 response는 바뀌면 문제가 생기게 됩니다. 따라서 이 둘은 반드시 분리를 해야지 됩니다.

2. 여러 Domain Model이 결합되어서 만들어지는 새로운 View에 대한 DTO
: View가 너무너무나 복잡해서 서로간에 연관성이 없는 Domain Model을 response로 보내줘야지 되는 경우에는 DTO를 만드는 것이 좋습니다. 

이 두가지 경우를 제외하고..... DTO를 모두 만드는 것은 다음과 같은 문제가 발생합니다. 

1. 객체가 너무 많이 만들어집니다. 지금 DataWindow의 package와 같이 각 SP의 숫자만큼의 package같이 객체들이 구성되게 됩니다. 이는 객체의 naming rule 및 관리가 매우 힘들어지는 결과를 가지고 옵니다.
2. 많이 만들어진 객체 숫자 만큼의 Converter가 필요합니다. Domain Model을 DTO로 바꿔주고 DTO를 Domain Model로 바꿔주는 Convert 숫자가 필요하게 됩니다.
3. 위 이유로 관리 포인트가 3개로 늘어나게 됩니다. - Domain Model, DTO, Converter

>> 배보다 배꼽이 더 큰 사태가 발생할 수 있습니다. Domain Model Everywhere가 절대로 좋은 것은 아닙니다. 그렇지만 개발 시간과 관리 포인트를 생각해서 Domain Model Everywhere로 만들고, 그 객체들을 차츰차츰 DTO로 변환시켜가는 과정이 Application을 더욱더 깔끔하게 만드는 과정이 되게 된다고 생각합니다.


결론입니다. 

# 처음에는 Domain Model Everywhere로 Project를 시작합니다.
# Domain Model로 처리하기 힘든 경우에는 DTO를 사용해서 객체의 변환을 합니다.
# 최대한 Pure Domain Model을 유지하기 위해서 계속 노력합니다.

* Domain Model Everywhere를 지원하기 위해서 Spring은 JPA Model Object를 위한 OpenEntityManagerInViewFilter와 Hibernate를  위한 OpenSessionInViewFilter를 지원하고 있습니다. 

지금까지 Domain Model과 Persistence Layer간의 연결에 대해서 알아봤습니다. Domain Layer는 Business Logic이 표현되는 가장 중요한 영역입니다. 그리고 이에 대한 다양한 표현 방법 및 Spring의 사용방법에 대해서 알아봤습니다. 이제 다음 시간부터는 Controller, View를 한번 알아보도록 하겠습니다. 이제 우리가 매일 보는 web page를 만드는 법을 알아보도록 하겠습니다.


저작자 표시 비영리 변경 금지
신고
Posted by xyzlast Y2K

* 사내 강의용으로 사용한 자료를 Blog에 공유합니다. Spring을 이용한 Web 개발에 대한 전반적인 내용에 대해서 다루고 있습니다.



지금까지 우리는 Template-callback 구조의 SqlExecutor와 Connection을 처리하는 ConnectionFactory를 이용한 Dao 객체들을 구성하였습니다. 지금까지 만든 Dao 객체들을 Spring에서 제공하는 Jdbc객체들을 이용해서 변환시키는 과정을 한번 알아보도록 하겠습니다. 

Spring JDBC를 이용한 Dao 의 개발

Spring JDBC는 지금까지 이야기한 모든 기능들이 다 포함되어있습니다.
# Template, callback 구조
# DataSource를 이용한 ConnectionFactory 구현
# Checked Exception을 Runtime Exception으로 변경

먼저, maven을 이용해서 spring jdbc를 추가하도록 합니다. 

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>3.2.0.RELEASE</version>
</dependency>

먼저, DataSource를 구성합니다. DataSource는 기존 ConnectionFactory를 대신합니다. 이는 이미 Spring JDBC에서 제공하는 객체이기 때문에 따로 구현할 필요가 없습니다. ApplicationContext에 다음 항목을 추가해주면 됩니다. 
여기서 보시면 아시겠지만, 지금 여기서 사용하는 DataSource는 DriverManagerDataSource객체이고, DataSource는 하나의 interface입니다. Spring에서 제공되는 모든 DB connection은 DataSource interface를 구현하고 있습니다. 이번에 사용한 DriverManagerDataSource는 가장 단순한 DataSource라고 할 수 있습니다.

  <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    <property name="url" value="jdbc:mysql://localhost/bookstore" />
    <property name="username" value="root" />
    <property name="password" value="qwer12#$" />
  </bean>

지금까지 개발한 BookDao를 변경합니다. BookDaoImplWithSqlExecutor로 이름을 변경시킵니다. JdbcTemplate을 이용해서 같은 기능의 코드를 작성할 예정이기 때문에 지금까지 구현된 method들을 모든 method를 interface로 따로 뽑습니다. 
구성된 interface BookDao는 다음과 같습니다. 이러한 Interface를 위주로하는 설계는 프로그램의 확장성을 높입니다. 지금 저희는 기존에 만들어진 것과 기능적으로는 완벽하게 동일한 객체를 만들어서 테스트코드를 통과시킬 예정입니다. 기존 테스트 코드가 객체 자체를 가지고 왔다면, 이제는 Interface를 가지고 오는 형식으로 변경을 시킬 예정입니다. 

public interface BookDao {
    int countAll();
    void add(Book book);
    void update(Book book);
    void delete(Book book);
    void deleteAll();
    Book get(int id);
    List<Book> getAll();
    List<Book> search(String name);
}

그리고, 변경시킨 BookDaoImplWithSqlExecutor에서 BookDao interface를 implements 해주도록 합니다. 
마지막으로 class를 추가합니다. BookDaoImplWithJdbcTemplate를 추가하고, JdbcTemplate을 사용하도록 코드를 작성합니다. 지금까지 만들었던 SqlExecutor와 설정이 너무나도 유사합니다. Spring을 통해 다음과 같이 선언하도록 합니다. 

  <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    <property name="url" value="jdbc:mysql://localhost/bookstore" />
    <property name="username" value="root" />
    <property name="password" value="qwer12#$" />
  </bean>
  
  <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"/>
  </bean>


다음은 JdbcTemplate를 이용한 BookDao 코드입니다. 기존 코드를 비교해보도록 합니다.

public class BookDaoImplWithJdbcTemplate implements BookDao {
    private JdbcTemplate jdbcTemplate;

    public JdbcTemplate getJdbcTemplate() {
        return jdbcTemplate;
    }
    
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    private Book convertToBook(ResultSet rs) throws SQLException {
        Book book = new Book();
        book.setId(rs.getInt("id"));
        book.setName(rs.getString("name"));
        book.setAuthor(rs.getString("author"));
        java.util.Date date = new java.util.Date(rs.getTimestamp("publishDate").getTime());
        book.setPublishDate(date);
        book.setComment(rs.getString("comment"));
        book.setStatus(BookStatus.get(rs.getInt("status")));
        int rentUserId = rs.getInt("rentUserId");
        if(rentUserId == 0) {
            book.setRentUserId(null);
        }
        else {
            book.setRentUserId(rentUserId);
        }
        return book;
    }
    
    private Book convertToBook(Map<String, Object> rs) {
        Book book = new Book();
        book.setId((int) rs.get("id"));
        book.setName((String) rs.get("name"));
        book.setAuthor((String) rs.get("author"));
        book.setPublishDate((Timestamp) rs.get("publishDate"));
        book.setComment((String) rs.get("comment"));
        book.setStatus(BookStatus.get((int) rs.get("status")));
        return book;
    }
    @Override
    public void add(final Book book) {      
        this.jdbcTemplate.update("insert books(id, name, author, publishDate, comment, status, rentUserId) values(?, ?, ?, ?, ?, ?, ?)", 
                book.getId(), book.getName(), book.getAuthor(), book.getPublishDate(), book.getComment(), book.getStatus().intValue(), book.getRentUserId());
    }
    @Override
    public Book get(final int id) {
        return this.jdbcTemplate.queryForObject("select id, name, author, publishDate, comment, status, rentUserId from books where id=?", new Object[] { id}, 
                new RowMapper<Book>() {
            @Override
            public Book mapRow(ResultSet rs, int rowNum)
                    throws SQLException {
                return convertToBook(rs);
            }
        });
    }
    @Override
    public List<Book> search(final String name) {
        List<Book> books = new ArrayList<>();
        String query = "select id, name, author, publishDate, comment, status, rentUserId from books where name like '%" + name +"%'";
        List<Map<String, Object>> rows = getJdbcTemplate().queryForList(query);
        for(Map<String, Object> row : rows) {
            books.add(convertToBook(row));
        }
        return books;
    }
    @Override
    public int countAll() {
        return this.jdbcTemplate.queryForInt("select count(*) from books");
    }
    @Override
    public void update(final Book book) {
        this.jdbcTemplate.update("update books set name=?, author=?, publishDate=?, comment=?, status=?, rentUserId=? where id=?",
                book.getName(), book.getAuthor(), book.getPublishDate(), book.getComment(), book.getStatus().intValue(), book.getRentUserId(), book.getId());
    }
    @Override
    public List<Book> getAll() {
        List<Book> books = new ArrayList<>();
        List<Map<String, Object>> rows = getJdbcTemplate().queryForList("select id, name, author, publishDate, comment, status, rentUserId from books");
        for(Map<String, Object> row : rows) {
            books.add(convertToBook(row));
        }
        return books;
    }
    @Override
    public void deleteAll() {
        this.jdbcTemplate.update("delete from books");
    }

    @Override
    public void delete(Book book) {
        this.jdbcTemplate.update("delete from books where id = ?", book.getId());
    }
}


매우 비슷한 코드가 나오게 됨을 알 수 있습니다. 이와 같이 Spring을 사용해서 코드를 만드는 과정 자체는 좋은 코드를 만드는 과정으로 이끌어가게 됩니다. 결론만 나오는 것 같아도, 기본적으로 이러한 과정을 무조건 거치게 만드니까요. 

Spring Jdbc는 다음 method를 주로 사용하게 됩니다. 

# queryForObject : 객체 한개를 return 하는 method. ResultMap<T>를 재정의 해서 사용
# update : insert, update, delete query에서 사용. return값이 존재하지 않고 query를 바로 반영할 때 사용
# queryForList : select에 의해서 List return이 발생할 때 사용. List<Map<String, Object>>가 return 되어, 객체로 변경하거나 map을 읽어서 사용 가능
# queryForInt, queryForLong, queryForDate : query 결과에 따른 값을 return 받을 때 사용.

위 method를 이용해서 UserDao, HistoryDao에 대한 JdbcTemplate 구현 코드를 모두 작성해주세요. 

모든 객체를 구현한다면 다음과 같은 코드 구조를 가지게 될 것입니다. 



각 Dao Impl 들의 테스트 코드 역시 2개씩 존재하게 됩니다. 그리고, 그에 따른 applicationContext.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:context="http://www.springframework.org/schema/context"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">
  <bean id="sqlExecutor" class="com.xyzlast.bookstore02.dao.SqlExecutor">
    <property name="connectionFactory" ref="connectionFactory" />
  </bean>
  <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"/>
  </bean>
  <bean id="connectionFactory" class="com.xyzlast.bookstore02.dao.ConnectionFactory"
    init-method="init">
    <property name="connectionString" value="jdbc:mysql://localhost/bookstore" />
    <property name="driverName" value="com.mysql.jdbc.Driver" />
    <property name="username" value="root" />
    <property name="password" value="qwer12#$" />
  </bean>
  <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    <property name="url" value="jdbc:mysql://localhost/bookstore" />
    <property name="username" value="root" />
    <property name="password" value="qwer12#$" />
  </bean>
  
  <bean id="bookDaoImplWithJdbcTemplate" class="com.xyzlast.bookstore02.dao.BookDaoImplWithJdbcTemplate">
    <property name="jdbcTemplate" ref="jdbcTemplate"/>
  </bean>
  <bean id="bookDaoImplWithSqlExecutor" class="com.xyzlast.bookstore02.dao.BookDaoImplWithSqlExecutor">
    <property name="sqlExecutor" ref="sqlExecutor"/>
  </bean>
  <bean id="userDaoImplWithJdbcTemplate" class="com.xyzlast.bookstore02.dao.UserDaoImplWithJdbcTemplate">
    <property name="jdbcTemplate" ref="jdbcTemplate"/>
  </bean>
  <bean id="userDaoImplWithSqlExecutor" class="com.xyzlast.bookstore02.dao.UserDaoImplWithSqlExecutor">
    <property name="sqlExecutor" ref="sqlExecutor"/>
  </bean>  
  <bean id="historyDaoImplWithJdbcTemplate" class="com.xyzlast.bookstore02.dao.HistoryDaoImplWithJdbcTemplate">
    <property name="jdbcTemplate" ref="jdbcTemplate"/>
  </bean>
  <bean id="historyDaoImplWithSqlExecutor" class="com.xyzlast.bookstore02.dao.HistoryDaoImplWithSqlExecutor">
    <property name="sqlExecutor" ref="sqlExecutor"/>
  </bean>
  
  <bean id="userService" class="com.xyzlast.bookstore02.services.UserServiceImpl">
    <property name="bookDao" ref="bookDaoImplWithJdbcTemplate"/>
    <property name="userDao" ref="userDaoImplWithJdbcTemplate"/>
    <property name="historyDao" ref="historyDaoImplWithJdbcTemplate"/>
  </bean>
  <bean id="bookService" class="com.xyzlast.bookstore02.services.BookServiceImpl">
    <property name="bookDao" ref="bookDaoImplWithJdbcTemplate"/>
  </bean>
</beans>


applicationContext.xml의 내용이 점점 복잡해지기 시작합니다. 이렇게 복잡해져가는 applicationContext.xml 의 정리 방법을 한번 알아보도록 하겠습니다. 

properties file을 이용한 중복 데이터의 설정파일화

구성된 applicationContext.xml에서 중복된 데이터가 지금 존재합니다. ConnectionFactory와 DataSource가 바로 그것인데요. 중복되는 String일 뿐 아니라, 환경의 구성에 따라 달리 되는 환경상의 설정이기 때문에 applicationContext.xml과는 달리 관리가 되는 것이 좋을 것 같습니다. 따로 spring.properties 파일을 작성하도록 합니다. 파일 내용은 다음과 같습니다. 

connect.driver=com.mysql.jdbc.Driver
connect.url=jdbc:mysql://localhost/bookstore
connect.username=root
connect.password=qwer12#$

그리고, applicationContext 파일에서 namespace 항목에서 context를 추가합니다. 
context 항목을 추가후, applicationContext에 다음 항목을 추가하고 변경하도록 합니다. 



<?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:context="http://www.springframework.org/schema/context"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">
  <context:property-placeholder location="spring.property"/>
  <bean id="sqlExecutor" class="com.xyzlast.bookstore02.dao.SqlExecutor">
    <property name="connectionFactory" ref="connectionFactory" />
  </bean>
  <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"/>
  </bean>
  <bean id="connectionFactory" class="com.xyzlast.bookstore02.dao.ConnectionFactory"
    init-method="init">
    <property name="connectionString" value="${connect.url}" />
    <property name="driverName" value="${connect.driver}" />
    <property name="username" value="${connect.username}" />
    <property name="password" value="${connect.password}" />
  </bean>
  <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="${connect.driver}" />
    <property name="url" value="${connect.url}" />
    <property name="username" value="${connect.username}" />
    <property name="password" value="${connect.password}" />
  </bean>

${PropertyName} 이라는 표현을 통해서, property 파일내에 있는 속성 값을 applicationContext에 등록하게 되는 것을 알 수 있습니다. 이와 같이 property file은 중복되는 applicationContext의 설정을 통합 관리하거나, 환경이나 build path에 종속적이고 개발자 PC에 종속적인 항목들을 관리할 때 주로 사용됩니다. 그리고 ${PropertyName} 표현은 spring, jsp 등에서 객체에 직접 접근할 때 사용되는 표현법으로 자주 나오게 됩니다. 꼭 익혀두도록 합시다. 


annotation을 이용한 bean의 자동 등록

기존의 bean들의 등록은 applicationContext.xml을 통해서 명시적으로 해주고 있습니다. 그리고, applicationContext를 통해서 객체를 직접 가지고 오는 코드를 구성해서 테스트를 하고 있습니다. 전에 소개되었던 @Autowired를 이용하면 applicationContext.xml을 간소화 시킬 수 있습니다.
먼저, Spring에서 bean들의 종류를 나누는 기준에 대해서 알아보겠습니다. Spring에서 보는 bean의 기준에 따라 적용되는 @Autowired annotation이 달라집니다. 

종류설명
@Component일반적인 Util 객체에 사용됩니다. 지금 구성되는 bookstore에서는 ConnectionFactory가 이에 해당됩니다.
@RepositoryDB에 접근되는 객체에 사용됩니다. 일반적으로 dao 객체에 적용이 됩니다.
@ServiceBusiness Logic이 구성되는 Service 객체에 사용됩니다. Business Logic은 여러개의 @Repository의 구성으로 만들어지게 됩니다. Service에 대해서는 다음에 좀더 깊숙히 들어가보도록 하겠습니다.
@ControllerWeb에서 사용되는 객체입니다. Url Request가 연결되는 객체를 지정할 때 사용됩니다. Spring Controller 때 깊게 들어가보도록 하겠습니다.
@Value위 annotation과는 성격이 조금 다릅니다. 다른 annotation은 객체에 할당이 되는 형태이지만, Value annotation은 property의 값을 지정할 때 사용됩니다. property file의 값을 대응시킬때 사용됩니다.


위의 기준으로 지금까지 만들어진 객체들을 나누면 다음과 같습니다.

종류annotation
ConnectionFactory@Component
SqlExecutor@Component
BookDaoImplWithJdbcTemplate@Repository
BookDaoImplWithSqlExecutor@Repository
UserDaoImplWithJdbcTemplate@Repository
UserDaoImplWithSqlExecutor@Repository
HistoryDaoImplWithJdbcTemplate@Repository
HistoryDaoImplWithSqlExecutor@Repository

객체들의 class 선언부에 각 annotation을 적용하고, 자동 등록될 ConnectionFactory와 SqlExecutor에 모두 @Autowired를 달아주도록 합시다. BookDaoImplWithSqlExecutor의 코드는 다음과 같이 변경됩니다.

@Repository
public class BookDaoImplWithSqlExecutor implements BookDao {
    @Autowired
    private SqlExecutor sqlExecutor;
    
    public SqlExecutor getSqlExecutor() {
        return sqlExecutor;
    }

    public void setSqlExecutor(SqlExecutor sqlExecutor) {
        this.sqlExecutor = sqlExecutor;
    }

    private Book convertToBook(ResultSet rs) throws SQLException {
        Book book = new Book();
        book.setId(rs.getInt("id"));
        book.setName(rs.getString("name"));
        book.setAuthor(rs.getString("author"));
        java.util.Date date = new java.util.Date(rs.getTimestamp("publishDate").getTime());
        book.setPublishDate(date);
        book.setComment(rs.getString("comment"));
        book.setStatus(com.xyzlast.bookstore02.entities.BookStatus.get(rs.getInt("status")));
        int rentUserId = rs.getInt("rentUserId");
        if(rentUserId == 0) {
            book.setRentUserId(null);
        }
        else {
            book.setRentUserId(rentUserId);
        }
        return book;
    }
    
    @Override
    public int countAll() {
        return (int) sqlExecutor.execute(new ExecuteSelectQuery() {
            @Override
            public Object execute(Connection conn, PreparedStatement st, ResultSet rs) {
                try {
                    st = conn.prepareStatement("select count(*) from books");
                    rs = st.executeQuery();
                    rs.next();
                    return rs.getInt(1);
                }
                catch(SQLException ex) {
                    throw new IllegalArgumentException(ex);
                }
            }
        });
    }

    @Override
    public void add(final Book book) {
        sqlExecutor.execute(new ExecuteUpdateQuery() {
            @Override
            public void execute(Connection conn, PreparedStatement st) {
                try {
                    st = conn.prepareStatement("insert books(id, name, author, publishDate, status, comment, rentUserId) values(?, ?, ?, ?, ?, ?, ?)");
                    st.setInt(1, book.getId());
                    st.setString(2, book.getName());
                    st.setString(3, book.getAuthor());
                    st.setTimestamp(4, new Timestamp(book.getPublishDate().getTime()));
                    st.setInt(5, book.getStatus().intValue());
                    st.setString(6, book.getComment());
                    if(book.getRentUserId() == null) {
                        st.setNull(7, Types.INTEGER);
                    }
                    else {
                        st.setInt(7, book.getRentUserId());
                    }
                    st.executeUpdate();
                }
                catch(SQLException ex) {
                    throw new IllegalArgumentException(ex);
                }
            }
        });
    }

    @Override
    public void update(final Book book) {
        sqlExecutor.execute(new ExecuteUpdateQuery() {
            @Override
            public void execute(Connection conn, PreparedStatement st) {
                try {
                    st = conn.prepareStatement("update books set name=?, author=?, publishDate=?, status=?, comment=?, rentUserId=? where id=?");
                    st.setString(1, book.getName());
                    st.setString(2, book.getAuthor());
                    st.setTimestamp(3, new Timestamp(book.getPublishDate().getTime()));
                    st.setInt(4, book.getStatus().intValue());
                    st.setString(5, book.getComment());
                    if(book.getRentUserId() == null) {
                        st.setNull(6, Types.INTEGER);
                    }
                    else {
                        st.setInt(6, book.getRentUserId());
                    }
                    st.setInt(7, book.getId());
                    st.executeUpdate();
                } catch(SQLException ex) {
                    throw new IllegalArgumentException(ex);
                }
            }
        });
    }

    @Override
    public void delete(final Book book) {
        sqlExecutor.execute(new ExecuteUpdateQuery() {
            @Override
            public void execute(Connection conn, PreparedStatement st) {
                try {
                    st = conn.prepareStatement("delete from books where id = ?");
                    st.setInt(1, book.getId());
                } catch(SQLException ex) {
                    throw new IllegalArgumentException(ex);
                }
            }
        });
    }

    @Override
    public void deleteAll() {
        sqlExecutor.execute(new ExecuteUpdateQuery() {
            @Override
            public void execute(Connection conn, PreparedStatement st) {
                try {
                    st = conn.prepareStatement("delete from books");
                    st.executeUpdate();
                } catch(SQLException ex) {
                    throw new IllegalArgumentException(ex);
                }
            }
        });
    }

    @Override
    public Book get(final int id) {
        return (Book) sqlExecutor.execute(new ExecuteSelectQuery() {
            @Override
            public Object execute(Connection conn, PreparedStatement st, ResultSet rs) {
                try {
                    st = conn.prepareStatement("select id, name, author, publishDate, comment, status, rentUserId from books where id = ?");
                    st.setInt(1, id);
                    rs = st.executeQuery();
                    rs.next();
                    return convertToBook(rs);
                } catch(SQLException ex) {
                    throw new IllegalArgumentException(ex);
                }
            }
        });
    }

    @SuppressWarnings("unchecked")
    @Override
    public List<Book> getAll() {
        return (List<Book>) sqlExecutor.execute(new ExecuteSelectQuery() {
            @Override
            public Object execute(Connection conn, PreparedStatement st, ResultSet rs) {
                try {
                    st = conn.prepareStatement("select id, name, author, publishDate, comment, status, rentUserId from books");
                    rs = st.executeQuery();
                    List<Book> books = new ArrayList<>();
                    while(rs.next()) {
                        books.add(convertToBook(rs));
                    }
                    return books;
                }catch(SQLException ex) {
                    throw new IllegalArgumentException(ex);
                }
            }
        });
    }

    @SuppressWarnings("unchecked")
    @Override
    public List<Book> search(final String name) {
        return (List<Book>) sqlExecutor.execute(new ExecuteSelectQuery() {
            @Override
            public Object execute(Connection conn, PreparedStatement st, ResultSet rs) {
                try {
                    st = conn.prepareStatement("select id, name, author, publishDate, comment, status, rentUserId from books where name like '%" + name + "%'");
                    rs = st.executeQuery();
                    List<Book> books = new ArrayList<>();
                    while(rs.next()) {
                        books.add(convertToBook(rs));
                    }
                    return books;
                }catch(SQLException ex) {
                    throw new IllegalArgumentException(ex);
                }
            }
        });
    }
}

다른 코드들 역시 같이 변경해보도록 합니다. JdbcTemplate을 사용하는 객체 역시 Property의 jdbcTemplate에 @Autowired를 달아주도록 합니다. 

그리고, applicationContext.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:context="http://www.springframework.org/schema/context"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">

  <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"/>
  </bean>
  <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="${connect.driver}" />
    <property name="url" value="${connect.url}" />
    <property name="username" value="${connect.username}" />
    <property name="password" value="${connect.password}" />
  </bean>
  <context:property-placeholder location="classpath:spring.property"/>
  <context:component-scan base-package="com.xyzlast.bookstore02.dao"/>
</beans>

지금까지 만들어진 코드가 엄청나게 많이 바뀌게 됩니다. 이렇게 된 후에 다음 테스트 코드를 작성해서 ApplicationContext.xml을 통해 객체가 어떻게 구성이 되었는지 알아보도록 하겠습니다.

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContextWithAutowired.xml")
public class ApplicationContextTest {
    @Autowired
    ApplicationContext applicationContext;

    @Test
    public void getBeansInApplicationContext() {
        String[] beanNames = applicationContext.getBeanDefinitionNames();
        for(String beanName : beanNames) {
            System.out.println(beanName + " : " + applicationContext.getBean(beanName));
        }
    }
}


jdbcTemplate : org.springframework.jdbc.core.JdbcTemplate@5d63838
dataSource : org.springframework.jdbc.datasource.DriverManagerDataSource@3304e786
org.springframework.context.support.PropertySourcesPlaceholderConfigurer#0 : org.springframework.context.support.PropertySourcesPlaceholderConfigurer@6fc2895
bookDaoImplWithJdbcTemplate : com.xyzlast.bookstore02.dao.BookDaoImplWithJdbcTemplate@14cc51c8
bookDaoImplWithSqlExecutor : com.xyzlast.bookstore02.dao.BookDaoImplWithSqlExecutor@720d2c22
connectionFactory : com.xyzlast.bookstore02.dao.ConnectionFactory@3ecca6ad
historyDaoImplWithJdbcTemplate : com.xyzlast.bookstore02.dao.HistoryDaoImplWithJdbcTemplate@6dd2c810
sqlExecutor : com.xyzlast.bookstore02.dao.SqlExecutor@294ccac4
userDaoImplWithJdbcTemplate : com.xyzlast.bookstore02.dao.UserDaoImplWithJdbcTemplate@70941f0a
userDaoImplWithSqlExecutor : com.xyzlast.bookstore02.dao.UserDaoImplWithSqlExecutor@c820344
org.springframework.context.annotation.internalConfigurationAnnotationProcessor : org.springframework.context.annotation.ConfigurationClassPostProcessor@2ba46bc6
org.springframework.context.annotation.internalAutowiredAnnotationProcessor : org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor@379faa8c
org.springframework.context.annotation.internalRequiredAnnotationProcessor : org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor@5375e9db
org.springframework.context.annotation.internalCommonAnnotationProcessor : org.springframework.context.annotation.CommonAnnotationBeanPostProcessor@624c53ab
org.springframework.context.annotation.ConfigurationClassPostProcessor.importAwareProcessor : org.springframework.context.annotation.ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor@2af9150

보시면, context:component-scan을 통해서 package안에 annotation이 된 모든 객체들이 모두 ApplicationContext에 등록된 것을 알 수 있습니다. 

@Autowired는 어떻게 처리가 되는 것일까요? @Autowired는 먼저 @Autowired가 필요 없는 bean들이 먼저 등록이 된 후에 @Autowired로 property를 설정할 수 있는 객체들을 차례로 등록하게  됩니다. 지금 코드에서는 jdbcTemplate와 dataSource는 @Autowired되는 속성이 하나도 없기 때문에 먼저 ApplicationContext에 등록이 되고 나머지 객체들이 등록되고 있는 것을 알 수 있습니다. 그럼 spring은 어떻게 Autowired를 이용해서 bean들을 등록할 수 있을까요? Autowired 동작은 다음 조건 중 선행되는 조건을 확인하고 우선적으로 wired되게 됩니다. 

1. 객체 type이 동일하고, property의 이름이 bean 이름과 동일할 때
2. 객체 type이 동일 할때

여기서 문제가 될 수 있는 항목이 2번째입니다. 객체 type이 동일하지만 bean의 이름이 property랑 맞지 않는 객체가 여러개가 존재를 할 수 있습니다. 이때, Spring은 Not Unique Beans in application context 에러를 발생시키며 applicationContext.xml 로드를 실패하게 됩니다. 여러 객체가 한개의 interface를 구현해서 사용하게 되었을 때, 객체를 Autowired해서 사용하기 위해서는 사용할 객체의 이름을 Spring 규칙에 맞추어 변경한 Property 이름으로 정해줘야지 됩니다. Spring은 기본적으로 객체 이름의 첫자를 소문자로 만들어 bean 이름으로 등록하게 됩니다. 아니면 다른 방법이 있습니다. @Repository, @Component와 같은 Autowird annotation은 생성자로 객체의 자동 등록 이름을 정해줄 수 있습니다. 자동 등록 이름을 이용해서 객체를 등록하고 그 이름에 맞는 Property 이름으로 사용하는 경우 동일한 결과를 가지고 올 수 있습니다. Spring에서 이름을 만드는 규칙과 같이 이를 이해하는 것이 중요합니다. 


Summary

JdbcTemplate을 통한 Dao의 구성방법에 대해서 알아봤습니다. 그리고 applicationContext의 autowired 방법에 대해서 알아봤습니다. applicationContext의 autowired의 사용법은 잘 알아두시길 바랍니다. 객체의 type위주로 autowired되는 것을 명시하고, 그 사용법을 잘 익혀두지 않으면 실제 프로젝트에서 어떻게 사용되는지 알기가 힘들어집니다. 지금까지 구성된 BookDao, UserDao, HistoryDao를 모두 JdbcTemplate으로 구성해보시고, Autowired를 이용해서 applicationContext에 모두 등록시켜주세요. 



저작자 표시 비영리 변경 금지
신고
Posted by xyzlast Y2K
TAG java, jdbc, Spring


티스토리 툴바