1장. 사용자 관리 프로젝트로 알아본 스트럿츠 탄생 배경

Summary : 스트럿츠 프레임워크 워크북의 1장 원고를 통하여 스트럿츠 탄생 배경에 대하여 총 5번의 강좌를 통하여 알아본다. 이번 강좌에서는 앞의 강좌에서만든 모델을 바탕으로 사용자 관리 프로젝트를 완성하겠다. 단, 개발 방법은 스트럿츠 프레임워크를 기반으로 사용자 관리 프로젝트를 완성하겠다.

5. 스트럿츠 프레임워크를 이용하여 개발

모델 2로 개발하려는 시도가 점차 증가하고 있지만 재사용성의 부족이라는 한계를 느끼고 많은 개발자들이 모델 2를 포기하는 경우를 종종 보아왔다. 처음에는 새로운 개발 방식을 적용하여 개발하겠다는 생각에 자신감을 가지고 시작하지만 더디 진행되는 프로젝트를 보면서 포기할 수 밖에 없었던 것으로 생각한다. 모델 2에서 해결해야할 과제는 모델 2로 개발할 경우 추가개발해야 부분들에 대한 재사용성이였다. 이러한 재사용성을 강화하여 모델 2에 기반한 프레임워크가 등장하게 되었으며, 그 중의 하나가 아파치 그룹에서 개발한 스트럿츠이다.

이 절에서는 스트럿츠를 이용하여 사용자 관리 프로젝트를 완성하겠다. 또한 스트럿츠가 모델 2에서 재사용가능도록 구현한 기능들에 어떠한 것이 있는지 살펴보도록 하겠다. 마지막으로 스트럿츠를 이용하여 개발할 때의 장점과 단점에 대해서도 살펴보도록 하겠다.

참고사항

최근 프레임워크라는 말을 많이 사용하고 있다. 사실 대부분의 개발자들이 프레임워크에 대한 정확한 개념없이 사용하는 것 또한 사실이다. 사실 프레임워크를 한마디로 정의한다는 것 또한 다소 무리가 있어 보인다. 프레임워크에 대하여 사람에 따라 다양하게 정의하고 있지만 공통적으로 포함하고 있는 의미는 비슷하다. 대부분의 프레임워크 정의에서 내포하고 있는 의미는 "애플리케이션 개발에 바탕이 되는 템플릿과 같은 역할을 하는 클래스들과 인터페이스의 집합"이다. 즉, 프로그램의 전체적인 구조와 흐름을 확정 지으며, 프로그래머가 정의해야할 함수의 이름까지도 결정짓는 역할을 한다.

자카르타 스트럿츠 프로그래밍 책에서 제시하는 프레임워크가 가지는 성질은 다음과 같다.

프레임워크는 특정 개념들의 추상화를 제공하는 여러 클래스나 컴포넌트로 구성된다.

프레임워크는 이렇나 추상적인 개념들이 문제를 해결하기 위해 같이 작업하는 방법을 정의한다.

프레임워크 컴포넌트들은
재사용이 가능하다.

프레임워크는 좀 더 높은 수준에서 패턴들을 조직화한다.

자카르타 스트럿츠 프로그래밍 책 36페이지에서 인용한 내용이다.

5.1 스트럿츠 프레임워크란?

스트럿츠는 모델2에서 재사용성이 부족했던 많은 부분들을 재사용이 가능하도록 미리 구현해 놓은 프레임워크이다. 웹 애플리케이션을 만들기 위해 필요한 많은 부분들을 미리 만들어 놓았기 때문에, 서블릿과 JSP 기반하에서 개발하는 웹 애플리케이션의 개발 기간을 상당부분 단축시키는 효과를 가져올 수 있다.

스트럿츠는 아파치 자카르타 프로젝트에서 앤트(Ant), Log4J, 톰캣(Tomcat)과 더불어 가장 유명하고 성공한 프로젝트중의 하나이다. 아파치 자카르타 프로젝트들 모두가 그렇지만, 스트럿츠 또한 오픈소스로 개발되고 있기 때문에 스트럿츠를 이용하여 웹 애플리케이션을 개발한다고 할지라도 추가 개발 비용은 발생하지 않는다.

