반응형

1. @Configuration 

@Configuration은 스프링 IOC Container에게 해당 클래스를 Bean 구성 Class임을 알려주는 것입니다.

 

2. @Bean

@Bean의 경우 개발자가 직접 제어가 불가능한 외부 라이브러리등을 Bean으로 만들려고 할 때 사용됩니다.

@Configuration
public class ApplicationConfig{
	@Bean
    	public ArrayList<String> array(){
        	return new ArrayList<String>();
     }      
}

  @Bean 을 이용하여 Bean을 생성한 예제 입니다. 위와 같이 ArrayList같은 라이브러리등을 Bean으로 등록하기 위해서는 별도로 해당 라이브러리 객체를 반환하는 Method를 만들고 @Bean 을 적어주면 됩니다. 위의 경우 @Bean에 아무런 값을 지정하지 않았으므로 Method 이름을 CamelCase로 변경한 것이 Bean id로 등록된다.

(ex. 메소드 이름이 arrayList()인 경우 arrayList 가 Bean id)

 

@Configuration
public class ApplicationConfig{
	@Bean(name="myarray")
    public ArrayList<String> array(){
    	return new ArrayList<String>();
    }
}

 위와 같이 @Bean 에 name이라는 값을 이용하면 자신이 원하는 id로 Bean을 등록할 수 있습니다. 어노테이션 안에 값을 입력하지 않을 경우 메소드의 이름을 CamelCase로 변경한 것이 Bean의 id가 됩니다.

@Configuration
public class ApplicationConfig{

	
    @Bean
    public ArayList<Integer> array(){
    	return new ArrayList<Integer>();
    }
    
    @Bean
    public Student student() {
    	return new Student(array());
    }
}

  의존관계가 필요할 때에는 어떻게 해결할 수 있을까요? Student 객체의 경우 새성자에서 ArrayList를 주입 받도록 코드를 짜놓았다면 이럴때에는 Bean으로 선언된 array()메소드를 호출함으로써 의존성을 주입할 수 있습니다.

 

3. @Component

@Component 어노테이션의 경우 개발자가 직접 작성한 Class를 Bean으로 등록하기 위한 어노테이션입니다.

@Component
public class Student{
	public Student(){
    System.out.println("hello");
    }
}

  Student Class는 개발자가 사용하기 위해서 직접 작성한 Class 입니다. 이러한 클래스를 Bean으로 등록하기 위해 상단에 @Component 어노테이션을 사용한 것을 볼 수 있습니다.

@Component(value="mystudent")
public class Student{
	public Student(){
    	System.out.println("hi");
    }
}

@Component 역시 아무런 추가 정보가 없다면 Class의 이름을 Camelcase로 변경한 것이 Bean id로 사용된다. 하지만 @Bean과 다르게 @Component 는 name이 아닌 value를 이용해 Bean의 이름을 지정한다.

 

 

4. @Autowired

@Component
	public class Pencil{
    ...
}

@Component(value="mystudent")
public class Student {
	@Autowired
    private Pencil pencil;
    
    public Student(){
    	System.out.println("hi");
    }
}

 

  @Component를 사용한 Bean의 의존성 주입은 @Autowired 어노테이션을 이용하여 할 수 있다. 위와 같이 Student가 Pencil에 대한 의존성을 가지고 있는 경우 @AutoWired 를 이용하여 의존성을 자동으로 주입할 수 잇다. 이때 당연히도 Pencil도 @Component 어노테이션을 가지고 있어야 한다. 그래야만 IOE Container에 Bean으로 등록되기 때문이다.

 

  @AutoWired의 경우 타입을 통해 해당 자리에 들어올 객체를 판별하여 주입해 준다. 따라서 해당 자리에 들어올 수 있는 객체가 여러개인 경우, 즉 다형성을 띄고 있는 객체타입에 @Autowired를 사용한 경우에는 @Qualifier("Bean이름")을 이용하여 해당 자리에 주입될 Bean을 명시해 주어야 한다.

 

  위의 그림에서 Goods라는 인터페이스를 Computer와 Book이 구현하고 있으므로 Person클래스의 goods 참조변수에 위치할 수 있는 Bean이 Book, Computer 두가지 이다. 때문에 @Qualifier("Bean이름")을 통해 해당 자리에 위치할 빈을 명시하였다.

 

 

5. @Bean 사용방법

public class Student{
	public Student() {
    	System.out.println("hi");
    }
}

  우선 의존성 주입 대상 Class를 생성한다. 생성자가 호출될 때 콘솔창에 "hi"를 출력하도록 했다.

@Configuration
public class ApplicationConfig {
	@Bean
    public Student student(){
    	return new Student();
    }
}

student를 Bean으로 등록하기 위해 Config Class를 임의로 만들고 @Configuration 어노테이션을 부여했다. 그 후 Student 객체를 반환하는 Method를 작성하고 @Bean 어노테이션을 부여한다.

public class Main{
	public static void main(String[] args){
    	ApplicationContext context = new AnnotationConfigApplicationContext(ApplicationConfig.class);
        	Student student = context.getBean("student", student.class);
        }
   }

Annotation을 기반으로 Bean을 등록했으므로 AnnotationConfigApplicationContext 객체를 생성하고 매개변수로 @Configuration 어노테이션을 부여한 ApplicationConfig 클래스를 넘겨준다. 그 후 getBean을 이용하여 사용하면 된다.

 

6. @Component 사용방법

