잊지 않겠습니다.

23. View의 표현법 - HTML

Java 2013. 9. 13. 08:33

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


크게 View는 Html을 표시시키는 View와 Application을 이용할 때 사용되는 View. 두개로 나눌수 있습니다. 이번 장에서는 Html을 표시하는 View를 알아보도록 하겠습니다.

1. JSP & JSTL

jsp와 jstl을 사용하기 위해서는 특별한 View 설정은 필요없지만, 기본적으로 Spring에서 요구되는 View는 WEB-INF 폴더 안에 view file들을 위치시키고, client에서 직접 접근할 수 없도록 하는 것이 일반적입니다. 이때는 기본적으로 InternalResourceViewResolver를 사용해서 View 파일의 위치를 설정하도록 합니다.

  <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
    <property name="prefix" value="/WEB-INF/views/" />
    <property name="suffix" value=".jsp" />
    <property name="contentType" value="text/html; charset=UTF-8" />
    <property name="order" value="1" />
  </bean>

code base로는 다음과 같이 설정하면 됩니다. 
    @Bean
    public UrlBasedViewResolver viewResolver() {
        UrlBasedViewResolver jspViewResolver = new UrlBasedViewResolver();
        jspViewResolver.setOrder(4);
        jspViewResolver.setPrefix("/WEB-INF/view/");
        jspViewResolver.setSuffix(".jsp");
        jspViewResolver.setContentType("text/html; charset=UTF-8");
        jspViewResolver.setViewClass(JstlView.class);
        return jspViewResolver;
    }

jsp만으로는 제어문을 구성할 수 없기 때문에 jstl을 이용해서 jsp를 확장해야지 됩니다. jstl을 사용하기 위해서는 pom.xml에 다음 항목을 추가해주세요.

        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

JSTL은 다양한 tag를 지원하고 있습니다. 이는 기존 jsp에서 <%= %>에서 빈번하게 만들어지는 code들을 단순화하고 읽기 편한 간단한 언어로 만들기 위해서 제공되고 있습니다.  jsp는 다음과 같은 tag를 선언함으로서 사용할 수 있습니다. 

<%@taglib prefix="c"uri="http://java.sun.com/jsp/jstl/core"%>

1) c:out  - 객체를 출력한다.
<!--기본 문법--><c:out value="${name}"/><!--  default 속성 : 값이 없을때 기본출력값을 정의-->
<c:out value="${age}" default="Null or empty"/> 
<!-- escapeXml 속성 : 기본적으로 XML 문자를 escape하는데 Escape 하지 않으려면  false로 설정-->
<c:out value="${name}" escapeXml="false"/>

2) c:set  - 객체를 저장(셋팅)한다.
<!--기본문법-->
<c:set var="name" value="홍길동" /><!--Scope 속성 : page | request | session | application 중 1개의 값 page가 기본값-->
<c:set scope="request" target="book" property="isbn" value="300"/><!--target,property속성:  홍길동의 값을 UserModel 객체의 UserName 프로퍼티값을 설정 -->
<c:set value="홍길동" target="UserModel" property="UserName"/>

3) c:remove - 객체를 삭제한다.
<!--기본문법-->  
<c:remove  var="name" scope="request" />  

4) c:if - 조건문
<!--기본문법-->  
<c:if test="${조건}">  
    조건 만족시 이 영역을 수행  
</c:if>  

jstl에서 if문은 조금 문제가 있습니다. 그건 else가 존재하지 않는 문제인데요. 우리가 주로 사용하는 if~else 문을 갖추기 위해서는 아래의 choose문을 사용해야지 됩니다.

5) c:choose, c:when, c:otherwise - switch 문이라 생각하면된다.
<!--기본문법-->   
<c:choose>  
    <c:when test="${value == 1}">  
        value가 1이면 이 영역을 수행  
    </c:when>  
    <c:when test="${value == 2}">  
        value가 2이면 이 영역을 수행  
    </c:when>  
    <c:otherwise>  
        value가 1,2가 아니면 이 영역을 수행(기본값)  
    </c:otherwise>  
</c:choose>  

6) c:foreach - 반복문
<!--기본문법(0~9까지 출력)-->   
<c:forEach begin="0" end="9" var="i">  
    <c:out value="${i}"/>  
</c:forEach>  
<!-- step 속성 : 정의된 수만큼 증가를 시킨다.(1,3,5,7,9출력)-->  
<c:forEach var="test" begin="1" end="10" step="2" >  
     <b>${test }</b>   
</c:forEach>  

7) c:forTokens - 구분자로 반복문
<!--기본문법(변수를 ','로 구분하여 출력한다. )-->   
<c:forTokens var="alphabet" items="a,b,c,d,e,f,g,h,i,j,k" delims="," varStatus="idx" >  
     <b>${alphabet }</b>  
</c:forTokens>  


8) c:url, c:param  - URL을 처리
<!--기본문법-->   
<c:url value="index.jsp"/>  
<!-- value의 속성값이 /로 시작하면 컨텍스트를 포함한다-->  
<!--Context가 Root이라면 /Root/index.jsp로 출력-->  
<c:url value="/index.jsp"/>  
<!--context 속성 : 다른 컨텍스트로 출력하고자할때 사용-->  
<!-- /newRoot/index.jsp로 출력-->  
<c:url value="/index.jsp" context="/newRoot"/>  

9) c:import - JSP파일을 인클루드한다.
<!-- 기본 문법 -->  
<!-- partialView.jsp의 내용을 출력 -->  
<c:import url="partialView.jsp"/>  
<!-- charEncoding 속성:   인코딩에 문제가 있을 시 사용 -->  
<c:import url="UserForm.jsp" charEncoding="UTF-8"/>  

10) c:redirect - 리다이렉션
<!-- 기본 문법 -->  
<c:redirect url="http://kkams.net"/>  


11) c:catch - 예외 발생시 처리
<!-- 기본 문법 -->  
<c:catch var="err">    
    <%=10 / 0%> <!--0으로 나누면 에러 발생-->  
</c:catch>  
<!--에러 출력-->  
<c:out value="${err }" />  


다양해보이지만, 상당히 빈약한 문법과 코드를 가지고 있는 것이 JSTL입니다. 자주 사용되기도 하고, 일단 표준이기 때문에 몰라서는 안되는 View 표현 방법입니다. 앞서 Controller에서 보내지는 Model의 값을 JSTL을 이용해서 표현하게 되는 것이 일반적입니다. 

지금까지 본 jstl을 이용한 book list의 표현과 book add의 표현방법입니다. 

    @RequestMapping("book/list")
    public String listup(Model model) {
        List<Book> books = bookService.listup();
        model.addAttribute("books", books);
        return "book/list";
    }

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions"%>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
<link href="/res/css/bootstrap.min.css" rel="stylesheet" />
<link href="/res/css/sample.css" rel="stylesheet" />
<script src="/res/js/bootstrap.min.js"></script>
</head>
<h2>jstl test code 입니다.</h2><div class="example-form">
    <h3>c:forEach example code</h3>
    <spring:message code="code.message"></spring:message>
    <table class="table table-striped table-bordered table-hover">
        <thead>
            <tr>
                <th>Title</th>
                <th>status</th>
                <th>Description</th>
            </tr>
        </thead>

        <tbody>
            <c:forEach var="book" items="${books}">
                <tr>
                    <td>${book.title}</td>
                    <c:set var="status" value="일반" />
                    <c:choose>
                        <c:when test="${book.status eq 'NORMAL'}">
                            <c:set var="status" value="일반" />
                        </c:when>
                        <c:when test="${book.status eq 'RENTNOW'}">
                            <c:set var="status" value="대여중" />
                        </c:when>
                        <c:otherwise>
                            <c:set var="status" value="분실중" />
                        </c:otherwise>
                    </c:choose>
                    <td>${status }</td>
                    <td>${book.comment}</td>
                </tr>
            </c:forEach>
        </tbody>
    </table>
</div>
</body>
</html>


2. JSTL fmt를 이용한 데이터의 가공

java의 원 데이터를 html로 표시할 때, 우리는 자주 데이터의 모양을 바꿔야지 되는 일들이 발생됩니다. 특히 통화량과 날짜, 소숫점의 표시에서 가장 일반적이라고 할 수 있습니다. 자리수 단락에서 ","를 추가한다던지, 소숫점 이하의 자리수를 어떻게 표시를 하는지에 대한 문제는 Controller와 같은 기술적인 issue와는 별개로 사용자들에게는 '모든 것'이 될 수 있는 문제입니다. 이런 일은 수치데이터를 직접 바꾸는 것이 아니라 수치의 표시를 어떻게 해줄 것인지에 대한 내용입니다. View에서 이런 일들을 해주는 것이 가장 좋습니다. 

이 부분에 대해서는 issue가 있습니다. View에서 특정 데이터를 빨간색으로 보여야지 되는 action에 대한 처리를 무엇으로 보느냐에 대한 논쟁입니다. 이것은 보는 방법을 바꾸는 일이기 때문에 View에서 봐야지 된다는 의견과 보는 방법이 아닌 이것 역시 Business Logic으로 보는 견해도 있습니다. BL이기 때문에 Server Code에서 구동이 되고 테스트가 가능한 방법으로 만들어야지 된다는 것이지요. 가장 좋은 위치는 Controller 영역으로 이야기하고 있습니다. 보여지는 Model을 변경하는 것이기 때문에 가장 좋은 Layer이니까요. 개인적인 의견으로는 View에 대한 영역은 모두 View에 넘기는 것이 좋지 않나. 라는 생각입니다. 저는 개인적으로는 전자의 의견에 좀더 한표를 주고 있는 편입니다. 이 부분에 대해서는 개발자들의 취향과 그 프로젝트의 PM에 따라서 많이 바뀌게 될 내용이라고 생각됩니다. 

지금 소개하는 JSTL fmt의 경우에는 View Layer, 즉 JSP에서 보이는 방법을 바꿔주는 방법입니다. 

선언 방법은 다음과 같습니다. 

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>

선언된 데이터는 다음과 같이 사용이 가능합니다. 

<div class="example-form">
    <fieldset>
        <legend>FMT examples - Date</legend>
        <ul>
            <li><fmt:formatDate value="${date}" type="DATE" pattern="yyyy/MM/dd" /></li>
            <li><fmt:formatDate value="${date}" type="DATE" pattern="yyyy년 M월 dd일" /></li>
        </ul>
    </fieldset>
    <br />
    <fieldset>
        <legend>FMT example - Number</legend>
        <ul>
            <li>orginal : ${number}</li>
            <li><fmt:formatNumber value="${number}" groupingUsed="true" currencySymbol=","/></li>
            <li><fmt:formatNumber value="${number}" minFractionDigits="5"/></li>
            <li><fmt:formatNumber value="${number}" type="CURRENCY"/></li>
            <li><fmt:formatNumber value="234.3" pattern="△#,##0.00; ▼#,##0.00" /></li>
            <li><fmt:formatNumber value="-1234.56" pattern="△#,##0.00; ▼#,##0.00" /></li>
            <li><fmt:formatNumber value="0.99" type="percent"/></li>
        </ul>
    </fieldset>
</div>


위 HTML은 다음과 같이 표시가 됩니다. 



3. tiles

Tiles는 기본적으로 JSTL을 이용하지만, JSTL에서 중복되는 html code를 최소화하기 위해서 만들어진 Template Engine입니다. Tile는 기본적인 Html View 가 Composite View Pattern으로 동작할 때, 중복되는 코드들을 공통 요소로 뽑아서 이용가능합니다. 다음은 Tile에 대한 기본 개념의 정의입니다. 




일반적인 Html Page의 기본 구조입니다. 이 구조에서 페이지가 바뀌게 된다면 Body부분의 Content는 계속해서 바뀌게 되지만, Menu, Header, Footer들은 크게 바뀌지 않는 것이 일반적입니다. 
따라서, 각 부분을 재사용할 수 있다면 코드의 양은 매우 줄어들고, 유지보수에 용의함을 알 수 있습니다. 


tiles를 추가하기 위해서는 pom.xml에 다음 항목을 추가해주세요. 

        <dependency>
            <groupId>org.apache.tiles</groupId>
            <artifactId>tiles-jsp</artifactId>
            <version>3.0.1</version>
        </dependency>

tiles는 tag를 제공하고 있으며, tag를 이용해서 tiles page를 작성할 수 있습니다.  먼저 layout page를 알아보도록 하겠습니다. 

<%@ taglib prefix="tiles" uri="http://tiles.apache.org/tags-tiles"%>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title><tiles:insertAttribute name="title"/></title>
<link href="/res/css/bootstrap.min.css" rel="stylesheet" />
<link href="/res/css/sample.css" rel="stylesheet" />
<script src="/res/js/bootstrap.min.js"></script>
</head>
<body>
    <tiles:insertAttribute name="content"/>
</body>
</html>

기본적인 content의 attribute를 지정하고, 그 attribute에 원하는 값을 넣어주는 것이 가능합니다. attribute는 String 문자열 또는 jsp 파일이 될 수 있습니다.  이러한 attribute와 view name을 설정하기 위해서 tiles는 설정 xml을 가지게 되는데, 이 xml은 다음과 같이 구성될 수 있습니다. 

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE tiles-definitions PUBLIC
       "-//Apache Software Foundation//DTD Tiles Configuration 3.0//EN"
       "http://tiles.apache.org/dtds/tiles-config_3_0.dtd">
<tiles-definitions>
    <definition name="main-layout" template="/WEB-INF/tiles/layouts/main-layout.jsp">
        <put-attribute name="title" value=""/>
        <put-attribute name="content" value=""/>
    </definition>
    <definition name="book/list" extends="main-layout">
        <put-attribute name="title" value="BOOK LIST"/>
        <put-attribute name="content" value="/WEB-INF/tiles/book/list.jsp"/>
    </definition>   
    <definition name="book/add" extends="main-layout">
        <put-attribute name="title" value="Add BOOK"/>
        <put-attribute name="content" value="/WEB-INF/tiles/book/add.jsp"/>
    </definition> 