모델 2에서 스트럿츠로 발전하면서 제일 크게 달라진 부분은 UserCommandFactory부분이다. 모델 2의 UserCommandFactory에는 수 많은 if/else절이 존재했다. 프로젝트가 커지면 커질수록 더 많은 if/else를 가지는 구조로 작성되어 있었다. 스트럿츠에서는 이 부분을 XML을 통하여 해결했다. 다음 장에서 더 자세하게 살펴보겠지만 스트럿츠는 JSP와 Action클래스 사이의 매핑을 소스가 아닌 XML을 이용하여 해결하고 있다. 그렇기 때문에 새로운 Action클래스가 추가될 경우 소스의 수정없이 XML파일에 JSP와 Action클래스를 매핑해주면 되는 방식이다.

이를 제외하고 스트럿츠의 구조는 [그림 1-13]에서 본 모델2의 구조와 유사하다. 스트럿츠가 재사용성에 중점을 둔 부분은 컨트롤러 부분이다. [그림 1-15]을 통해 스트럿츠의 구조를 살펴보도록 하자.

[그림 1-15]는 스트럿츠를 이용하여 클라이언트의 요청을 처리하는 과정을 보여주고 있다. 위에서 보여주는 클래스 이외에도 무수히 많은 클래스들이 웹 애플리케이션 개발을 위하여 있지만 [그림 1-15]는 스트럿츠에서 하나의 요청을 처리하기 위하여 중심이 되는 클래스들만 보여주고 있다.

[그림 1-13]의 모델 2와 비교하여 가장 큰 차이점은 UserCommandFactory가 없어졌다는 것이다. 스트럿츠에서 UserCommandFactory역할을 하는 부분은 struts-config.xml이다. 이 XML파일이 JSP와 Action클래스를 매핑하는 역할을 한다. 두번째 큰 차이점은 ActionForm 클래스가 추가된 것이다. 모델 2에서는 JSP에서 전달되는 모든 인자들을 각각의 Action클래스에서 일일이 코딩해주어야 했다. 스트럿츠에서는 인자를 받아 처리하는 부분의 재사용성을 위하여 ActionForm 클래스를 두었다. 그 외 ActionServlet, Action, ActionForward는 모델 2와 같은 역할을 한다.

이 절에서는 스트럿츠의 기본적인 구조를 여기까지 이해하면 된다. 스트럿츠에 대한 자세한 내용은 다음 장에서 다루도록 하겠다. 이번 장에서는 스트럿츠가 모델 2에 기본을 두고 있다는 것을 이해하는 것이 중요하다. 사실 스트럿츠를 이용하여 하나의 요청을 처리하는 과정을 이해하는 것이 스트럿츠를 이해하는데 제일 중요한 부분이다.

스트럿츠가 [그림 1-15]와 같은 구조로 이루어져 있는지를 예제소스를 통하여 더 자세하게 이해할 수 있도록 해보자.

5.2 스트럿츠 프레임워크를 이용하여 사용자 관리 프로젝트 완성.

스트럿츠에서 클라이언트의 요청을 처리하는 초기 진입점은 ActionServlet이 담당하고 있다. 모델 2에서는 UserServlet이나 또 다른 서블릿을 필요할 때마다 새로 작성할 필요가 있지만 스트럿츠에서는
ActionServlet하나만을 이용하여 모든 요청을 처리하는 하는 것이 가능하다. 이것을 가능하게 하는 또 하나의 파일이 struts-config.xml이다. struts-config.xml 설정 파일은 JSP와 Action클래스들의 매핑 정보를 저장하고 있기 때문에 ActionServlet은 이 정보를 바탕으로 클라이언트가 요청을 할 경우 사용할 Action클래스를 찾을 수 있는 방식이다.

이 절에서 ActionServlet을 살펴 볼수도 있겠으나 ActionServlet이 처리하는 과정이 생각보다 복잡하기 때문에 이 절에서는 간단히 ActionServlet이 담당하고 있는 역할에 대해서만 살펴보도록 하겠다. ActionServlet에 대한 자세한 내용은 다음 장에서 살펴보도록 하겠다.

ActionServlet이 기본적으로 담당하고 있는 역할은 앞절에서 살펴본 모델 2의 UserServlet과 같은 역할을 한다. 첫째, 클라이언트의 요청을 처음 받아들이는 역할을 한다. 둘째, 요청에 해당하는 Action클래스를 찾아 실행한다. 셋째, Action클래스를 실행하고 반환되는 ActionForward정보를 바탕으로 이동할 다음 페이지를 결정한다. 이상의 세가지는 모델2의 UserServlet과 같다.