@Component 이 부여된 Class 들은 자동으로 IOC Container에 Bean으로 등록이 되는데 IOC Container에게 이러한 어노테이션이 부여된 Class를 자동으로 Bean으로 등록하라고 하기 위해서 XML파일에 따로 설정이 필요하다.

 

 

우선 XML파일을 연 뒤 하단에 Namespaces탭을 클릭하고 context를 체크한 다음 저장을 한다.

그러면 다시 Source 탭으로 돌아와 <context:component-scan base-package="com.java.ex">

</context:component-scan> 코드를 추가해 주면 준비는 완료 된다.

 

 

@Component 어노테이션을 부여한 Student 클래스이다.

 

 

Main 클래스에서는 기존 xml을 이용하여 의존성을 주입하듯이 객체를 생성하면 된다.

 

 

출처: https://galid1.tistory.com/494

 

반응형
블로그 이미지

꽃꽂이하는개발자

,
반응형

이전 글에 이어서 작성해보도록 하겠습니다.

실습에 필요한 파일들을 다음과 같이 준비합니다.

MemberVO 를 작성하겠습니다.

package com.spring.member.vo;

import java.sql.Date;

public class MemberVO {
	private String id;
	private String pwd;
	private String name;
	private String email;
	private Date joinDate;

	public MemberVO() {
		
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getPwd() {
		return pwd;
	}

	public void setPwd(String pwd) {
		this.pwd = pwd;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public Date getJoinDate() {
		return joinDate;
	}

	public void setJoinDate(Date joinDate) {
		this.joinDate = joinDate;
	}
	
	


}

1. MemberControllerImpl 클래스를 다음과 같이 구현합니다. 자신의 속성 memberService에 설정 파일에서 생성된 memberService 빈을 주입하기 위해 반드시 setter를 구현해야 합니다.

package com.spring.member.controller;

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

import org.springframework.web.servlet.ModelAndView;

public interface MemberController {
	public ModelAndView listMembers(HttpServletRequest request, HttpServletResponse response) throws Exception;

}
package com.spring.member.controller;

import java.util.List;

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

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.multiaction.MultiActionController;

import com.spring.member.service.MemberService;

public class MemberControllerImpl extends MultiActionController implements MemberController {
	private MemberService memberService;
	public void setMemberService(MemberService memberService) {
		this.memberService = memberService;
	}
	public ModelAndView listMembers(HttpServletRequest request, HttpServletResponse response) throws Exception {
		String viewName = getViewName(request);
		List membersList = memberService.listMembers();
		ModelAndView mav = new ModelAndView(viewName);
		mav.addObject("membersList", membersList);
		return mav;
	}
	
	
	private String getViewName(HttpServletRequest request) throws Exception {
		String contextPath = request.getContextPath();
		String uri = (String) request.getAttribute("javax.servlet.include.request_uri");
		if (uri == null || uri.trim().equals("")) {
			uri = request.getRequestURI();
		}

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

		int end;
		if (uri.indexOf(";") != -1) {
			end = uri.indexOf(";");
		} else if (uri.indexOf("?") != -1) {
			end = uri.indexOf("?");
		} else {
			end = uri.length();
		}

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

2. MemberServiceImpl 클래스에서는 자신의 속성인 memberDAO에 빈을 주입하기 위해 setter를 구현합니다.

package com.spring.member.service;


import java.util.List;

import org.springframework.dao.DataAccessException;

public interface MemberService {
	public List listMembers() throws DataAccessException;
}
package com.spring.member.service;

import java.util.List;

import org.springframework.dao.DataAccessException;

import com.spring.member.dao.MemberDAO;

public class MemberServiceImpl implements MemberService {
	private MemberDAO memberDAO;

	public void setMemberDAO(MemberDAO memberDAO) {
		this.memberDAO = memberDAO;
	}

	@Override
	public List listMembers() throws DataAccessException {
		List membersList = null;
		membersList = memberDAO.selectAllMembers();
		return membersList;
	}

}

3. MemberDAOImpl 클래스에서는 자신의 속성 jdbcTemplate에 dataSource 빈을 주입하기 위해 setter를 이용합니다.

 

package com.spring.member.dao;

import java.util.List;

import org.springframework.dao.DataAccessException;

import com.spring.member.vo.MemberVO;


public interface MemberDAO {
	public List selectAllMembers() throws DataAccessException ;
	public int addMember(MemberVO memberVO) throws DataAccessException ;

}
package com.spring.member.dao;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import javax.sql.DataSource;

import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import com.spring.member.vo.MemberVO;


public class MemberDAOImpl implements MemberDAO {
	private JdbcTemplate jdbcTemplate;
	public void setDataSource(DataSource dataSource) {
		this.jdbcTemplate = new JdbcTemplate(dataSource);
	}

	@Override
	public List selectAllMembers() throws DataAccessException {
		String query = "select id,pwd,name,email,joinDate" + " from t_member " + " order by joinDate desc";
		List membersList = new ArrayList();

		membersList = this.jdbcTemplate.query(query, new RowMapper() {
			public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
				MemberVO memberVO = new MemberVO();
				memberVO.setId(rs.getString("id"));
				memberVO.setPwd(rs.getString("pwd"));
				memberVO.setName(rs.getString("name"));
				memberVO.setEmail(rs.getString("email"));
				memberVO.setJoinDate(rs.getDate("joinDate"));
				return memberVO;
			}
		});
		return membersList;
	}

	@Override
	public int addMember(MemberVO memberVO) throws DataAccessException {
		String id = memberVO.getId();
		String pwd = memberVO.getPwd();
		String name = memberVO.getName();
		String email = memberVO.getEmail();
		String query = "insert into t_member(id,pwd, name,email) values  ("
		                 + "'" + id + "' ,"
	 	                 + "'" + pwd + "' ,"
		                 + "'" + name + "' ,"
		                 + "'" + email + "') ";
		System.out.println(query);
		int result = jdbcTemplate.update(query);
		System.out.println(result);
		return result;
	}

}

4. listMembers.jsp에서는 조회한 회원 정보를 표시해줍니다.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8" 
    isELIgnored="false"  %>
 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"  %>
<c:set var="contextPath"  value="${pageContext.request.contextPath}"  />

<%
  request.setCharacterEncoding("UTF-8");
%>    


<html>
<head>
<meta charset=UTF-8">
<title>회원 정보 출력창..</title>
</head>
<body>
<table border="1"  align="center"  width="80%">
    <tr align="center"   bgcolor="lightgreen">
      <td ><b>아이디</b></td>
      <td><b>비밀번호</b></td>
      <td><b>이름</b></td>
      <td><b>이메일</b></td>
      <td><b>가입일</b></td>
   </tr>
   
 <c:forEach var="member" items="${membersList}" >     
   <tr align="center">
      <td>${member.id}</td>
      <td>${member.pwd}</td>
      <td>${member.name}</td>
      <td>${member.email}</td>
      <td>${member.joinDate}</td>
      
    </tr>
  </c:forEach>   
</table>
<a  href="${contextPath}/member/memberForm.do"><h1 style="text-align:center">회원가입</h1></a>
</body>
</html>

저의 db에 있는 회원 목록이 표시되네요

반응형
블로그 이미지

꽃꽂이하는개발자

,
반응형

  JDBC는 자바 데이터 접근 기술의 근간이라 할 정도로 대부분의 개발자가 쉽게 이해할 수 있어 많이 사용하는 데이터 액세스 기술입니다. 그러나 시간이 지남에 따라 SQL문이 지나치게 복잡해지면서 개발이나 유지관리에 어려움이 생기기 시작했습니다. 특히 cONNECTION 객체 같은 공유 리소스를 제대로 처리해주지 않으면 버그를 발생시키는 원인이 되곤 했습니다.

  스프링에서 제공하는 JDBC는 이러한 기존 JDBC의 장점과 단순함을 유지하면서 단점을 보완했습니다. 간결한 API뿐만 아니라 확장된 JDBC의 기능도 제공합니다.

  이번에 사용할 파일들 입니다.

lib 폴더와 action-servlet.xml , web.xml은 이 전글에서 했던 것들을 가져와 재사용 하겠습니다.

 

파일 설명
web.xml ContextLoaderListener를 이용해 빈 설정 XML 파일들을 읽어 들입니다.
action-servlet.xml 스프링에서 필요한 여러 가지 빈을 설정합니다.
action-dataSource.xml 스프링 JDBC 설정에 필요한 정보를 설정합니다.
jdbc.properties 데이터베이스 연결정보를 저장합니다.
action-service.xml 서비스 빈 생성을 설정합니다.

 

1. action-servlet.xml과 action-dataSource.xml의 <beans> 태그는 이전 글에서 실습한 action-servlet.xml의 것을 복사해 붙여 넣겠습니다.

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

 

2. web.xml을 다음과 같이 작성합니다. 한 개의 XML 파일에서 모든 빈을 설정하면 복잡해서 관리하기 어려우므로 빈의 종류에 따라 XML 파일에 나누어 설정합니다. 그러면 톰캣 실행시 web.xml에서 스프링의 ContextLoaderListener를 이용해 빈 설정 XML 파일들을 읽어 들입니다.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" 
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" 
id="WebApp_ID" version="3.1">

	<!-- 여러 설정 파일을 읽어 들이기 위해 스프링의 ContextLoaderListener를 설정합니다. -->
	<listener>
		<listener-class>
			org.springframework.web.context.ContextLoaderListener
		</listener-class>
	</listener>
	

	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
			<!-- 애플리케이션 실행 시 ContextLoaderListener로 해당 위치의 설정 파일을 읽어 들입니다. -->
			/WEB-INF/config/action-service.xml
			/WEB-INF/config/action-dataSource.xml
		</param-value>
	</context-param>
	
	
	<servlet>
		<servlet-name>action</servlet-name>
		<servlet-class>org.springramework.web.servlet.DispatcherServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
	
	<servlet-mapping>
		<servlet-name>action</servlet-name>
		<url-pattern>*.do</url-pattern>
	</servlet-mapping>

</web-app>

 

3. action-servlet.xml을 다음과 같이 작성합니다. 여기서는 뷰 관련 빈과 요청을 처리할 빈 그리고 메서드를 설정합니다. 이때 주의할 점은 빈 주입 시 주입 받는 클래스에서는 주입되는 빈에 대한 setter를 반드시 구현해야 한다는 것입니다.

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	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-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">


 	<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" />
	</bean>

	<bean id="memberController"
		class="com.spring.member.controller.MemberControllerImpl">
		<property name="methodNameResolver">
			<ref local="methodResolver" />
		</property>
		<property name="memberService" ref="memberService" />
	</bean>
	
	<bean  id="methodResolver"
   class="org.springframework.web.servlet.mvc.multiaction.PropertiesMethodNameResolver" >
      <property  name="mappings" >
        <props>
          <prop key="/member/listMembers.do" >listMembers</prop>
          <prop key="/member/addMember.do" >addMember</prop>
          <prop key="/member/memberForm.do" >memberForm</prop>
          <prop key="/member/memberDetail.do">memberDetail</prop>
       </props>
      </property>
   </bean>
	
	<bean id="urlMapping"
		class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping" >
		<property name="mappings" >
			<props>
				<prop key="/member/*.do">memberController</prop>
			</props>
		</property>
	</bean>
	
</beans>

 

4. action-service.xml에서 memberService 빈을 설정하도록 작성합니다. 데이터베이스와 연동할 때 필요한 memberDAO 빈을 주입하는 기능을 합니다.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	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-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">

	<bean id="memberService" class="com.spring.member.service.MemberServiceImpl">
		<!-- memberService 빈의 memberDAO 속성에 memberDAO 빈을 주입합니다. -->
		<property name="memberDAO" ref="memberDAO" />
	</bean>
</beans>

 

5. 다음으로 action-dataSource.xml을 작성합니다. 이 파일은 스프링에서 사용할 데이터베이스 연동 정보를 설정합니다. 먼저 jdbc.properties 파일에서 데이터베이스 연결 정보를 가져온 후 이 연결 정보를 이용해 스프링에서 제공하는 SimpleDriverDataSource로 id가 dataSource인 빈을 생성합니다. 그리고 dataSource 빈을 memberDAO 빈으로 주입합니다.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	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-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">


	<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer" >
		<property name="locations">
			<list>
				<!-- jdbc.properties 파일에서 데이터베이스 연결에 필요한 4가지 설정 정보를 가져옵니다. -->
				<value> /WEB-INF/config/jdbc.properties</value>
			</list>
		</property>
	</bean>
	
	<bean id="dataSource" class="org.springframework.jdbc.datasource.SimpleDriverDataSource">
		<property name="driverClass" value="${jdbc.driverClassName}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>
	
	<!-- 생성된 dataSource 빈을 memberDAO 빈에 주입합니다. -->
	<bean id="memberDAO" class="com.spring.member.dao.MemberDAOImpl">
		<property name="dataSource" ref="dataSource" />
	</bean>

</beans>

6. jdbc.properties 파일에서는 데이터베이스 연결정보를 작성합니다.

jdbc.driverClassName=oracle.jdbc.driver.OracleDriver
jdbc.url=jdbc:oracle:thin:@localhost:1521:XE
jdbc.username=scott
jdbc.password=scott

 

다음글에서는 jdbcTemplate 클래스를 이용해 회원 정보를 조회해 보겠습니다.

반응형
블로그 이미지

꽃꽂이하는개발자

,
반응형

이번 글에서는 회원 정보 입력창에서 회원 정보를 입력한 후 요청 시 전송된 회원 정보를 표시해보겠습니다.

 

1. 회원 정보를 표시하기 위해 action-servlet.xml을 다음과 같이 수정합니다. 회원 정보 요청 URL에 대해 처리할 메서드를 추가한 후 /test/memberInfo.do로 요청하면 요청명과 같은 memberInfo() 메서드를 호출합니다.

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	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-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">

<!-- 
	  id가 simpleUrlController인 빈을 생성합니다. 
	<bean id="simpleUrlController" class="com.spring.ex01.SimpleUrlController" />
	 SimpleUrlHandlerMapping 클래스를 이용해 /test/index.do로 요청 시 simpleUrlController를 호출하도록 매핑합니다. 
	<bean id="urlMapping"
		class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
	  <property name="mappings">
	  	<props>
	  	  <prop key="/test/index.do">simpleUrlController</prop>
	  	</props>
	  </property>
	</bean>
 -->	
 
 <!-- 컨트롤러에서 ModelAndView 인자로 뷰이름이 반환되면 InternalResourceViewResolver의 프로퍼티스 prefix 속성에 지정된 /test폴더에서
 	ModelAndView 인자로 넘어온 뷰 이름에 해당되는 jsp를 선택해 DispatcherServlet으로 보냅니다.
  -->
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
	<property name="prefix" value="/test/" />
	<property name="suffix" value=".jsp" />
</bean>
 
<bean id="userUrlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
 	<property name="mappings">
 		<props>
 			<prop key="/test/*.do">userController</prop>
 		</props>
 	</property>
 </bean>
 	
<bean id="userController" class="com.spring.ex02.UserController">
	<!-- methodNameResover 프로퍼티에 userMethodNameResolver를 주입해서 지정한 요청명에 대해
		직접 메서드를 호출하게 합니다. -->
	<property name="methodNameResolver">
		<ref local="userMethodNameResolver" />
	</property>
</bean>

<!-- PropertiesMethodNameResolver를 이용해 /test/login.do로 요청하면 userController의 login 메서드를 호출합니다. -->
<bean id="userMethodNameResolver"
	class="org.springframework.web.servlet.mvc.multiaction.PropertiesMethodNameResolver" >
	<property name="mappings">
		<props>
			<prop key="/test/login.do">login</prop>
			<!-- URL 요청명과 메서드 이름을 동일하게 하여 회원 정보를 요청합니다. -->
			<prop key="/test/memberInfo.do">memberInfo</prop>
		</props>
	</property>
</bean>

</beans>

2. UserController 클래스를 다음과 같이 수정하겠습니다. 회원 가입창에서 전송된 회원 정보를 가져온 후 ModelAndView를 이용해 회원 정보를 바인딩하여 memberInfo.jsp로 전달하는 memberInfo() 메서드를 추가합니다.

 

package com.spring.ex02;

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

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.multiaction.MultiActionController;

// 설정 파일의 userMethodNameResolver 프로퍼티를 사용하려면 반드시 MultiActionController를 상속 받아야 합니다.
public class UserController extends MultiActionController{
	public ModelAndView login(HttpServletRequest request, HttpServletResponse response) 
			throws Exception{
			String userID ="";
			String passwd ="";
			ModelAndView mav = new ModelAndView();
			request.setCharacterEncoding("utf-8");
			userID=request.getParameter("userID");
			passwd=request.getParameter("passwd");
			
			//ModelAndView에 로그인 정보를 바인딩합니다.
			mav.addObject("userID", userID);
			mav.addObject("passwd", passwd);
			//ModelAndView 객체에 포워딩할 JSP 이름을 설정합니다.
			mav.setViewName("result");
			return mav;
		}
	public ModelAndView memberInfo(HttpServletRequest request, HttpServletResponse response) throws Exception{
		request.setCharacterEncoding("utf-8");
		ModelAndView mav = new ModelAndView();
		String id = request.getParameter("id");
		String pwd= request.getParameter("pwd");
		String name= request.getParameter("name");
		String email=request.getParameter("email");
		
		mav.addObject("id", id);
		mav.addObject("pwd", pwd);
		mav.addObject("name", name);
		mav.addObject("email", email);
		
		mav.setViewName("memberInfo");
		return mav;
	}
}

3. 회원 가입창에서 회원 정보를 입력한 후 /test/memberInfo.do로 요청하도록 action 속성을 설정합니다.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"
    isELIgnored="false"%>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%
	request.setCharacterEncoding("utf-8");
%>
<c:set var="contextPath" value="${pageContext.request.contextPath }" />

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>회원 가입창</title>
<style>
	.text_center{
    text-align:center;
    }
</style>

</head>
<body>
<form method="post"   action="${contextPath}/test/memberInfo.do">
	<h1  class="text_center">회원 가입창</h1>
	<table  align="center">
	   <tr>
	      <td width="200"><p align="right">아이디</td>
	      <td width="400"><input type="text" name="id"></td>
	   </tr>
	   <tr>
	      <td width="200"><p align="right">비밀번호</td>
	      <td width="400"><input type="password" name="pwd"></td>
	    </tr>
	    <tr>
	       <td width="200"><p align="right">이름</td>
	       <td width="400"><p><input type="text" name="name"></td>
	    </tr>
	    <tr>
	       <td width="200"><p align="right">이메일</td>
	       <td width="400"><p><input type="text" name="email"></td>
	    </tr>
	    <tr>
	       <td width="200"><p>&nbsp;</p></td>
	       <td width="400"><input type="submit" value="가입하기"><input type="reset" value="다시입력"></td>
	    </tr>
	</table>
	</form>
</body>
</html>

4. memberInfo.jsp를 다음과 같이 작성합니다.

  UserController의 memberInfo() 메서드에서 바인딩해 넘어온 회원 정보를 출력합니다.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"
    isELIgnored="false"%>
    
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>    
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>회원정보 출력창</title>
</head>
<body>
<table border="1" align="center" width="100%" >
   <tr align=center   bgcolor="lightgreen">
      <td ><b>아이디</b></td>
      <td><b>비밀번호</b></td>
      <td><b>이름</b></td>
      <td><b>이메일</b></td>
   </tr>
   <tr align="center">
      <td>${id}</td>
      <td>${pwd}</td>
      <td>${name}</td>
      <td>${email}</td>
    </tr>
</table>
</body>
</html>

 

github: github.com/soulwine-it

자료출처 : 자바 웹을 다루는 기술

 

반응형
블로그 이미지

꽃꽂이하는개발자

,
반응형

  SimpleUrlController를 이용해 요청을 처리하려면 각 요청명에 대해 다시 스프링의 Controller 인터페이스를 구현한 각각의 컨트롤러 클래스를 만들어야만 합니다. 하지만 MultiActionController를 이용하면 여러 요청명에 대해 한 개의 컨트롤러에 구현된 각 메서드로 처리할 수 있어 편리합니다.

  

  이번 글에서는 MultiActionController를 이용해 스프링 MVC를 실습해 보겠습니다. 

  이번에 사용할 클래스들은

클래스 설명
MultiActionController URL 요청명으로 바로 컨트롤러를 지정해서 사용할 수 있습니다.
PropertiesMethodNameResolver URL 요청명으로 컨트롤러의 설정 파일에서 미리 설정된 메서드를 바로 호출해서 사용할 수 있습니다.
InternalResourceViewResolver JSP나 HTML 파일과 같이 웹 애플리케이션의 내부 자원을 이용해 뷰를 생성하는 기능을 제공합니다. 기본적으로 사용하는 View 클래스이며 prefix와 suffix 프로퍼티를 이용해 경로를 지정할 수 있습니다.

또한 MultiActionController를 이용한 실습에 필요한 파일들은

파일 설명
web.xml 브라우저에서 *.do로 요청하면 스프링의 DispatcherServlet 클래스가 요청을 받을 수 있게 서블릿 매핑을 설정합니다.
action-servlet.xml 스프링에서 필요한 빈들은 설정합니다.
UserController.java 매핑된 요청에 대해 컨트롤러의 기능을 수행합니다.
loginForm.jsp 로그인창입니다.
result.jsp 로그인 결과를 보여주는 JSP입니다.

1.  패키지를 만들고 UserController 클래스를 추가합니다. 그리고 loginForm.jsp, result.jsp등 필요한 파일을 준비하겠습니다.

 2.  action-servlet.xml을 다음과 같이 수정하겠습니다.

  브라우저에서 /test/*.do로 호출하면 userUrlMapping 빈을 이용해 userController 빈을 호출합니다.

  userController 빈의 methodNameResolver 프로퍼티에는 userMethodNameResolver가 주입되어 있으므로 /test/login.do로 요청하면 userController 빈의 login 메서드를 호출합니다. 또한 userMethodNameResolver는 스프링의 PropertiesMethodNameResolver 클래스를 이용해 요청명에 대해 호출할 메서드를 바로 지정합니다.

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	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-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 
 <!-- 컨트롤러에서 ModelAndView 인자로 뷰이름이 반환되면 InternalResourceViewResolver의 프로퍼티스 prefix 속성에 지정된 /test폴더에서
 	ModelAndView 인자로 넘어온 뷰 이름에 해당되는 jsp를 선택해 DispatcherServlet으로 보냅니다.
  -->
 <bean id="viewResolver" 
 class="org.springframework.web.servlet.view.InternalResourceViewResolver">
 	<property name="viewClass"
 	value="org.springframework.web.servlet.view.JstlView" />
 	<property name="prefix" value="/test/" />
 	<property name="suffix" value=".jsp" />
 </bean>
 
 <bean id="userUrlMapping"
 	class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
 	<property name="mappings">
 		<props>
 			<prop key="/test/*.do">userController</prop>
 		</props>
 	</property>
 	</bean>
 	
<bean id="userController" class="com.spring.ex02.UserController">
	<!-- methodNameResover 프로퍼티에 userMethodNameResolver를 주입해서 지정한 요청명에 대해
		직접 메서드를 호출하게 합니다. -->
	<property name="methodNameResolver">
		<ref local="userMethodNameResolver" />
	</property>
</bean>

<!-- PropertiesMethodNameResolver를 이용해 /test/login.do로 요청하면 userController의 login 메서드를 호출합니다. -->
<bean id="userMethodNameResolver"
	class="org.springframework.web.servlet.mvc.multication.PropertiesMethodNameResolver" >
	<property name="mappings">
		<props>
			<prop key="/test/login.do">login</prop>
		</props>
	</property>
</bean>

</beans>

3.  UserController 클래스를 다음과 같이 작성합니다. UserController 클래스는 MultiAction Controller를 상속받음으로써 지정한 요청명에 대해 바로 메서드를 호출할 수 있으며 ModelAndView 객체에 JSP에 전달할 값을 바인딩할 수 있습니다. ModelAndView 객체를 이용하면 더 이상 request 객체에 바인딩해서 포워딩할 필요가 없고, 문자열 이외의 다른 객체들도 ModelAndView 객체에 바인딩할 수 있습니다. 따라서 ModelAndView의 setViewName()메서드를 이용해 JSP 이름을 설정한 후 반환합니다.

package com.spring.ex02;

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

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.multiaction.MultiActionController;

// 설정 파일의 userMethodNameResolver 프로퍼티를 사용하려면 반드시 MultiActionController를 상속 받아야 합니다.
public class UserConroller extends MultiActionController{
	public ModelAndView login(HttpServletRequest request, HttpServletResponse response) 
			throws Exception{
			String userID ="";
			String passwd ="";
			ModelAndView mav = new ModelAndView();
			request.setCharacterEncoding("utf-8");
			userID=request.getParameter("userID");
			passwd=request.getParameter("passwd");
			
			//ModelAndView에 로그인 정보를 바인딩합니다.
			mav.addObject("userID", userID);
			mav.addObject("passwd", passwd);
			//ModelAndView 객체에 포워딩할 JSP 이름을 설정합니다.
			mav.setViewName("result");
			return mav;
		}
}

4. loginForm.jsp를 다음과 같이 작성합니다. 로그인창에서 ID와 비밀번호를 입력하고 로그인을 클릭하면 /test/login.do로 DispatcherServlet에 요청합니다.

 

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"
    isELIgnored="false"%>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<c:set var="contextPath" value="${pageContext.request.contextPath }" />
<%
	request.setCharacterEncoding("utf-8");
%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>로그인 폼</title>
</head>
<body>
	<form name="frmLogin" method="post" action="${contextPath}/test/login.do">
		<table border="1" width="80%" align="center">
			<tr align="center">
				<td>아이디</td>
				<td>비밀번호</td>
			</tr>
			<tr align="center">
				<td>
				<input type="text" name="userID" value="" size="20">
				</td>
				<td>
				<input type="password" name="passwd" value="" size="20">
				</td>
			</tr>
			<tr align="center">
				<td colspan="2">
					<input type="submit" value="로그인">
					<input type="reset" value="다시입력">
				</td>
			</tr>	
		</table>
	</form>

</body>
</html>

5. result.jsp를 다음과 같이 작성합니다. 로그인창에서 전송된 ID와 비밀번호를 컨트롤러에서 바인딩해 넘긴 후 결과창에서 출력합니다.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"
    isELIgnored="false"%>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%
	request.setCharacterEncoding("utf-8");
%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>결과창</title>
</head>
<body>
	<table border="1" width="50%" align="center" >
		<tr align="center">
			<td>아이디</td>
			<td>비밀번호</td>
		</tr>
		<tr align="center">
		<!-- 컨트롤러에서 바인딩해 넘어온 회원 정보를 출력합니다. -->
			<td>${userID}</td>
			<td>${passwd}</td>
		</tr>
	</table>

</body>
</html>

실행해 보겠습니다.

반응형
블로그 이미지

꽃꽂이하는개발자

,
반응형

  이번에는 브라우저의 요청 URL에 대해 미리 매핑해 놓은 컨트롤러를 호출하여 컨트롤러에서 지정한 JSP를 브라우저로 전송하는 과정을 실습해 보겠습니다.

  브라우저에서 요청한 URL(http://localhost:8090/pro21/test/index.do)에 대해 매핑된 컨트롤러를 선택하고 요청명에 대한 JSP파일을 브라우저로 전송하는 과정입니다.

 

웹 브라우저 -> DispatcherServlet -> SimpleUrlController -> /test/index.jsp -> 웹브라우저

 

1. 브라우저에서 http://localhost:8090/pro21/test/index.do로 요청합니다.

2. DispatcherServlet은 요청에 대해 미리 action-servlet.xml에 매핑된 SimpleUrlController 를 요청합니다.

3. 컨트롤러는 요청에 대해 test 폴더에 있는 index.jsp를 브라우저로 전송합니다.

 

 

cglib-nodep-2.1_3.jar
0.31MB
cglib-nodep-2.2.jar
0.31MB
com.springsource.javax.validation-1.0.0.GA.jar
0.05MB
com.springsource.org.aopalliance-1.0.0.jar
0.00MB
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
1.57MB
commons-beanutils-1.8.3.jar
0.22MB
commons-dbcp.jar
0.10MB
commons-dbcp-1.4.jar
0.15MB
commons-digester-2.0.jar
0.14MB

 

commons-fileupload-1.2.2.jar
0.06MB
commons-io-2.0.1.jar
0.15MB
commons-logging.jar
0.05MB
commons-logging-1.1.1.jar
0.06MB
commons-pool.jar
0.06MB
commons-pool-1.5.6.jar
0.10MB
json_simple-1.1.jar
0.02MB
jstl.jar
0.02MB
log4j-1.2.16.jar
0.46MB
mybatis-3.0.5.jar
0.61MB
mybatis-spring-1.0.1.jar
0.03MB
mysql-connector-java-3.0.14-production-bin.jar
0.23MB
ojdbc6.jar
2.61MB
org.springframework.aop-3.0.6.RELEASE.jar
0.31MB
org.springframework.asm-3.0.6.RELEASE.jar
0.05MB
org.springframework.aspects-3.0.6.RELEASE.jar
0.03MB
org.springframework.beans-3.0.6.RELEASE.jar
0.53MB
org.springframework.context-3.0.6.RELEASE.jar
0.64MB
org.springframework.core-3.0.6.RELEASE.jar
0.36MB
org.springframework.expression-3.0.6.RELEASE.jar
0.16MB
org.springframework.jdbc-3.0.6.RELEASE.jar
0.37MB
org.springframework.transaction-3.0.6.RELEASE.jar
0.22MB
org.springframework.web.servlet-3.0.6.RELEASE.jar
0.40MB
org.springframework.web-3.0.6.RELEASE.jar
0.38MB
slf4j-api-1.5.8.jar
0.02MB
slf4j-jdk14-1.5.8.jar
0.01MB
spring.jar
2.43MB
standard.jar
0.38MB
tiles-api-2.2.2.jar
0.03MB
tiles-core-2.2.2.jar
0.15MB
tiles-jsp-2.2.2.jar
0.05MB
tiles-servlet-2.2.2.jar
0.06MB
tiles-template-2.2.2.jar
0.02MB

  서블릿에서는 브라우저 요청 처리 시 서블릿에서 제공하는 메서드를 이용해 요청명을 일일이 가져왔습니다. 그러나 스프링에서는 브라우저의 요청을 쉽게 가져올 수 있는 여러 가지 기능을 제공합니다. 그중 SimpleUrlController를 사용해 보겠습니다. 먼저 스프링을 설정합니다.

 

새프로젝트를 만들고 위에 있는 파일들을 다운로드하고 복사해서 lib 폴더에 붙여 넣어 줍니다.

스프링 설정을 마쳤으니 SimpleUrlController를 이용해 요청을 처리해 보겠습니다.

 

실습 파일에 대한 간단한 설명을 하자면..

파일 설명
web.xml 브라우저에서 *.do로 요청 시 스프링의 DispatcherServlet 클래스가 요청을 받을 수 있게 서블릿 매핑을 합니다.
action-servlet.xml 스프링 프레임워크에서 필요한 빈들을 설정합니다.
SimpleUrlController.java 매핑된 요청에 대해 컨트롤러의 기능을 수행합니다.
index.jsp 요청에 대한 컨트롤러가 브라우저로 전송하는 JSP파일입니다.

web.xml을 다음과 같이 작성합니다. 브라우저에서 *.do로 요청하면 스프링의 Dispacther Servlet클래스가 요청을 받을 수 있게 서블릿 매핑을 설정합니다. 또한 <load-on-startup>태그를 이용해 톰캣 실행 시 미리 스프링의 DispatcherServlet을 메모리에 로드 합니다.

  action-servlet.xml에 필요한 빈들을 다음과 같이 설정합니다. SimpleUrlController 클래스에 대해 id가 simpleUrlController인 빈을 생성합니다. 스프링의 SimpleUrlHandlerMapping 클래스 빈을 생성하면 요청명 /test/index.do에 대해 처리하는 컨트롤러를 SimpleUrlController로 설정합니다.

 

  SimpleUrlController 클래스는 다음과 같이 작성합니다. 설정 파일의 요청을 처리하기 위해서는 반드시 Controller 인터페이스를 구현해야 하며, SimplerUrlController 클래스로 요청 시 ModelAndView 객체를 생성해 응답할 jsp이름인 index.jsp로 설정하여 반환합니다.

  컨트롤러에서 ModelAndView의 인자로 설정된 index.jsp를 화면에 출력하도록 설정합니다.

실행해 봅니다.

반응형
블로그 이미지

꽃꽂이하는개발자

,
반응형

스프링 프레임워크는 웹 애플리케이션 개발에 필요한 여러 가지 기능을 미리 만들어서 제공합니다. MVC 기능도 그 중 하나입니다. 스프링에서 제공하는 기능 사용법을 익히고 나면 MVC기능을 일일이 만들 필요 없이 편리하게 MVC 기능을 사용할 수 있습니다.

  스프링에서 지원하는 MVC 기능의 특징은 다음과 같습니다.

  • 모델2 아키텍처를 지원합니다.
  • 스프링과 다른 모듈과의 연계가 쉽습니다.
  • 타일즈나 사이트메시같은 View 기술과의 연계가 쉽습니다.
  • 태그 라이브러리를 통해 message 출력, theme 적용 그리고 입력 폼을 보다 쉽게 구현할 수 있습니다.

스프링에서는 애플리케이션 개발 시 많이 사용되는 모델2 기반의 MVC 기능을 제공하므로 편리하게 애플리케이션을 개발할 수 있습니다. 그리고 타일즈나 사이트메시처럼 화면 관련 프레임워크와도 쉽게 연동할 수 있습니다.

구성요소 설명
DispatcherServlet 클라이언트의 요청을 전달받아 해당 요청에 대한 컨트롤러를 선택하여 클라이언트의 요청을 전달합니다. 또한 컨트롤러가 반환한 값을 View에 전달하여 알맞은 응답을 생성합니다.
HandlerMapping 클라이언트가 요청한 URL을 처리할 컨트롤러를 지정합니다.
Controller 클라이언트의 요청을 처리한 후 그 결과를 DispatcherServlet에 전달합니다.
ModelAndView 컨트롤러가 처리한 결과 및 뷰 선택에 필요한 정보를 저장합니다.
ViewResorlver 컨트롤러의 처리 결과를 전달할 뷰를 지정합니다.
View 컨트롤러의 처리 결과 화면을 생성합니다.

출처 : https://gmlwjd9405.github.io/2018/12/20/spring-mvc-framework.html

1. 브라우저가 DispatcherServlet에 URL로 접근하여 해당 정보를 요청합니다.

2. 핸들러 맵핑에서 해당 요청에 대해 매핑된 컨트롤러가 있는지 요청합니다.

3. 매핑된 컨트롤러에 대해 처리를 요청합니다.

4. 컨트롤러가 클라이언트의 요청을 처리한 결과와 View 이름을 ModelAndView에 저장해서 DispatcherServlet으로 반환합니다.

5. DispatcherServlet에서는 컨트롤러에서 보내온 View 이름을 ViewResolver로 보내 해당 View를 요청합니다.

6. ViewResorvler는 요청한 View를 보냅니다.

7. View의 처리 결과를 DispatcherServlet으로 보냅니다.

8. DispatcherServlet은 최종 결과를 브라우저로 전송합니다.

 

반응형
블로그 이미지

꽃꽂이하는개발자

,
반응형

  새로운 프로젝트를 만들고 LIB 폴더를 만들어 라이브러리 클래스를 설정합니다.(이전 글 참고) 그리고 AOP 설정 파일인 AOPTest.xml를 src패키지에 생성합니다.

  AOP를 설정하는 AOPTest.xml을 다음과 같이 작성합니다. <bean> 태그를 이용해 타깃 빈과 어드바이스 빈을 생성한 후 스프링의 ProxyFactoryBean 클래스 빈 생성 시 <property>태그를 이용해 타깃 빈과 어드바이스 빈을 엮어 줍니다. 그리고 사용할 어드바이스가 여러개이면 <value> 태그로 추가하면 됩니다.

이번에는 타깃 클래스인 Calculator 클래스를 작성합니다.

  어드바이스 클래스인 LoggingAdvice를 다음과 같이 작성합니다. 먼저 인터페이스 MethodInterceptor를 구현하고  invocation.proceed() 메서드를 기준으로 메서드 호출 전과 후 를 분리하여 로그 메시지를 출력합니다. proceed() 메서드 호출 전 구문은 타깃 메서드 호출 전에 실행하는 기능이고, 호출 후 구문은 타깃 메서드 호출 후에 실행하는 기능입니다.

  실행 클래스인 CalcTest를 다음과 같이 작성합니다. AOPTest.xml을 읽어 들여 빈을 생성한 후 타깃 클래스의 메서드를 호출하면 결과 출력 전후에 어드바이스에서 설정한 로그가 출력됩니다.

main() 메서드가 있는 실행 클래스(CalcTest.java)가 보이는 상태에서 실행 버튼을 클릭해 실행합니다.

지금 실습한 AOP기능은 타깃 클래스인 Calculator의 모든 메서드에 적용됩니다. 실제 스프링에서는 특정 패키지 이름이나 특정 클래스 이름 또는 특정 메서드 이름에만 AOP기능을 적용할 수도 있습니다.

  이런 세부 기능은 다른 기능을 학습하면서 조금씩 적용해 보기로 하겠습니다. 지금은 AOP의 개념을 확실히 이해해 두기 바랍니다.

 

반응형
블로그 이미지

꽃꽂이하는개발자

,