</tiles-definitions>

여기서 각각의 definition name은 ModelAndView의 view name으로 이용됩니다. extends로 선언된 View를 Template로 이용하고, 각각의 View의 조각(tile)을 붙이는 형식으로 사용할 수 있습니다. 
tiles를 사용하기 위해서는 TilesViewResolver를 applicationContext에 선언해줘야지 됩니다. 일반적으로 controller-servlet.xml에서 구성합니다.  code base configuration은 다음과 같이 설정해줍니다. 

    @Bean
    public TilesConfigurer tilesConfigurer() {
        TilesConfigurer tilesConfigurer = new TilesConfigurer();
        tilesConfigurer.setDefinitions(new String[] { "/WEB-INF/tiles-configs.xml" });
        return tilesConfigurer;
    }

    @Bean
    public TilesViewResolver tilesViewResolver() {
        TilesViewResolver tilesViewResolver = new TilesViewResolver();
        tilesViewResolver.setOrder(1);
        return tilesViewResolver;
    }

2개의 @Bean을 설정해주는 것을 알 수 있습니다. 

보시면 <tiles:insertAttribute> tag로 구성된 부분에 tiles.xml 파일에서 지정한 tile이 들어가서 전체 웹페이지를 구성하게 되는 것을 알 수 있습니다. 매우 자주 쓰이고 있는 View Teamplate입니다. 전체 코드의 양을 줄일 수 있고, 전체 Framework 등의 문제를 쉽게 해결할 수 있는 방법이기도 합니다. 

tiles를 사용하시면 이제 book/list.jsp는 다음과 같이 변경이 될 수 있습니다.

<h2>jstl test code 입니다.</h2><div class="example-form">
    <h3>c:forEach example code</h3>
    <spring:message code="code.message"></spring:message>
    <table class="table table-striped table-bordered table-hover">
        <thead>
            <tr>
                <th>Title</th>
                <th>status</th>
                <th>Description</th>
            </tr>
        </thead>

        <tbody>
            <c:forEach var="book" items="${books}">
                <tr>
                    <td>${book.title}</td>
                    <c:set var="status" value="일반" />
                    <c:choose>
                        <c:when test="${book.status eq 'NORMAL'}">
                            <c:set var="status" value="일반" />
                        </c:when>
                        <c:when test="${book.status eq 'RENTNOW'}">
                            <c:set var="status" value="대여중" />
                        </c:when>
                        <c:otherwise>
                            <c:set var="status" value="분실중" />
                        </c:otherwise>
                    </c:choose>
                    <td>${status }</td>
                    <td>${book.comment}</td>
                </tr>
            </c:forEach>
        </tbody>
    </table></div>

layout에서 body 부분만을 제외하고 나머지 부분들을 모두 처리하고 있기 때문에 중복 코드를 없앨수 있는 것을 볼 수 있습니다. 조금 더 응용할 경우, 보다더 복잡한 UI를 좀 더 깔끔한 코드로 만들어주는 것이 가능합니다. Tiles의 경우에는 현장에서 주로 사용하고 있는 View Template 입니다. 꼭 사용법을 익혀주시길 바랍니다. 

4. velocity

Velocity는 JSTL의 문법의 복잡함을 해결하기 위해서 구성된 View Template 입니다. 기본적으로 제어문의 간편함과 간결한 html을 가능하게 하는 장점을 가지고 있습니다. 
기본적인 velocity로 구성된 html 파일을 한번 알아보도록 하겠습니다. (* velocity로 구성된 html파일은 대체적으로 .vm 확장자를 갖습니다.) velocity를 주로 이용하는 경우에는 eclipse에 velocity plugin을 설치하는 것이 좋습니다. Install New Software를 선택해서 http://veloeclipse.googlecode.com/svn/trunk/update/ 주소에서 veloctiy plugin을 설치해주면 .vm 파일의 syntax highlight가 가능합니다. 

기본적인 velocity 문법은 #으로 시작되는 제어문과 $로 시작되는 변수로 함축할 수 있습니다.  만들어진 book list에 대한 velocity code는 다음과 같습니다. 

<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Velocity View Example</title><link href="/res/css/bootstrap.min.css" rel="stylesheet" /><link href="/res/css/sample.css" rel="stylesheet" /><script src="/res/js/bootstrap.min.js"></script></head><body>
    <h2>freemarker list view</h2>
    <div class="example-form">
        <h3>Book list</h3>
        <spring:message code="code.message"></spring:message>
        <table class="table table-striped table-bordered table-hover">
            <thead>
                <tr>
                    <th>Title</th>
                    <th>status</th>
                    <th>Description</th>
                </tr>
            </thead>
            <tbody>
                #foreach($book in $books)
                <tr>
                    <td>$book.title</td>
                    #if($book.status == "NORMAL")
                        <td>일반</td>
                    #elseif($book.status == "RENTNOW")
                        <td>대여중</td>
                    #else
                        <td>분실</td>
                    #end
                    <td>$book.comment</td>
                </tr>                
                #end
            </tbody>
        </table>
    </div></body></html>

주의해서 보실 것이 #foreach와 #if문입니다.  jstl보다는 문법이 매우 쉬워지는 것을 알 수 있습니다. 좀더 보기도 편한것도 사실이고요. 

ViewResolver를 등록하기 위해서 Spring은 2개의 Bean을 정의하도록 되어 있습니다. 위에 Tiles에서와 완전히 동일합니다. 먼저 ViewConfigurer를 등록하고, ViewResolver를 등록하는 형식입니다. ViewConfigurer의 경우에는 View에 대한 Configuration을 주로 등록을 하고, ViewResolver의 경우에는 Resolver의 세부 설정을 넣는 형식입니다. Velocity의 code base configuration은 다음과 같이 구성됩니다. 

    @Bean
    public VelocityConfigurer velocityConfigurer() throws VelocityException, IOException {
        VelocityConfigurer configurer = new VelocityConfigurer();
        configurer.setResourceLoaderPath("/WEB-INF/vm");
        Properties properties = new Properties();
        properties.put("input.encoding", "UTF-8");
        properties.put("output.encoding", "UTF-8");
        configurer.setVelocityProperties(properties);

        return configurer;
    }

    @Bean
    public VelocityViewResolver velocityViewResolver() {
        VelocityViewResolver viewResolver = new VelocityViewResolver();
        viewResolver.setContentType("text/html; charset=UTF-8");
        viewResolver.setSuffix(".vm");
        viewResolver.setOrder(3);
        return viewResolver;
    }

Configurer에서 encoding을 설정하는 것을 잊지 말아주세요. 한글 데이터가 있는한, 그리고 영문만을 사용하지 않는한 모든 ViewResolver는 어떻게든 UTF-8 설정이 필요합니다. 


5. Freemarker

Freemarker는 기본적으로 velocity와 동일한 컨셉의 View Template Engine입니다. Velocity보다 빠르고, 가독성의 향상을 목적으로 하고 있습니다. 다음은 Freemarker로 만든 Html code입니다. 

<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title><tiles:insertAttribute name="title"/></title><link href="/res/css/bootstrap.min.css" rel="stylesheet" /><link href="/res/css/sample.css" rel="stylesheet" /><script src="/res/js/bootstrap.min.js"></script></head><body>
    <h2>freemarker list view</h2>
    <div class="example-form">
        <h3>Book list</h3>
        <spring:message code="code.message"></spring:message>
        <table class="table table-striped table-bordered table-hover">
            <thead>
                <tr>
                    <th>Title</th>
                    <th>status</th>
                    <th>Description</th>
                </tr>
            </thead>

            <tbody>
                <#list books as book>
                    <tr>
                    <td>${book.title}</td>                    
                    <#if book.status.name() == "NORMAL">
                        <td>일반</td>
                    <#elseif book.status.name() == "RENTNOW">
                        <td>대여중</td>
                    <#else>
                        <td>분실</td>
                    </#if>
                    <td>${book.comment}</td>
                    </tr>
                </#list>
            </tbody>
        </table>
    </div></body></html>

#을 이용한 간편한 foreach문이 보이시나요? #if 등 문법상으로는 개인적으로는 좀더 편해보이는 것이 freemarker이긴합니다. freemarker를 사용하기 위해서는 velocity와 동일하게 ViewConfiguration과 ViewResolver를 구성해야지 됩니다. 다음은 code base configuration입니다. 

    @Bean
    public FreeMarkerConfigurer freemarkerConfigurer() {
        FreeMarkerConfigurer freemarkerConfigurer = new FreeMarkerConfigurer();
        freemarkerConfigurer.setTemplateLoaderPath("/WEB-INF/fmt");
        Properties properties = new Properties();
        properties.put("default_encoding", "UTF-8");
        freemarkerConfigurer.setFreemarkerSettings(properties);
        return freemarkerConfigurer;
    }

    @Bean
    public FreeMarkerViewResolver freemarkerViewResolver() {
        FreeMarkerViewResolver viewResolver = new FreeMarkerViewResolver();
        viewResolver.setContentType("text/html; charset=UTF-8");
        viewResolver.setSuffix(".ftl");
        viewResolver.setOrder(2);

        return viewResolver;
    }


Summary

지금까지 다양한 Html View Engine을 살펴봤습니다. View Engine은 매우 다양한 형태로 제공되고 있습니다. 지금 소개한 Veloctiy, Freemarker, tiles의 경우에는 Spring에서 공식적으로 제공하고 있는 View Template Engine입니다. 타 View Template Engine의 경우, Library에 Spring의 ViewResolver를 구현하고 있는 것이 일반적입니다. 다양한 View Engine은 Project에서 개발자의 맘 또는 전체 개발팀의 의향으로 정해지는 것이 일반적입니다. 그런데, 여기에서 조금 문제가 되는 것이 여러개의 View Engine을 섞어서 쓰지는 거의 못한다는 겁니다. 물론 섞어서 사용하는 경우도 왕왕 있습니다. 예를 들어, tiles에 freemarker를 섞어서 사용한다던지요. 이 부분에 대해서는 각자 개인의 학습이 좀 더 필요한 것 같습니다. 저도 몇 부분은 좀 더 해봐야지 될 것 같고요. 

가장 대중적인 것은 jstl을 사용하는 것입니다. 모든 View Template의 기본이 되고 있고, 많은 Reference를 가지고 있습니다. Tiles + JSTL의 경우가 호환성이나 code의 편의성이 가장 좋은 것 같습니다. 

숙제입니다. BookList를 jsp, tiles, velocity, freemarker를 이용해서 표시해주세요. 4개의 html page와 4개의 Template engine의 설정이 필요합니다. 반드시 한글 데이터가 나오도록 설정되어야지 됩니다. 또한 각 ViewEngine이 한 web server에서 동작하도록 구성을 해주시길 바랍니다.


Posted by Y2K
,

22. Spring View 처리 구조

Java 2013. 9. 12. 13:41

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


View는 사용자에게 최종적으로 보이는 영역입니다. 이 영역은 우리가 일반적으로 보는 Html이 될 수도 있고, Mobile App에게는 JSON format의 API 결과가 될 수도 있습니다. 
기본적으로 Spring Servlet/MVC를 기반으로 동작하게 됩니다. View 계층 또는 Presentation 계층이라고 합니다. 

Controller가 return한 결과에 대한 표현을 담당하는 영역으로 Controller가 넘겨주는 ModelAndView가 View에서 핵심 객체라고 할 수 있습니다. 

기본적인 동작은 DispatcherServlet이 ModelAndView에서 넘어온 값 ViewResolver를 통해서 해석한 결과를 사용자에게 보내줍니다. ViewResolver는 기본적으로 jsp를 기반으로 하고 있고, jsp 이외에 모든 web context가 될 수 있습니다. 

View의 기본 구조

기본적으로 Spring의 org.springframework.web.servlet.View interface를 구현한 객체를 View로 표현이 가능합니다. 일반적으로 View는 Spring 내부의 View를 확장하거나, pdf, rss, excel과 같은 다른 형태의 View를 표현하기 위해서 class를 확장해서 사용합니다. 또는 외부 View engine을 이용한 View의 표현 역시 가능합니다. 여기서 외부 View engine을 이용하는 것은 velocity, freemarker, tiles와 같은 외부의 View engine과의 연결 interface 및 설정을 구현함으로서 가능합니다. 

View의 기본 동작

Controller가 작업을 마친 후, View정보를 ModelAndView 객체에 담아서 보내주는 DispatcherServlet에 보내주는 것이 기본 동작입니다. 이에 대한 방법은 Spring @MVC는 두가지를 제공하고 있습니다. 첫번째는 View interface를 구현한 객체를 보내주는 방법이고, 다른 하나는 View의 이름만을 보내는 방법입니다. 첫번째 방법의 경우에는 View interface의 구현 방법에 따라 다양한 View를 표시하게 됩니다. DispatcherServlet과 Controller간에는 어떠한 동작도 존재하지 않습니다. 그렇지만 View의 이름만 보내주는 방식은 좀 다르게 동작하게 됩니다. 

View의 이름으로 표현되는 논리적인 View를 실질적인 View interface를 구현한 객체로 변경하는 작업이 필요하게되는데요. 이를 담당하는 객체를 ViewResolver라고 합니다. 
Spring에서 제공하는 주요 ViewResolver는 다음과 같습니다. 

ViewResolver 구현 classDescription
InternalResourceViewResolverView Name에서 jsp나 tiles 연동을 위한 View 객체를 반환
BeanNameViewResolverBean name을 기준으로 View 객체를 반환
ResourceBundlleViewResolverView 이름과 View 객체간의 mapping 정보를 저장하기 위해서 Resource 파일을 이용
XmlViewResolverView 이름과 View 객체간의 mapping 정보를 저장하기 위해서 xml 파일을 이용


기본적으로 만들어지는 ViewResolver의 interface는 다음과 같습니다. 
public interface ViewResolver {
    View resolveViewName(String viewName, Locale locale) throws Exception;
}