하지만 ActionServlet위 세가지 이외에 수행하는 부분이 있다. struts-config.xml에 JSP와 Action클래스에 매핑 정보가 있다는 것은 알고 있다. 그러나 클라이언트의 요청이 있을 때마다 struts-config.xml파일을 읽어 원하는 정보를 얻기 위해서는 실행속도의 급격한 저하가 발생한다. 따라서 스트러츠에서는 웹 애플리케이션이 처음 시작할 때 struts-config.xml의 정보를 한번만 읽어 메모리에 저장하는 방식을 사용하고 있다. 이 같이 struts-config.xml을 읽어 초기화하는 작업을 ActionSerlvet이 담당하고 있다. ActionServlet은 클라이언트의
요청이 있을 때 메모리에 저장되어 있는 곳에서 매핑 정보를 얻어오기 때문에 실행속도의 저하에 큰 문제가 없다.

ActionServlet에 이 같은 작업이 하나 더 추가됨으로 인해 web.xml도 모델 2에서 보았던 web.xml에 추가로 설정되는 부분이 있다. 스트럿츠를 사용하는 애플리케이션의 web.xml을 보면 다음과 같다.

<?xml version="1.0" encoding="UTF-8"?>
<web-app>    
	<servlet>        
		<servlet-name>action</servlet-name>        
		<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>        
		<init-param>            
			<param-name>config</param-name>            
			<param-value>/WEB-INF/struts-config.xml</param-value>        
		</init-param>        
		<init-param>            
			<param-name>debug</param-name>            
			<param-value>3</param-value>        
		</init-param>        
		<init-param>            
			<param-name>detail</param-name>            
			<param-value>3</param-value>        
		</init-param>        
		<load-on-startup>1</load-on-startup>    
	</servlet>    
	<servlet-mapping>        
		<servlet-name>action</servlet-name>        
		<url-pattern>*.do</url-pattern>    
	</servlet-mapping>
</web-app>

[예제 1-15]를 보면 [예제 1-7]에서 살펴본 모델 2의 web.xml과 거의 비슷하다. UserServlet은 web.xml에서 초기 인자를 전달하지 않았지만 ActionServlet에는 여러 개의 초기 인자를 전달할 수 있다. 그 중 유독 눈에 띄는 부분은 struts-config.xml을 초기 인자로 전달한다는 것이다. 이 의미는 만약 struts-config.xml이외에 다른 이름으로 스트럿츠 설정 파일을 사용하고 싶다면 web.xml에서 변경해 주기만 하면 된다는 것이다.

또 하나 다른 점은 태그를 사용한다는 것이다. 이 태그의 의미는 애플리케이션이 시작할 때 ActionServlet의 init() 메소드를 호출하여 초기화를 진행하겠다는 뜻이다. 이 과정을 통하여 struts-config.xml의 모든 정보가 객체로 변환되어 메모리에 저장되었다가 이후에 재사용된다. 마지막으로 확장자는 *.do로 사용하겠다는 정보를 명시하고 있다.

web.xml에 대한 더 자세한 정보를 알고자 하는 개발자들은 자카르타 스트럿츠 프로그래밍 의 110페이지를 참조하기 바란다.

이상으로 스트럿츠를 사용하기 위한 기본 설정은 마쳤다. 스트럿츠는 모델 2 방식의 웹 애플리케이션을 개발하기 위한 기본 클래스들을 모두 만들어 놓았기 때문에 web.xml의 설정만하면 된다. 그 후 계속되는 작업은 Action클래스, ActionForm클래스의 개발과 개발된 클래스들을 struts-config.xml에 설정하는 것이다.

스트럿츠에서는 클라이언트로부터 전달되는 인자 또한 자동으로 객체에 저장할수 있도록 제공한다고 했다. 이것을 담당하는 클래스가 ActonForm클래스를 상속하는 클래스들이다. 사용자 관리 프로젝트를 위해서는 사용자 정보를 저장하는 UserForm 클래스를 생성하였다.

package net.javajigi.struts.form;

import javax.servlet.http.HttpServletRequest;

import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionMapping;

/** 
 * XDoclet definition:
 * @struts:form name="userForm"
 */
public class UserForm extends ActionForm {

	// --------------------------------------------------------- Instance Variables

	/** password property */
	private String password = null;

	/** userId property */
	private String userId = null;

	/** email property */
	private String email = null;

	/** name property */
	private String name = null;

	// --------------------------------------------------------- Methods

	/** 
	 * Method validate
	 * @param ActionMapping mapping
	 * @param HttpServletRequest request
	 * @return ActionErrors
	 */
	public ActionErrors validate(
		ActionMapping mapping,
		HttpServletRequest request) {
		
		return null;
	}

	/** 
	 * Method reset
	 * @param ActionMapping mapping
	 * @param HttpServletRequest request
	 */
	public void reset(ActionMapping mapping, HttpServletRequest request) {
		password = null;
		userId = null;
		email = null;
		name = null;
	}

	/** 
	 * Returns the password.
	 * @return String
	 */
	public String getPassword() {
		return password;
	}

	/** 
	 * Set the password.
	 * @param password The password to set
	 */
	public void setPassword(String password) {
		this.password = password;
	}

	/** 
	 * Returns the userId.
	 * @return String
	 */
	public String getUserId() {
		return userId;
	}


	/** 
	 * Set the userId.
	 * @param userId The userId to set
	 */
	public void setUserId(String userId) {
		this.userId = userId;
	}

	/** 
	 * Returns the email.
	 * @return String
	 */
	public String getEmail() {
		return email;
	}

	/** 
	 * Set the email.
	 * @param email The email to set
	 */
	public void setEmail(String email) {
		this.email = email;
	}


	/**
	 * @return
	 */
	public String getName() {
		return name;
	}

	/**
	 * @param string
	 */
	public void setName(String string) {
		name = string;
	}

}

[예제 1-16]은 사용자 관리 프로젝트에 전달되는 사용자 정보를 저장하는 클래스이다. 예제를 보면 알겠지만 사용자아이디, 비밀번호등의 속성에 해당하는 setter와 getter를 가진다. [예제 1-16]에서 특이할만한 메소드는 validate()와 reset() 메소드이다. reset() 메소드는 한번의 요청을 처리한 다음 초기화할 속성에 대하여 초기화 작업을 담당하는 메소드이다. validate() 메소드는 사용자로부터 전달되는 값들의 유효성을 서버측에서 체크하기 위한 메소드이다. 보통의 웹 애플리케이션은 자바 스크립트(Java Script)를 이용하여 클라이언트측에서 유효성 체크를 많이 한다. 하지만 서버측에서 유효성 체크를 같이 해주는 것이 애플리케이션을 더 좋게 만들 수 있는 기초가 된다.

스트럿츠에서는 클라이언트가 입력한 값이 [예제 1-16]에서 보는 바와 같이 ActionForm을 상속하는 클래스에 저장된다. 따라서 클라이언트가 입력한 값을 구하기 위하여 request.getParameter("paramName")을 사용할 필요없이 UserForm클래스를 이용하여 가능하다.

스트럿츠가 추가된 UserForm클래스를 인식하도록 하기 위하여 struts-config.xml에 다음과 같이 추가해주어야 한다.

<form-beans>	
	<form-bean name="userForm" type="net.javajigi.struts.form.UserForm" />        
</form-beans>

참고사항
클라이언트가 입력한 값을 UserForm에 정확하게 저장하기 위해서는 먼저 클라이언트가 전달하는 인자의 이름과 UserForm클래스의 속성 이름을 일치하는 것이 중요하다.

한 예로 로 사용자 아이디를 입력 받았다면 UserForm에서의 속성 이름도 userId여야한다. setter와 getter이름은 자바빈 규약에 맞도록 작성하면 된다.

ActionForm을 상속하는 Form클래스를 만들 때 이 점만 유의하면 된다. 클라이언트가 전달한 값이 제대로 전달되지 않는다면 이부분을 제일 먼저 확인해야 한다.

ActionForm클래스를 생성한 다음 개발해야 하는 부분이 모델 2에서 본 바와 같이 Action클래스들이다. Action클래스의 내용은 모델2에서 살펴본 Action클래스의 내용과 별반 다른 것이 없다.

먼저 위에서 작성한 UserForm클래스의 사용예를 보기 위하여 InsertAction클래스를 살펴보도록 하겠다.

package net.javajigi.struts.action;

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

import net.javajigi.struts.form.UserForm;
import net.javajigi.user.User;
import net.javajigi.user.UserManager;

import org.apache.commons.beanutils.PropertyUtils;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