다국어 지원을 위한 locale 정보와 View 이름을 이용한 View 객체를 얻어내는 간단한 interface만을 가지고 있습니다. 이를 이용해서 새로운 ViewResolver를 만드는 것 역시 가능합니다. 

구성되는 View는 다음과 같은 interface를 가지고 있습니다. 

public interface View {
    String RESPONSE_STATUS_ATTRIBUTE = View.class.getName() + ".responseStatus";
    String PATH_VARIABLES = View.class.getName() + ".pathVariables";
    String SELECTED_CONTENT_TYPE = View.class.getName() + ".selectedContentType";
    String getContentType();
    void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception;
}

들어오게되는 model을 어떻게 render하는지에 대한 interface 선언을 볼 수 있습니다. 

자, 전에 봤던 Spring MVC에서 Request가 처리되는 과정을 다시 한번 봐보도록 하겠습니다. 

지금까지는 Step2까지 알아본 상황입니다. 이제 Step 2에서  Step 3 사이의 ModelAndView가 Return이 되고 ViewResolver가 ViewName을 통해서 실질적인 View를 Return 시켜주는 영역을 알아봐야지 됩니다. 그리고, 그 설정은 Spring에서 제공하는 ViewResolver interface에서 담당하고 있습니다.  위 그림에서 Step 3이 생략되는 경우 역시 존재할 수 있습니다. 앞에서 이야기한것 처럼, 직접 View가 return 될 때에는 Step 3의 ViewResolver가 동작을 하지 않고, 바로 Step 4로 이동하게 됩니다. 



Summary

이번장에서는 Controller가 return 시켜주는 Model을 render 시켜주는 View interface에 대해서 알아봤습니다.  Spring MVC에서 Request가 처리되는 과정을 좀 더 살펴보시길 바랍니다. 


Posted by Y2K
,

21. Controller - Spring 3.x

Java 2013. 9. 12. 13:39

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



기존 Spring 2.x 대의 Controller의 문제점을 해결하기 위한 수단으로 새로운 Controller Mapping 방법이 나오게 되었습니다. 이 방법은 지금 Spring Controller 부분의 표준으로 사용되고 있으며, 기존 코드를 완벽하게 대치하고 있습니다. 

기존 Spring 2.x 대의 Controller의 문제점은 다음과 같습니다.

1. 특정 interface를 반드시 상속받는 형태여야지 된다.
2. bean name을 이용한 method - url mapping이 된다.
3. POST/GET/DELTE/PUT/HEAD 와 같은 http method에 적합하지 않다.
4. url 당 1개의 Controller 객체가 생성되기 때문에 Enterprise 개발에 적합하지 않다.

기존에 Controller Interface를 구현해야지 되었으나, 3.0대의 @MVC는 annotation을 이용해서 @Controller로 객체의 meta 정보를 적는 것으로 해결이 가능합니다. 

다음과 같은 코드로 기존과 동일한 Controller가 구현 가능합니다. 

@Controller
public class HelloController {
    @Autowired
    private HelloString helloString;
    
    @RequestMapping(value="index", method=RequestMethod.GET)
    public String index(@RequestParam(value="name") String name, ModelMap model) {
        model.addAttribute("message", helloString.say(name));
        return "hello";
    }
}


기본적으로 @Controller를 이용, component-scan으로 bean으로 등록시켜서 사용 가능합니다. mapping 시킵니다. 그리고, 각 method에 Mapping url을 각각 지정해주는 방식으로 처리가 가능합니다. 여기서 return값에 주목할 점이 있습니다. 기존에는 return값으로 ViewAndModel을 보내줘야지 되었지만, 이제는 input값으로 Response에 보내질 model을 미리 준비해서 받는것 역시 가능합니다. 이 코드는 method의 in/out의 type을 강제하지 않고, 특정한 객체에 대한 상속을 피하고, URL에 대한 mapping을 한개의 class에서 처리 가능한, Spring의 특징 및 장점을 모두 갖는 코드라고 할 수 있습니다. 

URL mapping의 기본이 되는 RequestMapping 에 대해서 좀 더 알아보도록 하겠습니다.


@RequestMapping

String[] value
URL을 지정해주는 pattern입니다. 예를 들어 다음과 같은 pattern들을 지정해주는 것이 가능합니다.
1. @RequestMapping("/hello")
2. @RequestMapping({"/hello", "/hello2"})
3. @RequestMapping("/hello1")

Path변수를 지정해주는 것이 가능합니다. "/hello/{name}" 과 같이 method의 input을 url에 같이 실어 주는것이 가능합니다.
1. @RequestMapping("/hello/{name}")
2. @RequestMapping("/hello/{name}/{number}")

method
RequestMethod를 지정하는 것 역시 가능합니다. GET, POST, DELETE, PUT, HEAD가 사용 가능합니다. 역시 method도 Path와 동일하게 중복 설정이 가능합니다.

params
url 요청 파라미터의 유무에 따라 호출되는 method를 결정할 수 있습니다.
1. RequestMapping(value="/user/edit", params="type=admin")
2. RequestMapping(value="/user/edit", params="type=member")

이 두 url은 다음 실제 Url과 mapping 됩니다.
* /user/edit?type=admin
* /user/edit?type=member

method의 input값에 따라 method내에서의 if문을 만들지 않고 처리가 가능한 유용한 팁입니다.

headers
HTTP header정보에 따른 mapping역시 가능합니다. request type을 text/html, application/json 각각의 type에 따라 다른 method를 처리 가능합니다. 

RequestMapping과 method parameter와 결합

기본적으로 @Controller의 각 method는 다음과 같은 input parameter를 갖을 수 있습니다.

TypeAnnotationDescription
URL/POST parameter@RequestParamGET/POST/DELETE/PUT 등으로 호출될 때, 넘겨지는 Parameter값
Path value@PathVariableURL 에 포함된 특정 영역 문자열
Servlet-HttpServletRequest, HttpServletResponse를 직접 Handling 하는 기존 Servlet과 같은 코드 역시 사용 가능합니다.
Cookie@CookieValueCookie 값을 얻거나 설정할 수 있습니다.
Session@SessionAttributesSession 값을 얻거나 설정할 수 있습니다.
Body@RequestBodyRequest의 Body 부분을 모두 String으로 얻어내는 것이 가능합니다.

또한 Controller의 action method는 주로 4가지 형태의 Return Type을 사용하게 됩니다. 

1. String : view 이름을 return 합니다. 주로 JSP 또는 Veloctiy, Freemarker, tiles와 Html View를 호출 할 때 사용됩니다. String 형태를 보내줄 때는 일반적으로 ViewResolver라는 객체를 applicationContext.xml에 등록하는 것이 일반적입니다.
2. void : 아무것도 return 하지 않습니다. 이는 method의 이름을 String 형태로 return 하는 것과 동일한 결과를 갖습니다.
3. Object : REST 형태의 Return값을 사용할 때 이용됩니다. 대체적으로 Object에 대한 Body Response를 덩어내는 것을 주 목적으로 하고 있습니다.
4. ModelAndView : Spring 2.X 형태로 Model과 View를 return 하는 것이 가능합니다. 

여기서 ModelAndView 형태의 return값은 pdf, excel 과 같은 데이터를 다운받는 형태로 사용 가능합니다. 이 부분은 뒤에 View에서 다시 다루도록 하겠습니다. 


Spring 3.x를 이용한 Hello World


기본적으로 그 전에 만들었던 Spring 2.x의 Hello World와 유사한 코드가 만들어집니다. Spring 2.x대의 코드와 동일한 설정을 해서 project를 하나 만들도록 하겠습니다. 아니면 기존의 project를 다른 이름으로 copy 해서 import 해도 괜찮습니다.
간단하게 HelloController를 작성해보도록 하겠습니다. @Controller를 이용한 처리를 하더라도 Controller의 경우에는 Controller라는 이름을 붙여주는 것이 일반적입니다. 

@Controller
public class HelloController {
    @Autowired
    private HelloString helloString;
    @RequestMapping(value="/index", method=RequestMethod.GET)
    public String index(@RequestParam(value="name") String name, ModelMap model) {
        model.addAttribute("message", helloString.say(name));
        return "hello";
    }
}

아주 간단한 코드입니다. 기존과 다르게 String 형태로 return을 시켰습니다. 지금 코드 그대로면 webapp/hello 파일을 찾게 되고, 이건 에러가 발생하게 됩니다. 따라서 기본적으로 사용할 ViewResolver를 등록시켜줘야지 됩니다. 


  <bean
    class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/jsp/" />
    <property name="suffix" value=".jsp" />
    <property name="order" value="1" />
  </bean>

지금까지 등록된 bean과는 조금 다른 형태입니다. 지금까지는 id값을 가지고 있었지만, id나 name이 없는 bean 등록입니다. spring을 사용한 개발을 하다보면 이렇게 등록되는 경우가 왕왕 있습니다. 주로 Spring 내부에서 사용할 bean 또는 모든 applicationContext에서 하나만 존재할 bean 들의 경우 id/name을 갖지 않아도 됩니다. 
그리고, @Controller를 url에 mapping 해주는 과정을 해줘야지 됩니다. 이는 context:component-scan 을 이용해서 해주면 되고, applicationContext에는 다음과 같이 위치시키면 됩니다. 

  <context:component-scan base-package="com.xyzlast.mvc.spring02.controllers" />

프로젝트의 구조를 잘 파악할 수 있어야지 됩니다. 지금 구성된 전체 Project의 구조는 다음과 같습니다.


web.xml을 구성해야지 됩니다. web.xml을 구성할 때, 앞으로 개발하기 좀 더 편하게 다음과 같은 설정을 추가하도록 하겠습니다. 모든 request에 .do가 붙는 경우에는 모두 spring에서 처리하도록 web.xml을 수정하도록 하겠습니다. 수정된 web.xml은 다음과 같이 구성됩니다. servlet-mapping에서 url-pattern이 구성된 방법을 확인해주세요. 이 pattern을 넣는것은 매우 중요한 의미를 갖습니다. .do가 아닌 .html과 잘 알려진 확장자 역시 처리가 가능합니다. 이러한 설정을 이용해서, spring을 통해서 작성된 web인지, 아니면 그냥 html인지 외부에서 착각을 유도하는 것도 가능합니다. 정부표준 프레임워크 등 대부분의 Framework에서는 .do를 사용하고 있습니다. 그리고 nhn에서는 .nhn을 붙여서 사용하고 있습니다. 다른 일반적인 file path들과 중복되지 않는 이름을 사용하는 것이 중요합니다. 


<?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
  version="3.0">
  <display-name>mvc.spring02</display-name>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <servlet>
    <servlet-name>spring</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>spring</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
</web-app>

그리고, 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:mvc="http://www.springframework.org/schema/mvc"
  xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  <bean id="helloString" class="com.xyzlast.mvc.spring02.entities.HelloString"></bean>
</beans>

마지막으로 spring-servlet.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">
  <context:component-scan base-package="com.xyzlast.mvc.spring02.controllers" />
  <bean
    class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/jsp/" />
    <property name="suffix" value=".jsp" />
    <property name="order" value="1" />
  </bean></beans>

구성후 테스트 코드를 작성해보도록 하겠습니다. 테스트 코드 소스는 다음과 같습니다. 
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"file:src/main/webapp/WEB-INF/applicationContext.xml", "file:src/main/webapp/WEB-INF/controller-servlet.xml"})
@WebAppConfiguration
public class HelloControllerTest {
    @Autowired
    private WebApplicationContext context;
    private MockMvc mvc;

    @Before
    public void setUp() {
        mvc = webAppContextSetup(context).build();
        assertThat(mvc, is(not(nullValue())));
    }

    @Test
    public void index() throws Exception {
        MvcResult result = mvc.perform(get("/index").param("name", "ykyoon")).andExpect(status().isOk()).andReturn();
        Object model = result.getModelAndView().getModel().get("message");
        assertThat(model, is(not(nullValue())));
        String message = (String) model;
        assertThat(message.endsWith("ykyoon"), is(true));
    }
}

마지막으로 jetty를 추가 후, maven jetty:run을 이용해서 프로젝트를 구동해보시길 바랍니다.
구성된 project의 pom.xml은 다음과 같습니다.

<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>com.xyzlast</groupId>
  <artifactId>mvc.spring02</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>mvc.spring02 Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>3.2.1.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>3.2.1.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>3.2.1.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>3.2.1.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>3.2.1.RELEASE</version>
    </dependency>
  </dependencies>
  <build>
    <finalName>mvc.spring02</finalName>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.0</version>
        <configuration>
          <source>1.7</source>
          <target>1.7</target>
        </configuration>
      </plugin>
      <plugin>
      <plugin>
       <plugin>
            <groupId> org.eclipse.jetty</groupId>
            <artifactId>jetty-maven-plugin</artifactId>
        </plugin>
      </plugin>
    </plugins>
  </build>
</project>


확장자가 없는 URL

지금까지의 예시에서는 확장자를 하나씩 붙여서 처리했습니다. 이러한 확장자를 붙여서 처리하는 것은 DispatcherServlet에서 처리할 URL이 어떤 것인지 명확하게 결정해줄 수 있는 장점을 가지고 있습니다. 그렇지만, 이 방법은 조금 애매한 것이 사실입니다. W3C에서 표준한 URL 표준에서, 확장자는 URL을 통해서 얻고 싶은 Response의 protocol을 선택하는 형식입니다. 예를 들어서 다음 URL들의 해석은 다음과 같습니다. 

/shop/search.json?name=윤영권
/shop/search.html?name=윤영권
/shop/search.rss?name=윤영권
/shop/search.xml?name=윤영권

다음 4개의 url format은 json/html/rss/xml 형식으로 데이터를 얻어오는 것을 가정하고 있습니다. url의 extension에 dispatcher servlet 을 종속시키는 것은 이제 옛날 방법입니다. 이제는 모든 URL을 dispatcherServlet에 보내게 됩니다. 그리고 dispatcherServlet에서 해석 불가능한 request들은 servlet container에게 넘기는 방식으로 처리하는 것입니다. 