/** 
 * @struts.action
 *      name="userForm"
 *      path="/user_write"
 *      input="/struts/user_write.jsp"
 *      scope="request"
 *      validate="true"
 *
 * @struts.action-forward
 *      name="user_list"
 *      path="/user_list.do"
 * 		redirect="true"
 */
public class InsertAction extends Action {
	/**
	 * request에 저장되어 있는 인자값으로 User객체를 생성하여 
	 * UserManager의 create메써드를 호출하여 새로운 게시물을
	 * 입력한다. 
	 */
	public ActionForward execute(
		ActionMapping mapping,
		ActionForm form,
		HttpServletRequest request,
		HttpServletResponse response)
		throws Exception {
		//UserForm클래스를 얻는다.
		UserForm userForm = (UserForm) form;
		
		User user = new User();
		//UserForm에 저장되어 있는 사용자 정보를 User클래스에 복사한다.		
		PropertyUtils.copyProperties(user, userForm);

		//모델과 통하여 새로운 사용자를 생성.
		UserManager manager = UserManager.instance();
		manager.create(user);
			
		return mapping.findForward("user_list");
	}

}

[예제 1-18]은 클라이언트가 입력한 정보를 이용하여 새로운 사용자를 생성하는 Action클래스이다. Action클래스 어디에도 request.getParameter("paramName") 코드는 보이지 않는다. 모든 정보는 이미 UserForm객체에 저장되어 Action클래스로 전달되기 때문에 UserForm클래스에서 클라이언트가 입력한 정보를 얻을 수 있다. 또 하나 눈여겨 볼 부분은 UserForm클래스와 모델에서 사용한 User클래스 사이에 속성 이름이 같고, 같은 정보를 요구한다면 PropertyUtils.copyProperties(user, userForm)와 같이 간단하게 복사한 다음 모델에 전달하는 것이 가능하다.

마지막으로 스트럿츠의 Action클래스에서 눈여겨 볼 부분은 ActionForward클래스를 찾는 부분이다. ActionForward클래스에 대한 정보는 이미 struts-config.xml에 설정되어 객체로 저장되어 있기 때문에 mapping.findForward("user_list")와 같이 이동할 페이지 정보를 찾을 수 있다. [예제 1-18]의 InsertAction클래스를 위한 struts-config.xml정보는 다음과 같다.

<action	
	attribute="userForm"	
	input="/struts/user_write.jsp"	
	name="userForm"	
	path="/user_write"	
	type="net.javajigi.struts.action.InsertAction">	
	<forward name="user_list" path="/user_list.do" redirect="true" />
</action>

스트럿츠를 이용하여 사용자 리스트를 개발하는 과정을 살펴보자. 먼저 ListAction클래스를 생성한다. ListAction클래스는 모델2에서 살펴본 ListAction과 거의 같다.


package net.javajigi.struts.action;

import java.util.List;

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

import net.javajigi.user.UserManager;

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

/**
 * @struts.action
 *      path="/user_list"
 *      scope="request"
 *
 * @struts.action-forward
 *      name="user_list"
 *      path="/struts/user_list.jsp"
 */
public class ListAction extends Action{
	/**
	 * UserManager의 list메써드를 호출하여 
	 * List를 response에 저장하는 소스코드가 들어간다. 
	 * list.jsp에서 response에 저장된 List객체를 이용한다.
	 */
	public ActionForward execute(
		ActionMapping mapping,
		ActionForm form,
		HttpServletRequest request,
		HttpServletResponse response)
		throws Exception {

		UserManager manager = UserManager.instance();
		List userList = manager.findUserList(1, 10);
		
		//사용자의 정보를 얻어와 사용자의 정보를 담은 객체를 
		//request에 저장하여 전달하고 있다.
		//이것이 가능한 이유는 RequestDispatcher를 이용하기 때문이다.
		request.setAttribute("userList", userList);	
		
		return mapping.findForward("user_list");
	}
}

<action path="/user_list" type="net.javajigi.struts.action.ListAction"> 
	<forward name="user_list" path="/struts/user_list.jsp" /> 
</action>

[예제 1-20]과 [예제 1-21]를 사용자 리스트를 위한 ListAction클래스와 ListAction클래스 정보를 struts-config.xml에 추가하는 부분이다. ListAction클래스를 보면 모델 2의 ListAction클래스와 별반 다른 작업은 없다. 그렇다면 ListAction클래스에서 전달한 사용자 리스트 정보를 이용하는 user_list.jsp는 어떻게 바뀌었을까?

<action path="/user_list" type="net.javajigi.struts.action.ListAction">	
	<forward name="user_list" path="/struts/user_list.jsp" />
</action>

[예제 1-22]와 모델 2로 개발했던 [예제 1-12]을 비교해보면 뭔가 잘못된거 같다. "혹시 필자의 실수로 예제를 잘못 복사한게 아닐까?"하고 의문을 제기하는 개발자들도 있을 것이다. 하지만 [예제 1-22]는 정확히 스트럿츠 예제에서 사용한 예제가 맞다. 그 이유는 스트럿츠와 모델2가 기본으로 사용하고 있는 방식이 같이 때문에 뷰에 해당하는 JSP가 변경될 이유는 없다. JSP에서는 똑같은 방법으로 사용자 정보를 얻어 클라이언트에게 보여주면 되는 것이다.

스트럿츠기반하에서 사용자 리스트 화면을 서비스하기 위하여 처리하는 과정을 시퀀스 다이어그램으로 살펴보면 다음과 같다.

[그림 1-16]은 스트럿츠 기반하에서 사용자 리스트 화면을 서비스하기 위한 과정을 보여주는 시퀀스 다이어그램이다. [그림 1-14]의 모델 2 방식과 같이 user_list.do의 요청은 제일 먼저 ActionServlet이 담당하게 된다. RequestProcessor의 process() 메써드에서는 하나의 요청을 처리하기 위하여 상당히 많은 단계를 거치게 되지만 [그림 1-16]에서는 중요한 몇 개의 과정만을 다루고 있다. 모델 파트의 처리는 [그림 1-11]과 같기 때문에 지면 관계상 생략하였다. RequestProcessor 클래스의 process() 메써드 내부는 다음장에서 자세하게 다루겠다.

그렇다면 로그인 과정은 어떻게 바뀌었을까? 로그인 과정 또한 앞의 사용자 리스트 예제와 같이 JSP의 변경은 없다. 단지 LoginAction클래스가 스트러츠에 맞도록 작성되었으며, LoginAction클래스 정보가 struts-config.xml에 설정되었다는 것 뿐이다.

package net.javajigi.struts.action;

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

import net.javajigi.struts.form.UserForm;
import net.javajigi.user.UserManager;

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

/**
 * @struts.action
 *      path="/login"
 *      scope="request"
 *		input="/struts/login.jsp"
 *      name="userForm"
 *
 * @struts.action-forward
 *      name="user_list"
 *      path="/user_list.do"
 * 		redirect="true"
 */
public class LoginAction extends Action {

	public ActionForward execute(
		ActionMapping mapping,
		ActionForm form,
		HttpServletRequest request,
		HttpServletResponse response)
		throws Exception {
		UserForm userForm = (UserForm) form;
			
		//모델에 로그인 처리를 위임.
		UserManager manager = UserManager.instance();
		manager.login(userForm.getUserId(), userForm.getPassword());
		
		//세션에 사용자 이이디 저장.
		HttpSession session = request.getSession();
		session.setAttribute("userId", userForm.getUserId());
		
		//이동할 페이지를 결정.
		return mapping.findForward("user_list");
	}
}

<action	
	attribute="userForm"	
	input="/struts/login.jsp"	
	name="userForm"	
	path="/login"	
	type="net.javajigi.struts.action.LoginAction">	
	<forward name="user_list" path="/user_list.do" redirect="true" />
</action>

지금까지 스트럿츠를 이용하여 사용자 관리 프로젝트를 개발하는 방법에 대하여 배웠다. 스트럿츠 예제를 실행하는 방법 또한 모델1과 모델 2방법과 동일하다. 스트럿츠예제를 빌드하기 위한 타겟은 struts이다. "ant struts"를 실행하여 스트럿츠 예제를 위한 war파일을 빌드하면 된다. 앞의 모델1, 모델2와 같이 자동 디플로이 된다. 디플로이 후 Tomcat 서버를 재시작하여 테스트해볼 수 있다. 스트럿츠 예제의 사용자 리스트에 접근하는 테스트 URL은 http://localhost:8080/chapter1/user_list.do 이다.

5.3 스트럿츠 프레임워크의 장,단점.