여기서 servlet spec에 대해서 한번 알아보도록 하겠습니다. SRV.11.2 Specification of Mappings 에서 servlet container는 다음과 같이 명령을 정의하고 있습니다. 

In theWeb application deployment descriptor, the following syntax is used to define mappings:
1. A string beginning with a ‘/’ character and ending with a ‘/*’ suffix is used for path mapping.
: '/'로 시작하고, '/*'로 끝나는 mapping의 경우에는 path mapping을 따르게 된다.
(path mapping : servlet container에서 정의되어 있는 mapping입니다.)
2. A string beginning with a ‘*.’ prefix is used as an extension mapping.
: *. 으로 시작하는 mapping의 경우에는 확장 mapping을 따르게 된다. 우리가 기존에 사용하는 것을 확인했던 *.do와 같은 방법입니다.
3. A string containing only the ’/’ character indicates the "default" servlet of the application. In this case the servlet path is the request URI minus the context path and the path info is null.
: '/'만 사용하게 되는 경우, 이는 application의 'default' servlet을 의미한다. 이 경우에는 request URI와 context Path가 완전히 일치하게 되고, servlet path는 null이 됩니다.
4. All other strings are used for exact matches only.
: 모든 request uri가 완전히 일치하는 경우

이 4가지 경우중에서 우리가 사용하게 되는 것은 3번으로 mapping을 설정하게 됩니다. 이는 결국에 원 servlet container의 default servlet의 목적을 바꿔버리는 결과를 가지고 옵니다. 이렇게 설정하는 경우, web.xml은 다음과 같이 설정할 수 있습니다. 

    <servlet-mapping>
        <servlet-name>controller</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

그리고 이렇게 설정하는 경우에 반드시 servlet-configuration에 다음과 같은 설정을 추가해줘야지 됩니다. 
<mvc:default-servlet-handler/>

앞으로 모든 url은 위와 같은 format으로 설정하게 될 것입니다. 

@Configuration을 이용한 DispatcherServlet 설정

Controller들을 선언하는 DispatcherServlet의 설정의 경우에는 DispatcherServletName + "-servlet.xml"의 형식으로 기본적으로 구성되게 됩니다. 이 설정을 @Configuration을 이용해서 변경해보도록 하겠습니다. 
먼저, 지금까지 구성된 spring-servlet.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"
    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.2.xsd
        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:component-scan base-package="com.xyzlast.mvc.spring02.controllers" />
  <bean
    class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/jsp/" />
    <property name="suffix" value=".jsp" />
    <property name="order" value="1" />
  </bean>
  <mvc:default-servlet-handler />
</beans>

ViewResolver를 등록하고, default-servlet-handler를 등록하는 것 이외에는 설정이 거의 없습니다. spring-servlet.xml을 대치하는 @Configuration을 구성의 편의성을 높이기 위해서 Spring은 abstract class를 제공하고 있습니다. 이 코드를 시용하면 보다 더 쉽게 처리가 가능합니다. xml을 이용해서 설정하는 것보다 나중에는 훨씬 편한 설정을 제공하기 때문에, 이는 꼭 @Configuration을 이용해서 구성하기실 바랍니다. 훨씬 편합니다. 

@Configuration
@EnableWebMvc
@ComponentScan(basePackages = { "com.xyzlast.mvc.spring02.controllers" })
public class ControllerConfiguration extends WebMvcConfigurerAdapter {
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    @Bean
    public InternalResourceViewResolver internalResourceViewResolver() {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        viewResolver.setViewClass(JstlView.class);
        viewResolver.setPrefix("/WEB-INF/jsp/");
        viewResolver.setSuffix(".jsp");
        viewResolver.setOrder(1);
        return viewResolver;
    }
}

WebMvcConfigurerAdapter를 이용하는 경우, DefaultServletHandlerConfigurer 등 여러 항목들을 편하게 설정이 가능합니다. override가 가능한 method들이 주목할 만한 것들이 많습니다. 나중에 나올 initBinder, formatter 등의 설정 역시 위 class에서 가능하기 때문에 여간해서는 xml을 사용하지 않기를 바랍니다. 

마지막으로 web.xml을 구성하는 방법에 대해서 간단히 소개를 드린 내용을 정리해보도록 하겠습니다. 

@Configuration  + web.xml을 이용한 설정

@Configuration class를 이용한 설정을 web.xml에 반영하기 위해서는 web.xml의 기본 ContextLoader의 설정을 변경해야지 됩니다.  기본적으로 web.xml의 ContextLoaderListener는 XmlConfigWebApplicationContext를 설정하고 있습니다. 이를 AnnotationConfgWebApplicationContext로 변경해야지 됩니다. 그리고 child applicationContext 역시, DispatcherServlet의 contextClass를 XmlConfigWebApplicationContext로 변경하고 @Configuration class로 변경하는 것이 필요합니다. 변경되는 web.xml은 다음과 같이 구성됩니다. 

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

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    version="3.0">

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <context-param>
        <param-name>contextClass</param-name>
        <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
    </context-param>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>com.xyzlast.bookstore.domain.config.DomainConfiguration</param-value>
    </context-param>
    <servlet>
        <servlet-name>controller</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextClass</param-name>
            <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
        </init-param>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>com.xyzlast.bookstore.web.configs.WebMvcContexConfiguration</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>controller</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

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

    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>

</web-app>

객체를 넣어줄때는 package명까지 명확히 넣어줘야지 된다는 것을 잊지 말아주세요.

지금보시면 web.xml에 새로운 내용이 하나 더 추가가 되어서 보입니다. filter-mapping이 바로 그것인데요. 지금 사용한 Filter는 기본적으로 tomcat과 같은 web container는  ISO-8859-1 문자 포멧을 사용하게 됩니다. 이 포멧을 UTF-8로 사용하기 위한 기본 설정입니다. 우리나라에서는 꼭 해줘야지 되는 기본 설정입니다.


@Configuration + no web.xml을 이용한 설정 방법

web.xml이 아애 없이 개발하기 위해서는 web.xml을 대신할 객체를 만들어줘야지 됩니다. 
web.xml이 없는 경우, servlet container 즉 tomcat 또는 jetty는 자신이 가진 bin 중에서 spring 객체가 로드되면서 WebApplicationInitializer를 상속받은 객체가 있는지 확인하는 과정을 거치게 됩니다. 

이제 우리가 사용할 기본적인 WebApplicationInitializer 코드를 확인해보도록 하겠습니다. 
public class BookStoreWebApplicationInitializer implements WebApplicationInitializer {

    private static final String DISPATCHER_SERVLET_NAME = "dispatcher";

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        registerListener(servletContext);
        registerDispatcherServlet(servletContext);

        addEncodingFilter(servletContext);
    }

    private void registerListener(ServletContext servletContext) {
        AnnotationConfigWebApplicationContext rootContext = createContext(DomainConfiguration.class);
        ContextLoaderListener contextLoaderListener = new ContextLoaderListener(rootContext);
        servletContext.addListener(contextLoaderListener);
        servletContext.addListener(new RequestContextListener());
    }

    private void registerDispatcherServlet(ServletContext servletContext) {
        AnnotationConfigWebApplicationContext dispatcherContext = createContext(WebMvcContexConfiguration.class);
        ServletRegistration.Dynamic dispatcher = servletContext.addServlet(DISPATCHER_SERVLET_NAME,
                new DispatcherServlet(dispatcherContext));
        dispatcher.setLoadOnStartup(1);
        dispatcher.addMapping("/");
    }

    private AnnotationConfigWebApplicationContext createContext(final Class<?>... annotatedClasses) {
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(annotatedClasses);
        return context;
    }

    private void addEncodingFilter(ServletContext servletContext) {
        CharacterEncodingFilter encodingFilter = new CharacterEncodingFilter();
        encodingFilter.setEncoding("UTF-8");
        encodingFilter.setForceEncoding(true);
        FilterRegistration.Dynamic encodingFilterRestriction = servletContext.addFilter("characterEncodingFilter",
                encodingFilter);
        encodingFilterRestriction.addMappingForUrlPatterns(null, false, "/*");
    }
}

하나하나 코드에 대해서 확인해보도록 하겠습니다. WebApplicationInitializer를 상속받으면 기본적으로 onStartup method가 abstract로 구현체로 나오게 됩니다. 이 method는 web container가 application을 로드할 때 시작되는 method가 됩니다. 

code의 private method는 다음과 같습니다. 

# registerListener : root applicationContext를 로드하는 private method입니다.
# registerDispatcherServlet : child applicationContext를 로드하고, front controller인 dispatcher servlet을 로드하는 구문입니다. 
# addEncodingFilter : Filter 적용 코드입니다.

이 코드랑, 그 전에 작성된 web.xml과 한번 비교를 해보시길 바랍니다. 완전히 1:1로 matching이 되어서 동작하는 것을 볼 수 있습니다. 
개인적으로는 가장 선호하는 방법입니다. 

위 코드도 길다고 느껴지시나요? 
Spring 3.2를 사용하실 경우에는 더욱더 간단한 코드를 작성하는 것이 가능합니다. 다음과 같습니다. 

public class WebXmlConfiguration extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class<?>[] { DomainConfiguration.class };
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class<?>[] { WebApp01Configuration.class };
    }

    @Override
    protected String[] getServletMappings() {
        return new String[] { "/" };
    }

    @Override
    protected boolean isAsyncSupported() {
        return true;
    }

    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter encodingFilter = new CharacterEncodingFilter();
        encodingFilter.setEncoding("UTF-8");
        encodingFilter.setForceEncoding(true);
        return new Filter[] { encodingFilter };
    }
}


@Configuration + WebApplicationInitializer + web.xml 을 이용하는 방법

이제 마지막 방법입니다.  만약에 WebApplicationInitializer를 상속받은 객체와 web.xml이 동시에 존재를 한다면 어떻게 동작을 할까요? 
정답은 web.xml이 먼저 적용되고, WebApplicationInitializer가 나중에 동작하게 됩니다. 이러한 구성을 사용하는 이유는 다음 항목들이 아직 WebApplicationInitializer에 구현되지 않았기 때문입니다. (servlet 3.0 규약에서 이 부분은 web.xml에서 빠져있습니다.) 

1. welcome-page
2. error-code

이 두가지를 구현하기 위해서는 반드시 web.xml을 사용해줘야지 됩니다.


Posted by Y2K
,

20. Controller - Spring 2.x

Java 2013. 9. 12. 10:53

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


maven을 이용한 기본 web application을 구성하는 방법에 대해서 알아봤습니다. 
servlet을 이용한 web page 개발은 Model 1 또는 Model 2라고 하는 Model에 의해서 구성되게 됩니다. 먼저 Model 1에 대해서 알아보도록 하겠습니다. 

Model 1은 JSP Page에서 JavaBean을 이용해서 직접 DB에 또는 DataSource에 접근하는 방식입니다. Client에서 WebServer로 호출이 되게 되면 SErver에서 요청한 File을 분석하게 됩니다. 이는 JSP 또는 Html 형태로 구성이 되게 되며, JSP의 경우 Servlet Container에서 JavaBean을 이용해서 DB에 접속하고 처리 결과를 조합하여 JSP 호출부에 전송하여 Html 형태로 Client에 response를 보내게 되는 방식입니다.


이러한 방식을 Model 1 이라고 합니다.


이러한 방법의 장/단은 다음과 같습니다.

장점
1. 개발 속도가 빠르다.
2. 개발자의 스킬이 낮아도 배우기 쉬워 빠르게 적용할 수 있다.

단점
1. JSP페이지에서 프리젠테이션 로직과 비즈니스 로직을 모두 포함하기 때문에 JSP페이지가 너무 복잡해 진다.
2. 프리젠테이션 로직과 비즈니스 로직이 혼재되어 있기 때문에 개발자와 디자이너의 분리된 작업이 어려워진다.
3. JSP페이지의 코드가 복작해 짐으로 인해 유지보수 하기 어려워진다.
4. 정교한 Presentation 레이어를 구현하기 힘들다.(유효성 체크, 에러 처리등)

점점 고도화 되어가는 Web Application의 구성에 있어서 Model 1의 코드의 복잡도에 의하여 유지보수를 하는 것이 불가능해졌습니다. 그래서, 기존의 Model 1을 버리고 Model 2 방식으로 변경이 되기 시작했습니다.
참고로, asp .net webform도 Model 1 방식이라고 할 수 있습니다. 


다음은 Model 2입니다.



Servlet에서 Request를 받아 Controller에서 비지니스 로직을 처리하고, View에서 표현할 데이터를 객체로 전달하고, View에서는 그 데이터를 어떻게 표현을 할지를 결정하는 방식입니다. 이때 View는 Presentation Layer라고 지칭이 됩니다. 이러한 방식을 Model 2 라고 합니다. Model 2의 장/단점은 다음과 같습니다.

장점
1. Presenation에서 명확한 역할 분담이 된다.
2. UI 레이어를 단순화 시킴으로서 디자이너도 작업하는 것이 가능하게 된다. - 단지 Display용으로만 사용된다.
3. Presentation 레이어의 정교한 개발이 가능하다. 유효성 체크, 에러 처리와 같은 기능들은 Spring 프레임워크에서 제공한다.
4. Dependency Pull 없이 Dependency Injection만을 이용해서 애플리케이션을 개발하는 것이 가능하다.
5. UI 레이어가 단순해 짐으로서 유지보수가 쉽다.

단점
1. 새로운 기술을 익혀야하는 부담감이 있다.
2. 프로젝트 초반에 개발속도의 저하를 가져올 수 있다.

Spring MVC를 사용하지 않을 때, 거의 모든 Web에서 사용되던 Struct 1과 Struct 2가 Model 2를 가장 잘 지원하는 Web Framework로서 인기를 끌었습니다. 


Web 개발에 들어가기 전에......

지금부터 모든 글(chapter 마지막까지) 은 Servlet 3.0 기반으로 적혀있습니다. servlet 3.0을 사용하기 위해서는 다음 jar가 반드시 pom.xml에 존재해야지 됩니다. scope를 반드시 provide로 해서 넣어주세요.

    <dependency>
      <groupId>org.apache.tomcat</groupId>
      <artifactId>tomcat-servlet-api</artifactId>
      <version>7.0.37</version>
      <scope>provide</scope>
    </dependency>


Spring 2.x 에서의 Model 2 Web 개발

spring web은 Model2에서 사용할 Controller interface를 제공합니다. Controller interface는 다음과 같이 선언됩니다.

public interface Controller {
    ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception;
}


매우 단순한 View 형태입니다. Controller interface를 이용해서 Hello World Web Application을 작성해보도록 하겠습니다.
바로 전에 이야기드린 것 처럼 maven project를 하나 만들어 줍니다.
그리고, 이제 spring mvc에 대한 maven 설정들을 모두 추가합니다.
정의된 maven bean들은 다음과 같습니다.

  <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>3.2.1.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>3.2.1.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>3.2.1.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>3.2.1.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>3.2.1.RELEASE</version>
    </dependency>

구성된 Folder중 src/main/webapp/WEB-INF/web.xml 파일을 다음과 같이 수정합니다. 

<?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" 
         xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  <display-name>mvc.spring01</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
  <listener>
    <display-name>ContextLoader</display-name>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <servlet>
    <servlet-name>spring</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>spring</servlet-name>
    <url-pattern>/app/*</url-pattern>
  </servlet-mapping>
</web-app>


web.xml에 대해서 알아보도록 하겠습니다. 

먼저, listener입니다. web application이 실행될 때, 기본 bean들을 load 하기 위한 listener를 등록합니다. 기본적으로 main/webapp/WEB-INF/applicationContext.xml 파일을 읽어 bean들을 load 시켜줍니다. 

다음은 servlet 설정입니다. front controller로 spring 이라는 이름으로 DispatcherServlet을 로드하고 있는 것을 볼 수 있습니다. 

마지막으로 servlet-mapping입니다. Servlet이 사용될 url path를 설정합니다. 위 xml에서는 /app/* path에서 DispatcherServlet이 실행됨을 지정하고 있습니다. 그리고, DispatcherServlet가 로드될때, 자동으로 spring-servlet.xml bean 정의를 로드합니다. 이는 DispatcherServlet 내부에서 사용할 child appliation context입니다. 파일 이름은 servlet 이름 + "-servlet.xml" 로 자동 결정됩니다. 

따라서, 위 설정의 경우 src/main/webapp 폴더는 다음과 같이 구성되게 됩니다. 


지금보시면 applicationContext가 2개가 등록되게 됩니다. 전에 applicationContext에 대해서 이야기드릴때, root context와 child context가 존재한다는 이야기를 드린적이 있습니다. 이 부분에 대한 내용이 바로 이것입니다. root context가 applicationContext.xml이 되고, child context가 spring-servlet.xml이 되게 되는 것입니다. 이런 root-child context 구조는 기존에는 spring application context를 사용하지만, web 기술은 spring @MVC를 하지 않고 structure 와 같은 다른 web framework를 사용하는 경우를 지원하기 위해서 만들어진 구조입니다.  xml을 사용하게 되면 application context class는 기본으로 지정된 XmlConfigWebApplicationContext를 사용하게 됩니다. 

그런데 왜 이렇게 2개의 application context를 가지도록 설계가 되어 있을까요? 그 이유는 Spring은 먼저 ApplicationContext를 제공하는 Spring-core와 Spring-Bean으로 시작했기 때문입니다. spring-mvc의 경우에는 후에 추가가 된 것이고, 초기에는 spring-core, spring-bean을 이용한 DI와 AOP만을 이용하고, web기술은 struct 와 같은 다른 web framework를 이용했기 때문입니다. 그래서 두개의 설정이 나뉘게 되었고, 그게 지금까지 고정되어 사용되고 있는 것입니다.

@Configuration을 이용한 개발의 경우, Spring 3.x대의 개발에서 좀더 알아보도록 하겠습니다. 기본적으로 Spring 2.x에서 3.0까지는 @Configuration을 이용한 설정을 지원하지 않습니다. 

이제 Controller와 Controller에서 사용될 객체인 HelloString을 만들어보도록 하겠습니다. 

public class HelloSpring {
    public String sayHello(String name) {
        return "Hello " + name;
    }
}

public class HelloController implements Controller {
    @Autowired
    private HelloSpring helloSpring;

    @Override
    public ModelAndView handleRequest(HttpServletRequest request,
            HttpServletResponse response) throws Exception {
        String name = request.getParameter("name");
        String message = helloSpring.sayHello(name);
        Map<String, Object> model = new HashMap<String, Object>();
        model.put("message", message);
        return new ModelAndView("/WEB-INF/view/hello.jsp", model);
    }
}

그리고, HelloSpring는 applicationContext.xml에 HelloController는 spring-servlet.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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="helloSpring" class="com.xyzlast.mvc.spring01.entities.HelloSpring"/>
</beans>

<?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 name="/hello" class="com.xyzlast.mvc.spring01.controllers.HelloController"/>
</beans>


Controller의 등록시, id가 아닌 name으로 /hello로 등록된 것을 주의해주세요. 

이제 이 Controller의 결과를 보여줄 view를 구성하도록 하겠습니다. view 파일의 이름은 webapp/WEB-INF/view/hello.jsp 입니다. 

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Insert title here</title>
</head>
<body>
    <p>${message}</p>
</body>
</html>

그리고 command 창에서 mvn jetty:run 을 실행시키면 이제 웹서버가 구동된겁니다. browser를 통해서 http://localhost:8080/hello/app/hello?name=ykyoon 를 실행시키면 다음 화면을 볼 수 있습니다.

지금까지 만들어지는 과정을 보면 기존 Application을 만드는 과정과는 조금 다른 과정을 보게 됩니다. 먼저, bean을 name으로 등록하게 됩니다. 이건 Controller를 url에 mapping하는 spring만의 방법입니다. 이때는 id가 아닌 name으로 url에 mapping 하게 됩니다. 

그리고 하나 더 주목할 것이 있습니다. ModelAndView객체가 바로 그것입니다. 

ModelAndView는 최종적으로 Controller가 return 해주는 값입니다. ModelAndView에서는 표현될 view의 파일 이름과 view 에서 사용될 Model을 Map형태로 return 시켜주게 됩니다. 이 형태는 jsp를 이용할 때의 형식이고, pdf 또는 파일이 return 될때는 좀 다른 형식을 사용합니다. 이 부분에 대해서는 좀 더 나중에 알아보도록 하겠습니다. 지금은 web page를 보여줄 때는 ModelAndView를 return 한다는 것을 기억해주시면 되겠습니다. 

그리고, 이와같은 web application의 테스트는 어떻게 해야지 될까요? 지금까지 web을 만들고 테스트 하는 것은 web server를 실행시키고, web server의 url을 직접 타이핑을 하던가, 아니면 link를 click-click 해가면서 손으로 테스트를 했습니다. 그런데 이런 테스트 방법은 매우 시간이 많이 걸리고, 개발자들을 불편하게 합니다. 
이제 다시 한번 테스트를 어떤것을 해야지 되는지 확인해보도록 합시다. 먼저, 지금 HelloController는 /hello url로 접근이 가능한지 확인해야지 됩니다. 그리고 Model에 message가 들어있는지 확인되어야지 됩니다. 마지막으로 message가 원하는 값인 Hello + input 임을 확인할 수 있어야지 됩니다. 

정리해보겠습니다.  우리가 Controller에서 테스트할 내용은 다음과 같습니다. 

1. 원하는 url로 접근이 가능한지.
2. return되는 Model에 필요한 값이 존재하는지.
3. return된 Model의 값이 원하는 값으로 나오는지 확인

이 3가지가 되면 Controller는 테스트가 가능합니다. 그리고 View는 Controller에 의해서 나온 값을 보여주는 영역이기 때문에 특별히 테스트를 하지 않습니다. 최종적으로 View영역도 HTML의 테스트를 하는 것이 필요하지만, 이 부분은 지금 영역을 넘어가기 때문에 다루지 않도록 하겠습니다. 
이러한 테스트 방법으로 spring은 멋진 솔루션을 제공합니다. Controller에서 Ctrl+j를 눌러 Controller에 대한 단위 테스트 코드를 작성하도록 하겠습니다. 

@SuppressWarnings("unused")
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({ "file:src/main/webapp/WEB-INF/applicationContext.xml",  "file:src/main/webapp/WEB-INF/spring-servlet.xml"})
@WebAppConfiguration
public class HelloControllerTest {
    private MockMvc mvc;
    @Autowired
    WebApplicationContext context;

    @Before
    public void setUp() throws Exception{
        mvc = webAppContextSetup(context).build();
    }

    @Test
    public void getHello() throws Exception {
        MvcResult result = mvc.perform(get("/hello").param("name", "ykyoon"))
           .andExpect(status().isOk())
           .andReturn();
        String message = (String) result.getModelAndView().getModel().get("message");
        assertThat(message.contains("ykyoon"), is(true));
        assertThat(message, is(not(nullValue())));
        System.out.println(message);
    }
}

import를 엄청나게 많이 합니다.위 구성을 eclipse template에 등록하시면 좀 더 편하게 테스트 코드를 작성할 수 있습니다. 
그리고 테스트를 실행하면 너무나 깔끔하게 처리가 되는 것을 알 수 있습니다. 

test code 살펴보면 다음과 같습니다. 

먼저 MockMvc라는 servlet container를 가상으로 Spring 내부에서 만들어줍니다. 만들어지는 객체는 tomcat이나 jetty와 동일하게 움직입니다. 

mvc.perform method를 통해서 url을 기반으로 접근이 됩니다. 그리고, status값이 200이 나오는지 확인을 하는 구조로 만들어집니다. 
마지막으로 andReturn을 통해서 Model 과 View값을 얻어내 접근이 가능합니다. 이런 테스트 코드를 이용해서 우리가 만든 Controller가 정상적으로 움직이는지 확인이 가능합니다. 

다만, 이 테스트 코드는 Spring 3.2 이상에서만 가능합니다.; 그리고, web aplication에서의 테스트 코드는 우리가 실제로 사용할 aplicationContext.xml 을 그대로 사용하는 형식으로 테스트를 행해야지 됩니다. 
Controller의 테스트 코드는 매우 중요합니다. 지금은 단순하게 model의 값을 확인하는 것이지만, 후에 나올 Server 측 validation과 cookie의 만료 부분에서 이러한 테스트의 통과는 매우 중요한 역활을 갖게 됩니다.

지금까지 만든 코드는 Spring 2.x 대에서 Controller를 만드는 방법입니다. 그렇지만 이 부분은 약간의 논란이 있습니다. Spring의 장점인 특정 환경, 특정 기술에 종속되지 않는 코드의 기반이 깨지게 됩니다. Spring에서 제공하는 Controller interface를 반드시 상속을 해야지 되는 문제가 같이 발생하게 됩니다. 그리고, 코드와 URL간의 mapping이 xml에 있기 때문에 코드를 한번에 파악하기도 힘들게 됩니다. 그리고 가장 큰 문제는 전체 Url 1개 당 하나씩 객체가 만들어지고, 객체의 갯수는 기하급수적으로 계속해서 증가하게 되는 문제가 발생하게 됩니다.

그래서, 이 부분 문제를 해결하기 위해서 Spring 3.x에서는 다른 방법의 URL mapping을 지원하게 됩니다. 다음 장에서 Spring 3.x대에서의 URL mapping의 방법을 알아보도록 하겠습니다. 


web.xml 없는 spring mvc 설정 

web.xml 을 소개할 때 나왔던 web.xml이 없는 개발 방법에 대해서 알아보도록 하겠습니다. 
spring은 WebApplicationInitializer을 제공하고 있습니다. 이 interface는 javax.servlet.ServletContainerInitializer를 구현하고 있으며, Spring jar가 로드되면서 자동으로 web.xml 대신에 사용되도록 servlet container에 로드가 되게 됩니다. 
다음 코드를 먼저 확인해보도록 하겠습니다. 
먼저,  ControllerConfiguration을 한번 알아보도록 하겠습니다. 

@Configuration
public class Spring2WebConfiguration extends WebMvcConfigurerAdapter {
    @Bean
    public HelloSpring helloSpring() {
        return new HelloSpring();
    }

    @Bean(name="/hello")
    public HelloController helloController() {
        HelloController helloController = new HelloController();
        helloController.setHelloSpring(helloSpring());
        return helloController;
    }
}

그리고, WebAplicationInitializer를 구현한 Spring2WebApplicationInitializer 코드는 다음과 같습니다. 

public class Spring2WebApplicationInitializer implements WebApplicationInitializer {

    @Override
    public void onStartup(final ServletContext servletContext) throws ServletException {
        registerDispatcherServlet(servletContext);
    }

    private void registerDispatcherServlet(final ServletContext servletContext) {
        WebApplicationContext dispatcherContext = createContext(Spring2WebConfiguration.class);
        DispatcherServlet dispatcherServlet = new DispatcherServlet(dispatcherContext);
        ServletRegistration.Dynamic dispatcher = servletContext.addServlet("dispatcher", dispatcherServlet);
        dispatcher.setLoadOnStartup(1);
        dispatcher.addMapping("/app/*");
    }

    private WebApplicationContext createContext(final Class<?>... annotationClasses) {
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(annotationClasses);
        return context;
    }
}

이제 이 두 객체를 package에 넣고, web.xml을 없애거나 파일 이름을 변경시키면 자동으로 Spring2WebApplicationInitializer가 실행되게 됩니다. 

코드의 내용을 보시면, web.xml의 내용을 그대로 코드에 옮겨온것을 알 수 있습니다. dispatcherServlet을 등록시켜주고, dispatcherServlet에 Spring의 applicationContext bean들을 적용시켜주는 것으로 매우 쉽게 개발이 가능합니다. 
한번 jetty를 이용해서 /hello를 실행시켜보시길 바랍니다. 그리고 테스트 코드 역시 @ContextConfiguration에 classes 에 Spring2WebConfiguration.class만 등록시켜주시면 동일하게 사용 가능합니다. test나 개발에 있어서는 확실히 code base configuration이 좀 더 우위인것 같습니다.;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = Spring2WebConfiguration.class)
@WebAppConfiguration
public class HelloControllerTest {
    private MockMvc mvc;
    @Autowired
    WebApplicationContext context;



Posted by Y2K
,

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



Spring MVC의 구조

지금까지 Spring을 이용한 DB에 대한 접근법과 다루는 법에 대해서 알아보았습니다. 엄밀히 말하면 이 부분은 MVC pattern의 M에 해당되는 내용들입니다. Spring은 구조화된 MVC 구조를 제공하며, Layer 기반의 잘 정형화된 서비스 패턴을 제공합니다. Spring은 MVC를 기반으로 하는 Web Framework를 제공하고 이는 org.springframework.web 안에 제공되어 있습니다.
이제부터 사용할 package인 org.springframework.web에서는 C와 V에 대한 내용들을 다루고 있습니다.

Controller

간단하게 말해서, Controller는 URL과 상호동작하는 Class입니다.
/wpwoms/appuser/getshoplist 라는 URL이 호출되었을 때, Http Request가 연결되는 Class를 의미합니다.
기술적으로는 굉장히 어려운 영역입니다. 이는 Servlet container의 Http Request가 어떻게 해석이 되며, 이 해석된 Http Request에 따라 어떤 class의 어떤 method를 선택할 지에 대한 복잡한 연결을 계속해서 이어가야지 됩니다.
Controller는 기본적으로 다음과 같은 일을 합니다.
1. Servlet이 넘겨주는 HttpServletRequest를 처리한다.
2. Servlet으로 HttpServletResponse를 보내준다.
3. Cookie, Session 에 대한 동기화 작업을 지원한다.

View

View는 HTML 영역이라고 생각하시면 됩니다. 어찌보면 단순한 영역일수도 있지만... 이 부분이 어마어마한 노가다를 요구하는 부분입니다. ㅠ-ㅠ
View는 Controller가 보내주는 데이터를 Html로 표현하는 영역이라고 생각하면 됩니다.
MVC Model이 서로간에 하는 일을 간단히 표현하면 다음 그림과 같습니다.




Front Controller
기존 servlet application 작성시에, url에 각각의 servlet을 등록해서 사용하는 것을 알고 있습니다. 일반적인 MVC 구조의 Web Application은 Front Controller pattern이라고 해서, 가장 최 상단 Front Controller가 모든 Web의 Request를 처리합니다. 그리고, 처리된 Request에 따라 맞는 Controller를 찾아서 호출해주는 형식입니다.  Spring에서는 org.springframework.web.servlet.DispatcherServlet에서 FrontController를 담당합니다. 참고로, .NET에서는 ASP .NET MVC에서는 ControllerFactory가 이 일을 합니다.

Controller
org.springframework.web.servlet.DispatcherServlet에서 처리된 request가 전달되는 영역입니다. 여기에서 HTML의 경우, 화면에 보여줄 model을 생성 하고, 또는 REST API의 경우에는 보내질 객체를 결정하게 됩니다.

View
사용자, Client에게 전달될 내용입니다. Html이 될 수도 있고, JSON이 될 수도 있고, Excel File이 될 수도 있습니다.

model
MVC에서의 M과는 다른 개념입니다. 기존 MVC에서의 Model은 BL 또는 Persistance Layer의 각 model 또는 entity를 의미하지만, 이곳의 model은 View Model입니다. View에 표시되는 model은 Controller에서 작성이 되는 경우도 있고, Domain Model에서 넘겨온 값을 그대로 이용하는 경우도 있습니다. 기존에 Application의 데이터 흐름에서 이야기한 DTO, VO가 여기에 속하게 됩니다.


Spring MVC에서의 Request 처리 과정

Spring MVC는 Web Request를 다음과 같은 순서로 처리되게 됩니다. 



1. Request -> DispatcherServlet : Request가 처음 들어오게 됩니다.
2. DispatcherServlet -> Handler Mapping : DispatcherServlet은 Request를 분석하고 Mapping 중에서 Request와 동일한 Mapping을 찾아냅니다.
3. Handler Mapping -> DispatcherServlet : 찾아진 Handler Mapping을 DispatcherServlet에 전달해줍니다.
4. DispatcherServlet -> Controller : Handler Mapping에서 찾아진 Controller측에 Http Request를 전달해줍니다.
5. Controller -> DispatcherServlet : ModelAndView 객체를 보내줍니다. ModelAndView객체는 View의 이름과 View에 표시될 데이터를 가지고 있습니다.
6. DispatcherServlet -> View Resolver : View이름을 가지고 View를 처리하는 View Resolver에 ViewName을 전달합니다.
7. View Resolver -> DispatcherServlet : 이름에 맞는 View를 return 시켜줍니다.
8. DispatcherServlet -> View : View에 표시될 데이터를 가지고 있는 model을 보내줍니다.
9. View -> DispatcherServlet : model을 이용해서 View를 render 시키고, 그 결과를 DispatcherServlet에 보내줍니다.
10. DispatcherServlet -> Response : View로부터 받은 render된 결과를 Client에게 보내주게 됩니다.

위 그림과 순서는 머리에 익혀두고 있어야지 됩니다. Spring이 우리에게 감춰버리는 부분이기 때문에, 개발을 할때에는 자주 쓰이는 부분이 아니지만 디버그나 문제가 발생했을 때, 어떤 영역에서의 문제인지 확인할 필요가 있을 때 사용되는 지식입니다. 


Maven을 이용한 Hello World Web App

maven을 이용해서 Simple web application을 작성하는 법을 간단히 알아보도록 하겠습니다. 이 프로젝트는 전반적인 프로젝트들의 뼈대가 될 것입니다. 

Maven Project를 선택해줍니다.



maven-archetype-webapp을 선택해줍니다.


groupId와 artifact Id를 넣어주고, Project를 생성합니다.





지금 상태는 기본적으로 JRE1.5를 기반으로 한 Project가 구성이 되어있고, web application으로 eclipse에서 인식도 못하는 상태입니다. 프로젝트를 좀 손을 봐줘야지 됩니다.

pom.xml을 수정해서 JRE1.7기반으로 변경합니다.

       <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.0</version>
        <configuration>
          <source>1.7</source>
          <target>1.7</target>
        </configuration>
      </plugin>

Project에서 우클릭 > Property에 들어가서 Project Facets를 선택합니다.


Convert to faceted from... 을 클릭합니다. 

Dynamic Web Module과 JavaScript를 선택합니다.


하단에 나오는 Further configuration available 을 클릭합니다.

ContextRoot를 artifactId와 동일하게 설정하고, Context directory를 src/main/webapp 으로 수정하고, Generate web.xml deployment descriptor를 선택합니다. 



프로젝트가 다음 모습이 되는지 확인합니다.




다시 Project 우클릭 > Property에 들어가서, Deployment Assembly를 선택합니다.


Add를 눌러, Java Build Path Entities를 추가, Maven Dependencies를 추가합니다.

 


 /src/test/java를 제거합니다.
다음과 같이 Web Depolyment Assembly가 되어 있는지를 확인합니다.


Server에 추가 후, Hello World!가 나오는지 확인합니다.



이번에는 Tomcat이 아닌 jetty를 이용해서 실행해보도록 하겠습니다.
pom.xml > build > plugins 에 다음 항목을 추가합니다.

            <plugin>
                <groupId>org.eclipse.jetty</groupId>
                <artifactId>jetty-maven-plugin</artifactId>
                <version>9.0.1.v20130408</version>                
            </plugin>

추가후 mvn jetty:run 을 이용해서 jetty를 실행시켜주세요. 그리고 jetty는 이 버젼에 유의해서 사용해야지 됩니다. jetty 9.0.0 버전은 심각한 오류를 가지고 있기 때문에 절대로 사용해서는 안됩니다. 
jetty를 사용하는 경우에는 webapplication name이 없이, http://localhost:8080 으로만 접근이 가능합니다. 

Summary

maven을 이용해서 web application을 작성하는 법을 한번 알아봤습니다. maven으로 작업하는 경우에는 maven way 라고 하는 절대적인 폴더 위치를 비롯해서 프로젝트의 구성을 그대로 맞춰줘야지만 쉽게 사용할 수 있습니다. 물론, 위치들을 변경하는 방법역시 존재하지만 이와 같은 공통적인 방법을 통해서 구성하는 것이 좋습니다. 이 폴더의 구조에 대해서는 반드시 외우거나 숙지해주시길 바랍니다.


Posted by Y2K
,

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


java로 개발한 application을 배포를 할때는 주로 jar, war 형태로 배포를 하게 됩니다. 
이 둘은 완전히 동일한 형식입니다. 다만, war는 web application을 배포하는 형식이고 jar는 library나 일반 application을 배포하는 형식입니다. 

Java Application의 배포



생성하지 않은 폴더와 파일이 있는 것을 알 수 있습니다. 
META-INF 폴더가 바로 그것인데요. 폴더 안에는 build시에 사용한 pom 파일을 비롯해서 MANIFEST.MF 파일이 있는 것을 알 수 있습니다. 이 파일은 다음과 같은 정보를 포함합니다. 

# Manifest-Version : Manifest file version
# Build-By : Build user
# Build-Jdk : jdk version
# Created-By : Build tool

이 내용은 jar파일에 대한 manual이나 스팩을 기록하는 폴더입니다. 그리고 우리가 web-resource와 같은 정적인 resource를 배포할 때도 역시 META-INF 폴더를 이용하게 됩니다. jar 파일은 자신이 개발한 class를 가질수도 있고, 심지어 jar에 jre까지 포함하는 것까지 가능합니다. 다른 jar 역시 추가하는 것도 가능합니다.

그리고, jar 형태로 구성이 되는 경우, ClassLoader에 의해서 로드되는 객체들은 jar의 root에 위치하게 됩니다. 이 부분은 war와 jar의 가장 큰 차이를 가지고 오게 됩니다. 

이제 packaging을 jar가 아닌 war로 packaging을 하는 경우를 알아보도록 하겠습니다. 
war 폴더 구조는 다음과 같습니다. 


war의 기본정보와 static-resource를 저장한 META-INF 폴더의 경우에는 jar와 동일하게 만들어집니다. 그리고 또다른 폴더가 하나더 생깁니다. WEB-INF 폴더가 바로 그것인데요. 이 폴더는 다음 2개의 폴더를 같이 포함합니다. 

# lib - 외부 및 추가 jar가 위치하는 폴더
# classes - 개발된 application의 compile된 class 파일이 위치

war의 경우에는 ClassLoader에 의해서 로드되는 객체들은 classes 폴더를 기준으로 로드가 이루어지게 됩니다.

그리고, 이 안에는 매우 중요한 파일이 하나 들어가게 됩니다. 그것은 web.xml인데요. java web application의 구성은 기본적으로 WEB-INF/web.xml 에서 결정됩니다. web.xml은 필터, 서블릿, DB소스 등  web container가 구동하는데 이용되는 환경설정파일입니다. 서버가 처음 로딩될때 web.xml파일을 읽어들여 해당 환경설정에 대해 어플리케이션 배치를 하게 됩니다. 다른 말로 web.xml은 배치 서술자(deployment de-scriptor)라고도 합니다. 

web.xml에 들어가는 환경설정은 다음과 같은 것들이 존재합니다.

1. 필터정보 (매핑 포함)
2. 서블릿정보 (매핑 포함)
3. 웹 애플리케이션 정보
4. 세션정보
5. 세션정보가 소멸, 생성, 수정되는 것을 알려주는 리스너 정보
6. MIME매핑
7. welcomefile정보
8. errorPage 정보
9. url보호 정보
10. 인터프라이즈 빈의 홈레퍼런스 정보 (로컬 레퍼런스 정보 포함)
가 있습니다. 

이 항목들에 대해서 각각 알아보도록 하겠습니다.

1. 필터 (filter)

필터는 요청이 들어오면 URL 패턴을 분석해서 해당 패턴의 요청이 들어오면 해당 요청에 담긴 정보들을 프로그래머가 원하는 형태의 데이터로 가공해서 서버로 요청을 넘길 수 있습니다. servlet과 비슷한 개념으로 계속 요청을 감시하고있습니다가 url패턴에 해당하는 요청이 들어오게되면 해당 요청을 가로채서 원하는 데이터 형태로 가공한뒤 다시 요청을 서버로 보내는 역할을 하게 됩니다.. 따라서 서버내에서 사용될 데이터 또는 화면으로 다시 보낼 데이터의 형태를 프로그래머가 원하는 형태로 단일화 시킬 수 있습니다.

<filter>
     <filter-name>myRequest</filter-name>
     <filter-class>myFilter.util.myReqFilter</filter-class>
     <init-param>
          <param-name>myRequestFilter</param-name>
          <param-value>filterTest</param-value>
     </init-param>
</filter>

필터 이름과 클래스, 초기화 파라미터를 지정하게 됩니다.. myRequest라는 필터는 myFilter.util 페키지 안에 있는 myReqFilter를 호출하며 초기화 파라미터로 myRequestFilter의 이름을 가진 filterTest값을 가지고 filter를 호출할것입니다. filter를 사용할때 사용할 클래스는 반드시 Filter인터페이스를 implenebts받아 doFilter메소드를 반드시 오버라이드 해주어야 하며 메소드 실행순서는 init() -> doFilter() -> destroy() 순으로 구성됩니다. 이는 Servlet의 생명 주기와 동일하게 동작합니다. 

<filter-mapping>
     <filter-name>myRequest</filter-name>
     <url-pattern>*.doFilter</url-pattern>
</filter-mapping>

위에서 선언한 filter정보를 url패턴과 매핑하는 부분입니다.
어떠한 URL의 확장자로 .doFilter가 함께 넘어오면 myRequest필터를 호출하게 되고 해당 필터는 myFilter.util 페키지안에 있는 myReqFilter 를 호출하게 됩니다. url-pattern 대신 servlet-name이 올 수 있습닌다.

servlet-name이 들어오게 되면 해당 패턴에 맞는 모든 filter가 실행되고 나서 servlet을 호출하게 됩니다..
filter는 여러겹으로 사용할 수 있는데 필터 체인(Filter Chain)이라는 용어로 쓰입니다.


2. 서블릿 (Servlet)

필터와 비슷한 맥락의 기능입니다. 그렇지만 큰 차이를 가지고 옵니다. Filter의 경우에는 Response와 Request에 대한 stream의 처리를 담당하고, 이에 대한 실질적인 Action을 담당하는 것이 Servlet입니다. web.xml에 매핑되어져 있는 서블릿들은 해당 요청을 포함하여 url패턴을 분석하고 거기에 매핑되어져 있는 클래스를 호출하여 처리를 하게 됩니다.
지정 방법은 다음과 같습니다.

<servlet>
     <servlet-name>loginServlet</servlet-name>
     <servlet-class>myServlet.util.loginServlet</servlet-class>
</servlet>

위처럼 하나의 서블릿 클래스를 생성해두고 해당 클래스를 servlet-class라는 element를 지정하게 됩니다..
나중에 loginServlet을 호출하면 myServlet.util 페키지 안에있는 loginServlet클래스가 호출될것입니다.

<servlet-mapping>
     <servlet-name>loginServlet</servlet-name>
     <url-pattern>*.login</url-pattern>
</servlet-mapping>

 
url패턴과 해당 해당 패턴에 해당하는 url로 접근시 호출될 servlet을 설정하는 부분입니다.
메타문자로 *가 올 수 있고 확장자를 설정하게 됩니다..
나중에 *.login이라는 URL을 서버로 요청하게되면 loginServlet의 이름을 가진 서블릿을 호출하게 됩니다..
해당 서블릿은 위에서 myServlet.util.loginServlet 클래스를 매핑해두었으므로 해당 클래스가 호출되는 형태가 될것입니다.

Spring은 이곳에 DispatcherServlet이라는 Spring에서 제공하는 Servlet을 이용해서 Spring MVC에서 Request를 처리합니다. 예를 들어 Naver의 경우에는 *.nhn 이라는 url-pattern에 DispatcherServlet을 연결시켜두는 것이 일반적입니다. 
인터넷 서핑을 주로 하시다보면 *.do url을 간간히 보게 되는데요. 이것은 Spring의 2.5대 버젼에서 Spring에서 추천하던 url-pattern입니다. web.xml의 설정의 경우에는 개발자들이 copy-paste 신공을 펼치는 경우가 많기 때문에 이것을 계속해서 이용하게 되는 경우도 많지요.

3. 웹 어플리케이션 정보 (Web Application )

웹 어플리케이션 정보를 설정하는 부분으로

<display-name>webApplication</display-name>
<description>desc for webApplication</description>

으로, Web Application의 정보와 표시 이름을 적을 수 있습니다. 


4. 세션정보 ( Session )

Session의 timeout 및 공유 방법을 결정할 수 있습니다. 

<session-config>
    <timeout>20</timeout>
    <shared>true</shared>
</session-config>


5. 세션 리스너 정보 ( Session Listner )
Session이 연결되고, 제거되는 각각의 event에 연결되는 Listner에 대한 정보를 기술할 수 있습니다. 아래는 servlet에서 기본으로 제공하는 listener입니다. 

javax.servlet.ServletContextAttributeListener
이 리스너는 컨텍스트에 저장된 애트리뷰의 변화가 있었을 때 설정된 이벤트를 엔진이 자동으로 발생시키도록 합니다. 이벤트 감지를 얻어내기 위해서는 여러분들이 직접 작성한 리스너의 implemention클래스를 통해야 하는것은 물론이며, 아래의 리스너 모두 동일하게 설정됩니다.

javax.servlet.ServletContextListener
당신이 작성한 웹애플리케이션에서 컨텍스트를 이용하여 무언가를 저장하고 이용할 수 있는데 이 리스너의 작동은 그러한 컨텍스트에 대한 변경이 이루어졌을 때 자동으로 엔진이 감지하고 작성한 클래스의 이벤트를 발생시킵니다.

javax.servlet.http.HttpSessionActivationListener
request.getSession(true)같은 경우처럼 Session에 대한 내용이 새로 생성되어 activate되어졌을 때 발생하는 이벤트를 감지하는 리스너입니다.

javax.servlet.http.HttpSessionAttributeListener
HttpSession에 대한 애트리뷰트의 변경시 연결되어지는 리스너입니다.

javax.servlet.http.HttpSessionBindingListener
HttpSession에 대하여 클라이언트 세션정보에 대한 바인딩이 이루어졌을 경우 감지되는 리스너입니다. 

이 SessionListener를 상속받아 구현된 class에 대한 정보를 web.xml에 다음과 같이 사용가능합니다. 

<listener>
    <listener-class>SessionListener</listener-class>
</listener> 


6. MIME 매핑 (MIME Mapping)
web server에서 보내지는 각각의 파일 리소스에 대한 정보를 mapping하는 영역입니다. 예를 들어 JSON의 경우 application/json 형태임을 web browser에게 알리는 등의 일을 수행합니다. 이것이 정상적으로 설정되어 있지 않으면 hwp와 같은 파일 포멧을 다운받지 못하고, browser에서 직접 열게 되는 식의 오동작을 발생시키게 됩니다. 아래와 같은 형식으로 설정이 가능합니다. 

    <mime-mapping>
        <extension>zip</extension>
        <mime-type>application/zip</mime-type>
    </mime-mapping>
    <mime-mapping>
        <extension>hwp</extension>
        <mime-type>application/unknown</mime-type>
    </mime-mapping>

7. welcomefile 정보 ( welcomeFile )
welcomeFile은 서버에 접속하면 가장 최초로 보여줄 파일을 지정하는 부분입니다.

  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>

서버를 구동한 후 http://localhost:8080/myWeb/ 로 접속을 하게되면 index.html이 실행될것입니다. html파일이 없다면 index.jsp가 실행됩니다.

8. errorPage 정보( ErrorPage )

특정 요청에 대해 error가 반환될때 해당 페이지를 보여주도록 설정이 가능합니다.

<error-page>
  <error-code>404</error-code>
  <location>/errors/404.jsp</location>
</error-page>
<error-page>
  <error-code>java.lang.NullPointerException</error-code>
  <location>/errors/badcode.jsp</location>
</error-page>


9. url보호 정보 ( URL Security )

로그인 및 각 URL에 대한 접근 정책을 결정할 수 있습니다.  이 때 사용되는 Security 정책은 servlet-container의 정책에 따르게 되기 때문에 Web Application에서 사용하기에는 조금 힘듭니다.
tomcat에서는 conf/tomcat-user.xml 에 사용자가 정의되어 있습니다.  tomcat manager에 등록되어 있는 default security 정책은 다음과 같습니다. 

<security-constraint>
  <display-name>Name String</display-name>
  <web-resource-collection>
    <web-resource-name>GETServlet</web-resource-name>
    <description>some description</description>
    <url-pattern>/servlet/*</url-pattern>
    <http-method>GET</http-method>
  </web-resource-collection>
  <auth-constraint>
    <description>some description</description>
    <role-name>*</role-name>
  </auth-constraint>
  <user-data-constraint>
     <description>some description</description>
     <transport-guarantee>INTEGRAL</transport-guarantee>
  </user-data-constraint>
</security-constraint>
<login-config>
  <auth-method>FORM</auth-method>
  <realm-name>MemoryRealm</realm-name> 
  <form-login-config>
    <form-login-page>login.jsp</form-login-page>
    <form-error-page>notAuthenticated.jsp</form-error-page>
  </form-login-config>
</login-config>
<security-role>
  <description> some description</description>
  <role-name>administrator</role-name>
</security-role>


12. 인터프라이즈 빈의 홈레퍼런스 정보 (로컬 레퍼런스 정보 포함) ( Interprize Bean's Home Reference [Local Reference])

이제는 과거의 유산이 되어버린 ejb에 대한 설정 정보가 위치하는 곳입니다. ejb에 대한 정보 설정은 다음과 같이 설정됩니다.

<env-entry>
  <description>some description</description>
  <env-entry-name>MinimumValue</env-entry-name>
  <env-entry-value>5</env-entry-value>
  <env-entry-type>java.lang.Integer</env-entry-value>
</env-entry>
<ejb-ref>
  <description>some description</description>
  <ejb-ref-name>Employee Bean</ejb-ref-name>
  <ejb-ref-type>EmployeeBean</ejb-ref-type>
  <home>com.foobar.employee.EmployeeHome</home>
  <remote>com.foobar.employee.Employee</remote>
</ejb-ref>



web.xml 등록법

servlet의 변화에 따라 web.xml은 많은 확장이 있었습니다. web.xml의 정보는 다음 3가지 방법으로 표현될 수 있습니다. 

1. WEB-INF/web.xml 을 이용해서 등록하는 방법

가장 많이 사용되고 있으며, servlet 1.0부터 지금까지 구현된 방법입니다. 가장 대중적입니다. 

2. META-INF/web-fragment.xml 을 이용하는 방법

servlet 3.0 부터 지원되는 방법입니다. web.xml은 web application에 종속되는 방법입니다. web application 뿐 아니라, jar로 개발된 project에서 가지고 있는 META-INF 폴더 안의 web-fragment.xml을 이용해서 web을 구동하는 방법을 지원하고 있습니다. web-fragment.xml은 web.xml과 내용이 동일합니다. 이 방법이 나오게 된 이유는 Servlet 3.0에서부터는 web container를 포함한 설치형 war가 배포가 가능합니다. 지금까지는 web application을 tomcat과 같은 web container에 배포하는 것이 일반적이였지만, web container를 포함한 한개의 web application으로 구동하는 방법을 servlet 3.0에서 이제는 지원하고 있습니다.

3. javax.servlet.ServletContainerInitializer interface를 구현한 객체를 이용하는 방법

servlet 3.0 부터 지원되는 방법입니다. web.xml이 없이, application에서 작성한 ServletContainerInitializer를 구현하는 것으로 web.xml 대신 페이지를 작성할 수 있도록 지원하고 있습니다. 

3가지 방법중 3번의 방법이 조금 재미있습니다. ServletContainerInitializer를 구현한 객체를 이용하게 되면, 다음과 같은 설정들만 사용 가능합니다. 
* Listener 구성
* filter 구성
* Session Listener 구성
* ejb 구성

web.xml의 핵심이 구현되긴하지만, 자주 사용되는 다음 항목들이 제공되지 않습니다. 
* session-config
* error-page

이 두항목을 사용하기 위해서는 web.xml과 ServletContainerInitializer를 구현한 객체를 같이 사용해주면 됩니다. 그럼 ServletContainer는 web.xml을 먼저 로딩 후, 객체를 로드해서 사용하게 됩니다. 


Posted by Y2K
,

* 사내 강의용으로 사용한 자료를 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 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 Y2K
,

15. Spring과 iBatis

Java 2013. 9. 11. 14:18

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



Spring에서 myBatis를 사용하기 위해서는 Hibernate는 Spring이 Hibernate에 대한 SessionFactory, DataSource를 제공하고 있는 것에 비해, 오히려 mybatis 측에서 Spring에 대한 library를 제공하고 있습니다. 

pom.xml에 다음과 같은 내용을 추가해주시길 바랍니다. 

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.1.1</version>
</dependency>

pom.xml에 적용후, command창에서 mvn dependency:tree 를 한번 실행시켜보시면 다음과 같은 결과를 볼 수 있습니다. 




기본적으로 mybatis-spring은 spring 3.1RELEASE를 가지고 개발된 jar입니다. 따라서, mybatis-spring을 참조하는 즉시, spring 3.1Release가 바로 추가가 됩니다. 그런데, 저희 프로젝트는 기본적으로 Spring 3.2RELEASE를 기반으로 구성되어 있습니다. 이런 경우 어떻게 해야지 될까요?
다행히도, Spring은 하위 호환성을 100% 맞추고 있습니다. 따라서, mybatis-spring에서 사용하고 있는 Spring 3.1 module을 모두 제거하고, Spring 3.2 RELEASE를 모두 사용하도록 maven의 dependency를 조절해줘야지 됩니다. maven에서 dependency 된 jar안에 포함된 다른 module을 제거하는 것은 다음과 같은 포멧으로 pom.xml을 수정해줘야지 됩니다.

이러한 경우에 pom.xml을 수정하는 방법은 2가지가 있습니다. 

1. 각 dependency에서 각 library들을 exclude 시켜주는 방법
2. dependencyManagement에서 각 library들의 version을 관리해주는 방법

개인적으로는 2번째의 방법이 좀 더 나은 것 같습니다. dependencyManagement를 이용해서 mybatis-spring의 dependency 충돌을 해결한 pom.xml의 일부입니다. 

   <repositories>
        <repository>
            <id>mybatis-snapshot</id>
            <name>MyBatis Snapshot Repository</name>
            <url>https://oss.sonatype.org/content/repositories/snapshots</url>
        </repository>
    </repositories>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>3.2.1.RELEASE</version>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>3.2.1.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-orm</artifactId>
                <version>3.2.1.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-tx</artifactId>
                <version>3.2.1.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>3.2.1.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>3.2.1.RELEASE</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.1.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.22</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.1.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <scope>test</scope>
        </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>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib-nodep</artifactId>
            <version>2.2.2</version>
        </dependency>
    </dependencies>

이제 dependency를 다시한번 확인해보도록 하겠습니다. 

mybatis-spring에서 의존하고 있던 jar들은 모두 제거가 된 것을 알 수 있습니다. 그리고 Spring에 필요한 jar들이 모두 추가 됨을 볼 수 있습니다.

마지막으로 applicationContext.xml을 추가하도록 하겠습니다. myBatis는 기본적으로 spring에서 제공하는 DataSource를 그대로 이용할 수 있습니다. DataSource를 그대로 이용한다는 것은 TransactionManager를 이용한 @Transactional 역시 사용이 가능하다는 뜻입니다. 지금까지 해왔던 내용대로 설정을 할 수 있습니다. 다만 차이가 있다면 Spring을 사용하지 않고 myBatis를 이용할 때는 SqlSession을 SqlSessionFactory에서 직접 얻어오는 방식을 채택했습니다. 그렇지만, Spring을 이용하는 경우, mybatis-spring에서 제공하는 SqlSessionFactoryBean과 SqlSessionFactoryTemplage을 이용해서 작업을 한다는 차이 이외에는 테스트 코드 자체도 큰 차이가 없습니다.

다음은 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"
  xmlns:tx="http://www.springframework.org/schema/tx"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd">
  <context:property-placeholder location="classpath:spring.property" />
  <bean id="dataSource"
    class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="${jdbc.driver}" />
    <property name="url" value="${jdbc.url}" />
    <property name="username" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
  </bean>
  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="configLocation" value="classpath:mybatis.xml" />
  </bean>
  <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
    <constructor-arg ref="sqlSessionFactory" />
  </bean>
  <bean id="transactionManager"
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
  </bean>
  <tx:annotation-driven transaction-manager="transactionManager" />
</beans>

dataSource와 transactionManager는 JdbcTemplate을 사용할때와 완전히 동일합니다. 그리고 Hibernate에서 사용하던 LocalSessionFactoryBean 대신에 SqlSessionFactoryBean과 SqlSessionTemplate를 사용하는 차이만을 가지고 있습니다. 

이제 구성된 설정을 이용해서 각 Dao interface들을 얻어보도록 하겠습니다. 

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
@Transactional
public class BookDaoTest {
    @Autowired
    private SqlSessionTemplate sqlSessionTemplate;
    private BookDao bookDao;
    
    @Before
    public void setUp() {
        assertThat(sqlSessionTemplate, is(not(nullValue())));
        bookDao = sqlSessionTemplate.getMapper(BookDao.class);
        bookDao.deleteAll();
        assertThat(bookDao.countAll(), is(0));
    }
    
    @Test
    public void add() {
        List<Book> books = getBooks();
        for(Book book : books) {
            bookDao.add(book);
        }
    }
    
    @Test
    public void getAll() {
        List<Book> books = getBooks();
        for(Book book : books) {
            bookDao.add(book);
        }
        List<Book> allBooks = bookDao.getAll();
        for(Book book : allBooks) {
            System.out.println(book);
        }
    }

기존에는 각각의 session에서 commit를 실행시켜줬지만, 이제는 @Transactional을 이용한 세련된 Transaction을 하고 있는 것을 볼 수 있습니다. 사용법 역시 큰 차이가 있지 않으며 Spring과 interface를 조합한 사용 계층에서의 큰 변경 없이 코드의 기술을 완전히 변경을 시킬 수 있는 것을 알 수 있습니다. 
코딩하는 연습을 하는 시간을 갖겠습니다. 나머지 코드들을 모두 작성해주세요. 


매우 간편한 설정 및 사용의 편의성. mybatis가 현업에서 가장 많이 사용되고 있는 이유가 보이시나요? 이렇게 쉬울수는 없다. 라는 느낌이 맞을 정도입니다. 


Summary

지금까지 구성된 bookstore를 myBatis-spring을 이용해서 구성해주세요. 



Posted by Y2K
,

Spring 4.0 에서 제공되는 핵심 기능 변경사항중 가장 주목할 점이 있다면 WebSocket의 지원입니다.


일단 Java에서는 Java EE 7에서 WebSocket에 대한 기본 API는 모두 구성이 마쳐져 있습니다. 당장 WebSocket을 지원하는 Web Page를 구성하기 위해서는 다음과 같은 조건들이 필요합니다.


1. Java EE 7 이상 지원

2. 최신 WAS 지원 (tomcat 8 이상, jetty 9.0.4 이상)


Spring에서는 WebSocket을 다음과 같은 방법으로 지원하고 있습니다.


1. @ServerEndPoint를 이용한 Java 기본 API

2. WebSocketHandler를 이용한 구성 - Spring WebSocket API


Spring WebSocket API의 경우, Java 기본 API와는 구성이 다릅니다. 이와 같은 구성을 갖게 되는 이유는 SocketJS와 같은 WebSocket을 이용하는 다른 API들을 사용할 수 있도록 한번 Wrapping을 거친 구성을 가지게 하는 것이 목표이기 때문입니다.. Spring WebSocket API의 경우, WebSocketHandler가 가장 핵심이 되고, 이를 이용한 코드 구성에 대해서 알아보도록 하겠습니다. 


먼저, pom.xml에 필요한 dependency를 설정합니다.

         <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-websocket</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>


websocket의 경우, servlet 3.0을 사용해야지 되고, websocket에 대한 dependency는 다음과 같습니다.


        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.websocket</groupId>
            <artifactId>javax.websocket-api</artifactId>
            <version>1.0</version>
        </dependency>


간단한 EchoService를 지원하는 WebSocket 지원 WebPage를 구성합니다. 그에 따른 WebSocketHandler는 TextWebSocketHandlerAdapter를 이용합니다. 여담이지만, Spring에서 Adapter라는 접미사가 붙은 객체들은 대부분 상속을 통해서 좀더 편하게 설정들을 할 수 있도록 도와주는 Spring에서 제공하는 일종의 Helper Class 또는 Parent Class 들이라고 할 수 있습니다.


WebSocketHandlerAdapter에서는 다음 3개의 method를 주목할 필요가 있습니다. 


1. afterConnectionEstablished(WebSocketSession session)

: WebSocket connection이 발생되었을 때, 호출되는 method입니다. connection open이 된 후기 때문에, 해줘야지 될 일들을 처리하면 됩니다. 


2. afterConnectionClosed(WebSocketSession session, CloseStatus status)

: WebSocket connection이 끊겼을 때, 호출되는 method입니다. connection close가 된 후, 일을 처리하면 됩니다. 


3. handleMessage(WebSocketSession session, WebSocketMessage<?> message)

: 핵심적인 method입니다. 실질적인 통신 method입니다. socket.accept() 후에 onMessage 에서 처리될 일들을 이곳에서 coding하면 된다고 생각하면 됩니다. 


한번 코드를 확인해보도록 하겠습니다. 


public class EchoWebSocketHandler extends TextWebSocketHandlerAdapter {

    @Override
    public void handleMessage(WebSocketSession session, WebSocketMessage<?> message) throws Exception {
        String payloadMessage = (String) message.getPayload();
        session.sendMessage(new TextMessage("ECHO : " + payloadMessage));
    }

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        // Connection이 구성된 후, 호출되는 method
        super.afterConnectionEstablished(session);
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        // Connection이 종료된 후, 호출되는 method
        super.afterConnectionClosed(session, status);
    }
}


WebSocket을 지원하는 Handler의 구성이 모두 마쳐진 후, WebSocketHandler를 Spring @MVC에 통합하기 위해서는 Config를 다음과 같이 구성합니다. 


@Configuration
@EnableWebMvc
@EnableWebSocket
public class WebConfig extends WebMvcConfigurerAdapter implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        // WebSocket을 /echo 에 연결합니다.
        registry.addHandler(echoHandler(), "/echo");

        // SocketJS 지원 url을 /socketjs/echo에 연결합니다.
        registry.addHandler(echoHandler(), "/socketjs/echo").withSockJS();
    }

    @Bean
    public WebSocketHandler echoHandler() {
        return new EchoWebSocketHandler();
    }

    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
}

매우 단순한 구조로 Config를 구성할 수 있습니다. Config에서 주목할 것은 WebSocketConfigurer interface입니다. 이 interface를 통해서 WebSocket Handler를 아주 쉽게 구성할 수 있습니다. 


마지막으로 web.xml을 대신할 DispatcherWebApplicationIntializer 입니다. 특별한 것은 없고, Servlet Configuration에서 만들어진 WebConfig.class를 반환합니다. 


public class DispatcherServletInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return null;
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class<?>[] { WebConfig.class };
    }

    @Override
    protected String[] getServletMappings() {
        return new String[] { "/" };
    }

    @Override
    protected void customizeRegistration(Dynamic registration) {
        registration.setInitParameter("dispatchOptionsRequest", "true");
    }

}


이제 WebSocket을 테스트 하기 위해 간단한 HTML Page를 구성해보도록 하겠습니다.


echo.html은 다음과 같이 구성할 수 있습니다. 


<!DOCTYPE html>
<html>
<head>
    <title>WebSocket/SockJS Echo Sample (Adapted from Tomcat's echo sample)</title>
    <style type="text/css">
        #connect-container {
            float: left;
            width: 400px
        }

        #connect-container div {
            padding: 5px;
        }

        #console-container {
            float: left;
            margin-left: 15px;
            width: 400px;
        }

        #console {
            border: 1px solid #CCCCCC;
            border-right-color: #999999;
            border-bottom-color: #999999;
            height: 170px;
            overflow-y: scroll;
            padding: 5px;
            width: 100%;
        }

        #console p {
            padding: 0;
            margin: 0;
        }
    </style>

    <script src="http://cdn.sockjs.org/sockjs-0.3.min.js"></script>

    <script type="text/javascript">
        var ws = null;
        var url = null;
        var transports = [];

        function setConnected(connected) {
            document.getElementById('connect').disabled = connected;
            document.getElementById('disconnect').disabled = !connected;
            document.getElementById('echo').disabled = !connected;
        }

        function connect() {
            if (!url) {
                alert('Select whether to use W3C WebSocket or SockJS');
                return;
            }

            ws = (url.indexOf('socketjs') != -1) ? 
                new SockJS(url, undefined, {protocols_whitelist: transports}) : new WebSocket(url);

            ws.onopen = function () {
                setConnected(true);
                log('Info: connection opened.');
            };
            ws.onmessage = function (event) {
                log('Received: ' + event.data);
            };
            ws.onclose = function (event) {
                setConnected(false);
                log('Info: connection closed.');
                log(event);
            };
        }

        function disconnect() {
            if (ws != null) {
                ws.close();
                ws = null;
            }
            setConnected(false);
        }

        function echo() {
            if (ws != null) {
                var message = document.getElementById('message').value;
                log('Sent: ' + message);
                ws.send(message);
            } else {
                alert('connection not established, please connect.');
            }
        }

        function updateUrl(urlPath) {
            if (urlPath.indexOf('socketjs') != -1) {
                url = urlPath;
                document.getElementById('sockJsTransportSelect').style.visibility = 'visible';
            }
            else {
              if (window.location.protocol == 'http:') {
                  url = 'ws://' + window.location.host + urlPath;
              } else {
                  url = 'wss://' + window.location.host + urlPath;
              }
              document.getElementById('sockJsTransportSelect').style.visibility = 'hidden';
            }
        }

        function updateTransport(transport) {
          transports = (transport == 'all') ?  [] : [transport];
        }
        
        function log(message) {
            var console = document.getElementById('console');
            var p = document.createElement('p');
            p.style.wordWrap = 'break-word';
            p.appendChild(document.createTextNode(message));
            console.appendChild(p);
            while (console.childNodes.length > 25) {
                console.removeChild(console.firstChild);
            }
            console.scrollTop = console.scrollHeight;
        }
        function clear() {
            $('#message').html('');
        }
    </script>
</head>
<body>
<div>
    <div id="connect-container">
        <input id="radio1" type="radio" name="group1" onclick="updateUrl('/tutorial01/echo');">
            <label for="radio1">W3C WebSocket</label>
        <br>
        <input id="radio2" type="radio" name="group1" onclick="updateUrl('/tutorial01/socketjs/echo');">
            <label for="radio2">SockJS</label>
        <div id="sockJsTransportSelect" style="visibility:hidden;">
            <span>SockJS transport:</span>
            <select onchange="updateTransport(this.value)">
              <option value="all">all</option>
              <option value="websocket">websocket</option>
              <option value="xhr-polling">xhr-polling</option>
              <option value="jsonp-polling">jsonp-polling</option>
              <option value="xhr-streaming">xhr-streaming</option>
              <option value="iframe-eventsource">iframe-eventsource</option>
              <option value="iframe-htmlfile">iframe-htmlfile</option>
            </select>
        </div>
        <div>
            <button id="connect" onclick="connect();">Connect</button>
            <button id="disconnect" disabled="disabled" onclick="disconnect();">Disconnect</button>
        </div>
        <div>
            <textarea id="message" style="width: 350px">Here is a message!</textarea>
        </div>
        <div>
            <button id="echo" onclick="echo();" disabled="disabled">Echo message</button>
        </div>
    </div>
    <div id="console-container">
        <div id="console"></div>
    </div>
</div>
</body>
</html>


이제 구성된 Page의 테스트를 위해 maven jetty를 build 항목에 추가합니다. 


    <build>
        <finalName>${project.artifactId}</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <failOnMissingWebXml>false</failOnMissingWebXml>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>2.5</version>
                <configuration>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-eclipse-plugin</artifactId>
                <version>2.8</version>
                <configuration>
                    <downloadSources>true</downloadSources>
                    <downloadJavadocs>true</downloadJavadocs>
                    <wtpversion>2.0</wtpversion>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.eclipse.jetty</groupId>
                <artifactId>jetty-maven-plugin</artifactId>
                <version>9.0.4.v20130625</version>
                <configuration>
                    <webApp>
                        <contextPath>/${project.artifactId}</contextPath>
                    </webApp>
                </configuration>
            </plugin>
        </plugins>
    </build>


구성후, mvn jetty:run 명령어를 통해서 실행이 가능합니다. 


websocket-tutorial01.zip





Posted by Y2K
,