스트럿츠는 모델 2 방식으로 웹 애플리케이션을 개발하고자 하는 개발자들에게 많은 편의성을 제공한다. 모델 2로 개발하기 위하여 필요한 많은 부분들을 미리 개발해 놓았기 때문에 개발시간 또한 상당히 단축시킬 수 있는 효과를 가져올 수 있다. 스트럿츠는 이 절에서 살펴본 항목 이외에도 상당히 많은 부분을 재사용 가능하도록 이미 구현해 놓은 상태이다. 따라서 스트럿츠를 정확히 이해하고 제대로 사용할 수만 있다면 아무리 큰 웹 애플리케이션일지라도 개발이 가능하다.

하지만 스트럿츠를 제대로 사용하기 위해서는 앞의 예제를 보아서도 알겠지만 학습하는데 상당한 시간을 필요로 한다. 모델 2로 발상의 전환이 있어야할 뿐만 아니라 JSP와 Action클래스 매핑을 전담하는 struts-config.xml에 대한 이해까지 선행되어야 한다. 그 이외에도 스트럿츠가 제공하는 다양한 기능들을 모두 사용하기까지는 더 많은 시간을 요한다. 따라서 웹 애플리케이션 개발에 스트럿츠를 이용하고자 할 때는 프로젝트를 진행하는 개발자들의 스트럿츠에 대한 이해가 어느 정도 수준인지 파악할 필요가 있다.

대부분의 개발자들이 스트럿츠에 대한 이해도가 높다면 스트럿츠를 이용하여 웹 애플리케이션을 개발하는 기간이 오히려
모델1 방식으로 개발할 때보다 더 단축할 수 있는 효과를 가져올 수 있다.

스트럿츠를 이용하여 개발할 때 가장 많은 시간을 요하는 부분은 struts-config.xml의 정보가 바뀔 때마다 웹 애플리케이션을 재시작해주어야 한다는 것이다. 이유는 앞에서 언급한 것처럼 애플리케이션이 시작될 때 struts-config.xml의 설정 값이 초기화되기 때문이다. 스트럿츠에서도 아직까지 이에 대한 해결책을 내놓지 못하고 있는 상태이다. 따라서 struts-config.xml의 변경이 최대한 적도록 하기 위하여 프로젝트 초기에 JSP와 Action클래스에 대한 매핑 설계를 꼼꼼하게 하는 것이 필요하다.

6. 생각해볼 문제

스트럿츠를 이용하여 웹 애플리케이션을 개발하는 많은 개발자들이 이구동성으로 하는 말은 "스트럿츠는 너무 어렵다. 배우는데 너무 많은 시간이 소요된다."는 것이였다. "도대체 그렇게 어려워하는 이유가 뭘까?"를 고민해 보았다. 필자가 내린 결론은 모델 1 에 익숙해져 있는 개발자들이 모델2로의 발상의 전환이 선행되어 있지 않은 상태에서 스트럿츠를 먼저 접하기 때문이다. 아직 모델 2가 무엇인지도 잘 모르는 개발자들이 무턱대고 스트럿츠를 배우려하다보니 스트럿츠의 복잡한 구조 때문에 초반에 지쳐 포기하는 경우가 많은 것으로 생각된다.

따라서 이 장에서는 스트럿츠에 중점을 두기 보다는 모델 2가 과연 무엇인지에 대하여 중점적으로 설명하기 위해 노력했다. 모델 1과 모델 2의 근본적인 차이점은 초기 진입점이 틀리다는 것이다. 이 차이점이 큰 것 같지는 않지만 모델1과 모델2를 결정짓는 가장 중요한 차이점이라는 것을 명심해야한다. 스트럿츠의 기본적인 구조 또한 모델 2이다. 단지 다른 점이라면 모델 2가 제공하지 못하는 재사용성을 극대화하여 제공하는 프레임워크이라는 것이다.

이 장에서 아직까지 스트럿츠가 뭔지 모른다고해도 걱정하지 마라. 앞으로 많은 장에서 스트럿츠만을 집중적으로 다룰 것이다. 하지만 모델 2가 아직까지 무엇인지 모르는 개발자라면 이 장의 모델 2파트를 다시 한번 읽어보기 바란다. 모델 2의 기본적인 뼈대를 이해했을 때 스트럿츠가 아닌 모델2에 기반한 다른 프레임워크를 사용하는 경우가 발생한다고 해도 쉽게 사용할 수 있을 것이다. 이 뿐만이 아니라 모델 2에 대한 기본 개념이 잡혀 있을 때 스트럿츠의 다양한 기능들을 제대로 이해하고 적재적소에 사용할 수 있게 될 것이다.