spring framework 3kbm.mcircle.co.kr/wp/wp-content/uploads/2014/01/spring... · 2014-01-11 ·...

Advanced Java Programming - 1 - Spring3- Oh Moon Jeong 1

Spring Framework 3.X

오 문 정 강사 ([email protected])

2013. 1.


레이어vs. 티어

•레이어–논리적분할, 단방향

•티어--물리적분할, 양방향


Java EE

Java 2 Platform, Enterprise Edition Java EE 6

•specifies technologies to support multitier enterprise applications


JAVAEE 응용어플리케이션–with EJB

비즈니스티어확장을 위한

분산객체(distributed object) 기술을적용

(+) 비즈니스티어확장을통한 가용성향상

(-) 기술복잡도가높아 이해하기어려움

(-) 개발생산성

(-) 성능

(-) 유지보수성

(-) 테스트–EJB 컨테이너필요

(-) 컨테이너이식성–벤더고유서비스

(-) 개체지향개발-컨테이너API 제약


JAVAEE 응용어플리케이션–without EJB

비즈니스컨테이너서비스는 인정

분산객체(distributed object) 기술은오버스팩

웹티어와 비즈니스티어를 분할하지 않고

웹티어내에 통합함

(+) 배우기쉬움

(+) 개발생산성

(+) 성능

(+) 유지보수성

(+) 테스트용이

(+) 컨테이너이식성-Servlet컨테이너

(+) 개체지향개발

(-) 비즈니스티어분산홖경미지원

(-) LightwegihtContainer표준이없음


POJO

•Plain Old Java Object

•Java Language 이외에 어떤 제약도 받지않는 개체

•스프링의 자바빈이란 용어는 POJO와 같은 말이다.

•POJO 가아닌사례


요약

POJO 기반J2EE 응용어플리케이션

Without EJB

프레임워크기반응용어플리케이션


SPRING FRAMEWORK


SpringFramework의 특징

스프링은 ‘어플리케이션 프레임워크’로 불리며, 웹어플리케이션은 물론 콘솔어

플리케이션, GUI어플리케이션 등 어떤 어플리케이션에도 적용 가능한 프레임

워크이다.

다양한 API와의 연동 지원을 통한JAVA EE 구현 가능하다.

POJO지원

– 특정 규약(특정 클래스로부터 상속해서 만들어야 하는 규약)에 종속되지 않는다.

– 특정 환경(특정서버 및 기술)에 종속되지 않는다.

스프링은 EJB와 같은 복잡한 순서를 거치지 않아도 간단하게 이용할 수 있기

때문에 Lightweight 컨테이너라고도 부른다.

스프링은 Dependency Injection(DI)과 Aspect Oriented Programming(AOP)

을 가장 중점적인 기술로 사용한다.


스프링 구성 모듈


스프링 설치

spring홈페이지 - http://spring.io

spring 소스 : https://github.com/SpringSource/spring-framework

maven 중앙저장소 : http://mavenrepository.com

spring-framework-3.0.1.RELEASE-A-with-docs.zip

http://spring.io/

http://spring.io/

http://spring.io/

https://github.com/SpringSource/spring-framework







D I

(dependency injection)


객체지향설계원칙

High Coherence, Low Coupling

class CD음식점 -공통모듈상속

shop::Donut

+ Donut()

shop::Bakery

+ Bakery()

+ sale(String) : Food

+ toString() : String

shop::Cafe

+ Cafe()



shop::Cake

+ Cake()

shop::Coffee

+ Coffee()

shop::ShopTest

+ main(String[]) : void

Food

- name: String

CoffeeMaker

+ make() : Coffee

DonutMaker

+ make() : Donut

«interface»

FoodMaker

+ make() : Food

«생성»

«사용»

«사용»


class CD음식점 -공통모듈상속

shop::Donut

+ Donut()

shop::Bakery

+ Bakery()



shop::Cafe

+ Cafe()



shop::Cake

+ Cake()

shop::Coffee

+ Coffee()

shop::ShopTest


Food

- name: String

CoffeeMaker

+ make() : Coffee

DonutMaker

+ make() : Donut

«interface»

FoodMaker

+ make() : Food

«생성»

«사용»

«사용»

Low Coupling ? public class Bakery{

public Bakery(){}

//케익을 만들어야한다면?

public Food sale(String type){

if("도넛".equals(type)){

FoodMaker dm = new DonutMaker( );

Donut d = dm.make();

return d;

}else if("커피".equals(type)){

FoodMaker cm = new CoffeeMaker( );

Coffee coffee = cm.make();

return coffee;

}

}

public String toString(){

return "빵집입니다.";

}


Inversion of Control (이하 IoC)란?

Component dependency resolution, configuration 및 lifecycle을 해결하기

위한 Design Pattern

DIP (Dependency Inversion Principle) 또는 Hollywood Principle (Don’t

call us we’ll call you)라는 용어로도 사용

특정 작업을 수행하기 위해 필요한 다른 컴포넌트들을 직접 생성하거나 획득하

기 보다는 이러한 의존성들을 외부에 정의하고 컨테이너에 의해 공급받는 방법

으로 동작


IoC

IoC의 장점

– 클래스 / 컴포넌트의 재사용성 증가

– 단위 테스트 용이

– Assemble과 Configure를 통한 시스템 구축 용이

IoC와 Dependency Injection 간의 관계


Dependency Injection

예시

– 객체 사이의 의존관계를 객체 자체에서가 아닌 외부설정을 이용하여 주입을 함으로써

각 객체간의 의존관계를 맺는 것을 말한다.

– 대표적인 방법으로 생성자를 통한 주입, 설정 메소드를 통한 주입이 있다.

조건

– 클래스모델이나 코드에는 런타임 시점의 의존관계가 드러나지 않는다. 그러기 위해서

는 인터페이스에만 의존하고 있어야한다. (FoodMaker를 구현한 클래스가 바뀌거나 메

서드내용이 바뀌어도 Bakery에 영향을 주지 않는다)

– 런타임 시점의 의존관계는 컨테이너나 팩토리 같은 제3의 존재가 결정한다.

– 의존관계는 사용할 오브젝트에 대한 레퍼런스를 외부에서 제공(주입)해줌으로써 만들

어진다.


Dependency Injection

class CD음식점

Shop

Cafe

- foodMaker: FoodMaker

+ Cafe(FoodMaker)

+ sale() : Food


Cake

+ Cake()

CakeMaker

+ make() : Food

Coffee

+ Coffee()

CoffeeMaker

+ make() : Food

DependencyInjection


Donut

+ Donut()

DonutMaker

+ make() : Food

Factory

+ bakery() : Bakery

+ cafe() : Cafe

+ foodMaker() : FoodMaker

Food

# name: String


«interface»

FoodMaker

+ make() : Food

Shop

Bakery


+ Bakery(FoodMaker)

+ sale() : Food


«사용»

«사용»

«생성»


런타임시의 의존관계 주입과 사용 의존관계

object OD음식점

:Bakery

::Bakery


:Factory

«interface»

:FoodMaker

:CoffeeMaker

::CoffeeMaker

+ make() : Food

:CakeMaker

«생성»

«사용 의존관계»

«의존관계주입»


Spring Container

DI을 적용하려면 각 객체들을 생성및 관리할 조립기가 필요하다.

– 개발자가 직접 만들 수도 있지만, 조립할 객체가 증가하고 의존관계가 복잡해 질수록

조립기를 만드는 일 또한 어렵다.

DI패턴을 지원해주는 프레임워크를 사용하는 것을 권장


Spring Container

어플리케이션 컨텍스트 = IoC Container = Bean Factory = Spring


Spring Container

스프링에서는 스프링이 제어권을 가지고 직접 만들고 관계를 부여하는 오브젝

트단위의 컴포넌트를 Bean이라고 한다. 동시에 스프링 빈은 스프링 컨테이너

가 생성과 관계설정, 사용등을 제어해주는 제어의 역전이 적용된 오브젝트를

말한다.

빈팩토리(Bean Factory)

– 스프링에서는 빈의 생성과 관계설정 같은 제어를 담당하는 IoC오브젝트를 라고 부른다

. 기본인터페이스명은 BeanFactory이다.

어플리케이션 컨텍스트(ApplicationContext )

– 빈팩토리라 부를 때는 주로 빈 생성과 제어의 관점에서 이야기하는 것이고, 라고 할때

는 스프링이 제공하는 애플리케이션 지원기능을 모두 포함한 경우를 말한다. 기본인터

페이스명은 ApplicationContext이며 BeanFactory의 하위인터페이스이다.

– Context 생성 시 모든Singleton Bean을 미리 loading하여Bean이 필요할 때 즉시 사용

할 수 있도록 보장한다.


Spring Container


자바코드 설정정보 XML 설정정보

빈설정파일 @Configuration <beans>

빈이름 @Bean methodName() <bean id=”methodName”

빈의 클래스 return new BeanClass class=”a.b.BeanClass” /> -- bean 기본속성 --

name : 주입받을 곳에서 호출할 이름 id : name과같음, 단 중복되면 안됨. "/"나 ","같은 특수문자포함할 수 없다. class : 주입할 클래스

Bean객체 설정 방법

@Configuration

public class Factory {

@Bean

public Bakery bakery(){ return new Bakery(foodMaker());

}

@Bean

public FoodMaker foodMaker(){

return new CoffeeMaker();

}

}

<bean id="bakery" class="shop.xml.Bakery"> <constructor-arg name="foodMaker" ref="foodMaker"> </constructor-arg> </bean> <bean id="foodMaker" class="shop.xml.CoffeeMaker"> </bean>


Bean객체 사용법

ClassPathXmlApplicationContext :

– 클래스 경로에 있는xml 파일로부터 로딩

ex) ApplicationContext context = new ClassPathXmlApplicatoinContext("c:/config.xml");

FileSystemXmlApplicationContext :

– 파일 시스템에 있는xml 파일로부터 로딩

ex) ApplicationContext context = new FileSystemXmlApplicatoinContext("c:/config.xml");

GenericXmlApplicationContext :

– 클래스 패스의 루트에 있는 xml 파일로부터 로딩

ex) GenericXmlApplicationContext context =

new GenericXmlApplicationContext(“config.xml”);

XmlWebApplicationContext :

– 웹 어플리케이션에 포함되어 있는xml 파일로부터 로딩


Bean객체 사용법

Dependency LookUp으로 빈객체 사용

public class DependencyInjection{

public static void main(String []args){

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Factory.class);

Bakery b1 = ctx.getBean("bakery", Bakery.class);

Bakery b2 = ctx.getBean("bakery", Bakery.class);

System.out.println(b1 == b2);

Food f = b1.sale();

System.out.println(f);

}

}


DI 의존관계설정 방법

생성자 방식

– XML설정 파일에서 생성자 주입 요소는 <constructor-arg>

Setter 메서드방식

– XML설정 파일에서 setter주입요소는 <property>

생성자와 Setter메서드에서 공통으로 쓰이는 속성

– 단, <property>요소는 ref속성과 value속성에만 갖는다.

속성 설명 index 생성자의 몇번째 인수에 값을 넘길 것인가를 지정한다. type 생성자의 어떤 데이터타입인 인수에 값을 넘길 것인지 지정한다. ref 자식요소<ref bean=”빈이름”/>대신 사용할 수 있다 value 자식요소<value>값</value>대신 사용할 수 있다.


<constructor-arg>

<bean id="bakery" class="shop.xml.Bakery">

<constructor-arg ><ref bean="foodMaker"/> </constructor-arg>

</bean>

<bean id="foodMaker" class="shop.xml.CoffeeMaker">

</bean>

<ref>태그대신 ref속성사용가능

– <constructor-arg ref="foodMaker"/>

전달받은 파라미터가 2개이상인 경우

– <constructor-arg value="10"/> <constructor-arg ref="sender"/>

value의 기본타입은 String타입이다. 타입지정에는 type속성설정

– <constructor-arg><value>10</value></constructor-arg>

– <constructor-arg><value type="long">10</value></constructor-arg>

id가 foodMaker인 빈객체를 생성자에 전달

public class Bakery{ private FoodMaker foodMaker; public Bakery(){} public Bakery(FoodMaker foodMaker){ this.foodMaker = foodMaker; } public Food sale(){ return foodMaker.make( ); } }


<property>

<bean id="bakery" class="shop.xml.Bakery">

<property name="foodMaker"><ref bean="foodMaker"/></property>

</bean>

<bean id="foodMaker" class="shop.xml.CoffeeMaker">

</bean>

참고)null값 처리

– <constructor-arg>나 <property>요소에서 비어있는 <value>요소를 작성하면 String타입 필드에는

빈문자열(“”)가 설정된다.( 숫자타입필드일 경우에는 예외가 발생한다.)

– 빈문자열이 아니라 명시적으로 ‘null’값을 설정하려면 <value>대신 <null>요소를 사용한다.

<constructor-arg> <null/> </constructor-arg>

id가 foodMaker 인 빈객체를 setFoodMaker()에 전달

public class Bakery{ private FoodMaker foodMaker; public Food sale(){ return foodMaker.make( ); } public void setFoodMaker(FoodMaker foodMaker) { this.foodMaker = foodMaker; } }


Collection 타입의 객체 설정 주입

<property> 또는<constructor-arg> 의 하위태그로 Collection타입의 값을 설

정하는 태그들

태그 Collection종류 설명

<list> java.util.List List 계열컬렉션값목록전달

<set> java.util.Set Set 계열컬렉션값목록전달

<map> java.util.Map Map계열컬렉션에key-value의값목록전달

<props> java.util.Properties Properties에key(String)-value(String)의값 목록전달


Collection 타입의 객체 설정 주입

public void setMyList(List list){…}

<bean id=“otherbean” class=“vo.OtherBean”/> <bean id=“myBean” class=“vo.MyVO”>

<property name=“myList”> <list><value>10</value> ->String으로저장됨

<value type=“java.lang.Integer”>20</value>->Integer로저장됨

<ref bean=“otherbean”/> </list>

</property> </bean>

<list> List 계열 컬렉션이나 배열에 값들을 넣기.

– <ref bean=“bean_id”/> : bean 객체를 list에 추가

– <value [type=“type”]>값</value> : 문자열(String), Primitive 값을 list에추가

<map>

public void setMyMap(Map map){…} <bean id=“otherbean” class=“vo.OtherBean”/> <bean id=“myBean” class=“vo.MyVO”> <property name=“myMap”> <map> <entry key=“id” value=“abc”/> <entry key=“other” value-ref=“otherbean”/> </map> </property> </bean>


autowire="byName" 의존관계 자동설정

값 의미 no Autowiring을 하지 않는다. byName Bean의 프로퍼티에 대한 Setter메서드의 이름과 같은 이름의 id

를 갖는 Bean객체를 설정해준다.

설정파일 setter주입 <bean id="driver" class="autoBy

Name.Driver" autowire="byName">

</bean>

<bean id="car" class="autoByName.Civic"/> </beans>

package autoByName; public class Driver { private Car c; public void setCar(Car c){ this.c = c; } public void driving(){ c.run(); }} package autoByName; public interface Car { void run(); } package autoByName; public class Civic implements Car { public void run() { System.out.println("CIVIC이 달린다."); }}


autowire="byType" 의존관계 자동설정

byType Bean의 프로퍼티에 대한 Setter메서드의 인수타입을 사용해 Bean객체를 설정해준다.

설정파일 setter주입 <bean id="driver" class="autoByType.Driver" autowire="byType"> </bean>

<bean id="car" class="autoByType.Civic"/>

package autoByType; public class Driver { private Car c; public void setAAA( Car c ){ this.c = c; } public void driving(){ c.run(); } }

또는 소스파일에 어노테이션을 설정해서 자원접근 수단 간소화

설정파일 setter주입 <context:annotation-config/> <bean id="driver" class="autoConfig.Driver"/> <bean id="car" class="autoConfig.Civic"/>

public class Driver { @Autowired private Car c; public void driving(){ c.run(); }}


autowire="constructor" 의존관계 자동설정

constructor 생성자 파라미터 타입과 같은 타입을 갖는 빈 객체를 생성자에 전달한다.

설정파일 생성자 주입

<bean id="driver" class="autoConstructor.Driver" autowire="constructor">

</bean> <bean id="car" class="autoConstructor.Civic"/>

package autoConstructor; public class Driver { private Car c; public Driver(Car c) { this.c = c; } public void driving(){ c.run(); } }


실습

오브젝트관계에서 생성할 Outputter빈은 FileOutputter타입의 빈을 생성한다.

MessageBean빈으로는 MessageBeanImpl타입의 빈을 생성한다.

MessageBeanImpl의 빈설정은 생성자injection으로 name을 설정하고,

setter injection으로 greeting과 outputter를 설정한다.

FileOutputter의 filePath는 a.txt로 설정한다.(setter / 생성자주입 어느것도 관계없음)

sayHello( )에서 메시지를 만들어서 [e.g)name값님 greeting값 !] output(메시지 )를 호출 한다.

output( )에서 a.txt파일에 메시지를 출력한다.


실습 테스트 소스

package message.output;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.FileSystemXmlApplicationContext;

public class MessageTest {

public static void main(String[] args) {

ApplicationContext factory =

new FileSystemXmlApplicationContext("src/message/output/beans.xml");

MessageBean bean =factory.getBean("messageBean", MessageBean.class);

bean.sayHello( );

}

}


BEAN LIFE CYCLE


Bean Scope


Bean Scope

서로 다른 Scope 빈에 대한 의존처리

– 생명주기가 더 긴 빈의 의존객체로 설정되면 의존객체의 Scope은 주입된 객체의

Scope과 같아진다.

e.g ) Singleton빈에서 Prototype빈을 사용하면 Prototype빈도 Singleton Scope을 갖는다.

올바른 범위를 적용하려면<aop:scoped-proxy/>태그를 사용

<bean id="p" class="~" scope="prototype">

<aop:scoped-proxy/>

</bean>

<bean id="s" class="XXX">

<property name="p" ref="p"/>

</bean>

Singleton빈 Prototype빈 사용


Bean Life Cycle


Bean Life Cycle

bean의 init-method속성

– 설정된 메서드명의 메서드가 빈 객체 생성 후 한번 실행

<bean id="messageBean" class="lifecycle.MessageBeanImpl" init-method="init">

bean의 destroy-method속성

– 설정된 메서드명의 메서드가 빈 객체가 힙에서 삭제되기 전에 실행

bean의 lazy-init 속성

– ApplicationContext를 이용하면 ApplicationContext가 초기화되는 시점에 모든 Bean을 생성해 놓고 이용한다. 하지만 필요한 시점에 객체를 생성하기 원하다면 lazy-init속성을 지정한다.

<bean id=”messageTest” class=”MessageBean” lazy-init=”true” />

bean의 depends-on 속성

– XML에 설정한 순서대로 Bean객체가 생성되는 것이 default이다. 하지만 depends-on속성으로 강제 순서를 지정할 수 있다. 해당 bean보다 먼저 생성해야하는 bean을 값으로 준다.<bean id="userService" class="a.Service" depends-on=”userDAO"/>

<bean id=”userDAO” class=”UserDAO” />

bean의 factory-method속성

– private생성자를 갖는 빈을 참조할 메서드 지정


어노테이션기반 설정


어노테이션

설정파일에 <context:annotation-config>등록

@Required

– 반드시 의존주입되어야하는 프로퍼티용 setter메서드에 사용한다.

@Required

public void setNumber(int number){ }

<bean id="r" c="a.b.Foo">

<property name="number" value="1">

@Autowired

– 설정된 생성자/필드/메서드는 객체생성시 자동 호출됨.

– 프로퍼티타입으로 빈찾음.

– 동일타입의 빈이 두개 이상이면 예외 발생한다.

– 해당빈을 찾지 못하면 예외발생됨.

– 어노테이션적용필수여부지정해서 해당빈을 없으면 자동설정 안하도록한다.

@Autowired(required=false)public void setA(A a){ }


어노테이션

@Qualifier

– 동일타입의 빈들 중에서 특정빈을 사용하도록 설정가능.

@Autowired @Qualifier("main") private Recorder recorder;

<bean id="re1" class="a.b.Recorder"><qualifier value="main">

<bean id="re2" class="a.b.Recorder">

@Resource

– 프로퍼티이름으로 빈을 찾음

@Resource private DataSource ds;

@PostConstruct , @PreDestroy

– init-method속성과 destroy_method속성과 같은 역할


어노테이션

@Component

– XML에 <bean>을 설정하지 않아도 자동검색되어 빈으로 등록될 클래스에 선언한다.

– 단, xml에 <context:component-scan base-package="자동검색할 패키지명"/>을 지정

한다.

– 빈의 name을 지정하려면 어노테이션속성값을 지정한다. @Component("aController")

– 빈의 scope을 지정하려면 @Scope어노테이션을 추가한다.

@Component@Scope("prototype")

@Configuration

– 스프링3에서는 XML대신 자바코드로 스프링컨테이너에 빈객체를 제공할 수 있다.

– 빈객체 설정용 클래스에 선언한다.

@Bean

– @Configuration클래스에서 새로운 빈객체를 제공할때 사용된다.

– 메서드이름이 아닌 다른 이름을 빈객체의 name으로 사용하려면 어노테이션의 name

속성을 사용한다 @Bean(name="cDAO") public CustomerDAO customerDAO(){ }


실습개요

스프링 데이터 소스용 API인

org.springframework.jdbc.datasource.SimpleDriverDataSource를 주입해서

매번DB와의 연결중복을 피한다.

SimpleDriverDataSource는 org.springframework.jdbc-3.0.1.RELEASE.jar에

있으므로 build path에 추가해야한다.


실습 테스트 소스

package datasource;

:

public class CustomerDAOTest{

public static void main(String []args){

//실습1 Lookup방법

ClassPathXmlApplicationContext ctx =

new ClassPathXmlApplicationContext("dsApplicationContext.xml", CustomerDAOTest.class);

//실습2 Lookup방법

/*AnnotationConfigApplicationContext ctx =

new AnnotationConfigApplicationContext(DAOFactory.class);

*/

CustomerDAO dao = ctx.getBean("customerDAO", CustomerDAO.class);

try {

Customer c = dao.findById("id0");

} catch (Exception e) {

e.printStackTrace();

}

}

}


실습1 - Autowired를 이용한 CustomerDAOImpl과 설정파일 만들기

실습내용

XML설정파일을 완성하고, CustomerDAOImpl에 dataSource를 autowire한다

DataSource용 설정내용은 아래와 같다. 파일명 : (dsApplication.xml) <bean id="dataSource" class="org.springframework.jdbc.datasource.SimpleDriverDataSource"> <property name="driverClass" value=""/> <property name="url" value=""/> <property name="username" value=""/> <property name="password" value=""/> </bean>

:CustomerDao

Impl


실습2 - @Controller어노테이션를 이용하는 Factory클래스 만들기

Autowire실습에서 사용한 XML설정파일 대신 어노테이션을 활용한 Factory클

래스를 사용한다.

클래스 이름 : DAOFactory

object OD데이터소스

:DAOFactory

:CustomerDAO

«interface»

:DataSource

:SimpleDataSource

«생성»

«의존관계주입»

«사용

의존관계»

:CustomerDao

Impl


AOP

Aspect Oriented Programming



여러업무의 공통기능을 클래스단위로 모으고 모듈로부터 분리함으로써 재사용

성과 보수성을 높이는 것이 OOP이다. 그러나 그 기능을 사용하기 위한 코드까

지는 각 모듈로부터 분리할 수 없었다. 그렇기 때문에 분리한 기능을 이용하기

위해서는 코드가 각 모듈에 횡단으로 산재(Cross -cutting Concern)하게 된다.

핵심관심 (core concerns)

– 시스템의 핵심 가치와 목적이 그대로 드러난 관심영역..

비즈니스 로직

횡단관심 (crosscutting concern)

– 아래와 같은 쉽게 모듈화 되지 않는 부분

-로그작성(logging), -보안/인증(security/authentication), -트랜잭션(transaction),

-리소스 풀링(resource pooling), -에러검사(error checking), -정책적용(policy),

-멀티쓰레드 안전관리(multithread), -데이터 퍼시스턴스(persistence) 등




– 핵심관심 사항과 횡단관심사항(공통모듈)을 기준으로 프로그래밍함으로써 공통모듈을

손쉽게 적용할 수 있게 해준다.

AOP에서는 횡단관점까지 분리하여 각 모듈로부터 관점에 관한 코드를 완전히

제거하는 것을 목표로 한다.


AOP 용 어

프로그램 실행순서

pointcut A Advice X

pointcut B Advice

Y joinpoint

Advisor

Advisor Advice를 적용가능한

지점을 말한다.

핵심로직

WHEN + WHAT (공통코드)

공통관심기능을 언제 핵심로직에

적용할지를 정의한 것

WHERE

여러 개의 조인포인트를

하나로 결합한 것

Advice와 Pointcut을 하나로 묶어 취급한 빈

Weaving : Advice를 Pointcut에 삽입하는 것


Weaving방식

Weaving

– Advice를 Pointcut에 삽입하는 것

컴파일시에 Weaving

– AspectJ에서 사용하는 방식

– 컴파일할때 알맞은 위치에 공통코드를 삽입

클래스로딩시에 Weaving (LoadTimeWeaving)

– AspectJ에서 사용하는 방식

– 로딩한 클래스의 바이너리 정보를 변경하여 알맞은 위치에 공통코드를 삽입한 새로운

바이너리 코드를 사용한다.

– 원본클래스파일은 변경하지 않는다.

런타임시에 Weaving (동적AOP)

– 프록시를 생성하여 핵심로직을 구현한 객체에 접근하게 된다.


클래스 다이어그램

Logging 처리

<<interface>> MessageBean

+sayHello(name:String)

MessageBeanImpl +sayHello(name:String)

Spring AOP


Proxy기반 AOP 구현

필요 라이브러리

– org.springframwork.aop-3.X-RELEASE.jar

– com.springsource.org.aopalliance-1.0.0.jar

AOP구현 절차

1. Advice 클래스 작성하기. 설정파일에 Advide설정한다.

2. 설정파일에 PointCut을 설정한다.

3. 설정파일에 Advice와 PointCut을 묶어 놓은 Advisor를 설정한다.

4. 설정파일에 ProxyFactoryBean클래스를 이용하여 대상 객체에 Advisor를 적용한다.

5. getBean()메소드로 빈객체를 가져와 사용한다.


Proxy기반 AOP

<<interface>> MessageBean

+sayHello(name:String)

LogginAdvice (부가기능) +invoke( )

Target ( 핵심기능 ) MessageBeanImpl +sayHello(name:String) JoinPoint

Proxy +sayHello(name:String)

<bean id="logginAdvice">

<bean id="proxy">

프록시에서 쓰일

Target빈 주입

Advisor빈 주입

<<interface>> MethodInterceptor

+invoke( )

Advisor

<bean id="helloAdvisor" ~>

사용할 Advice빈 주입

Pointcut용 메서드설정

<bean

id="messageBean"


Proxy패턴

다이나믹 프록시와 프록시 팩토리 빈

– 프록시 클래스 없이도 프록시 오브젝트를 런타임시에 만들어주는 JDK다이나믹 프록시

기술을 적용할 수 있다.

– 하지만 동일한 기능의 프록시를 여러 오브젝트에 적용할 경우 오브젝트 단위로 중복이

일어나는 문제가 있다.

– JDK다이나믹 프록시와 같은 프록시 기술을 추상화한 스프링의 프록시 팩토리 빈을

이용해서 다이나믹 프로시 생성 방법에 DI를 도입했다.

– 스프링의 ProxyFactoryBean은 프록시를 생성해서 빈 오브젝트로 등록하게 해주는

팩토리 빈이다.


Proxy기반 AOP 구현절차

1. Advice클래스 작성하기 (aop.LoggingAdvic)

advice 타입 인터페이스 설명

Before advice org.springframework.aop. MethodBeforeAdvice

joinpoint전에 수행되는 advice. 하지만 joinpoint를 위한 수행 흐름 처리(execution flow proceeding)를 막기위한 능력(만약 예외를 던지지 않는다면)을 가지지는 않는다.

After returning advice

org.springframework.aop. AfterReturningAdvice

joinpoint이 일반적으로 예를 들어 메소드가 예외를 던지는것없이 반환된다면 완성된 후에 수행되는 advice.

After throwing advice

org.springframework.aop.ThrowsAdvice

메소드가 예외를 던져서 빠져나갈때 수행되는 advice

Around advice

org.aopalliance.intercept.MethodInterceptor

메소드 호출과 같은 joinpoint주위(surround)의 advice. 이것은 가장 강력한 종류의 advice이다. Around advice는 메소드 호출 전후에 사용자 정의 행위를 수행할수 있다. joinpoint를 처리하거나 자기 자신의 반환값을 반환함으로써 짧게 수행하거나 예외를 던지는 것인지에 대해 책임을 진다.

설정파일명 : e.g src/sample1/proxyaop.xml

1. 설정파일에 Advice빈 설정한다.

2. 설정파일에 Advisor (Advice참조정보와 PointCut)를 설정한다.

<bean id="helloAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor"> <property name="advice"> <ref local="loggingAdvice" /> </property> <property name="pointcut"> <bean class="org.springframework.aop.support.JdkRegexpMethodPointcut"> <property name="pattern">  <value>.*sayHello.*</value> </property> </bean> </property> </bean>

<bean id="loggingAdvice" class="sample1.LoggingAdvice" />

4. 설정파일에 ProxyFactoryBean클래스를 이용하여 대상 객체에 Advisor를

적용한다.

<bean id="targetBean" class="aop.MessageBeanImpl">

<property name="name">

<value>Spring</value>

</property>

</bean>



<bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">

<property name="target">

<ref local="targetBean" />

</property>

<property name="interceptorNames"> 

<list>

<value>helloAdvisor</value>

</list>

</property>

</bean>




package sample1;

import org.springframework.context.support.FileSystemXmlApplicationContext;

public class AopTest {


FileSystemXmlApplicationContext ctx =

new FileSystemXmlApplicationContext("src/sample1/proxyaop.xml");

//MessageBean인터페이스를 구현한

//MessageBeanImpl(핵심관점용 빈:타깃), XXX클래스(부가관점용 빈:프록시)가 있다.

//클라이언트는 프록시를 lookup

MessageBean bean = ctx.getBean("proxy", MessageBean.class);

//클라이언트가 프록시의 sayHello()를 요청하면

// 포인트컷으로 설정된 타깃의 sayHello()메서드 호출전후에

// 어드바이스:sample1.LoggingAdvice를 수행한다.

bean.sayHello();

}

}


AspectJ기반 AOP 구현

필요 라이브러리

– com.springsource.org.aspect-1.6.6-RELEASE.jar

– aspectjrt.jar

– aspectjweaver.jar

AspectJ포인트컷 표현식은 포인트컷 지시자를 이용해 작성한다.

– 포인트컷 지시자 중 가장 대표적으로 사용되는 지사자가 execution( )이다.

– [ ]는 생략가능, | 는 OR조건이다.

포인트컷 설명

execution Bean의 조건에 맞는 메서드나 생성자의 실행을 Pointcut으로 한다.

within Bean이 조건에 설정한 타입이라면 메서드의 실행을 Pointcut으로 한다.

this Bean이 조건에 설정한 타입에 대입할 수 있는 인스턴스라면, 메서드 실행을 Pointcut으로 한다.

target 대상이 되는 객체가 조건에 설정된 타입에 대입할 수 있는 인스턴스라면, 메서드의 실행을 Pointcut으로 한다.

args 메서드의 인수가 조건에 설정한 타입에 대입할 수 있는 인스턴스라면, 메서드 실행을 Pointcut으로 한다.


AspectJ포인트컷 표현식

패턴문자 * : 1개의 모든값을 표현 (파라미터로쓰일 경우 1개의 파라미터,

package로쓰일 경우 1개의 하위패키지)

.. : 0개이상

execution (

[접근제한자 패턴]

리턴값타입 패턴 - 반드시 하나의 타입을 지정해야한다. 또는 *를 써서 모든 타입을 다 선택하겠다고 해도 된다.

[패키지와 클래스이름에 대한 타입패턴] -사용할때는 패키지.클래스형태로 .을 두어 연결해야한다 *를 이용할

수 있다. “..”를 사용하면 한번에 여러 개의 패키지를 선택할 수 있다.

메서드 이름패턴 -모든메서드를 다 선택하겠다면 *를 넣으면 된다.

( 파라미터 타입패턴 | “..”, …)

파라미터의 타입패턴을 순서대로 넣을 수 있다.

파라미터가 없는 메서드를 지정하려면 ( )로 적는다

파라미터의 타입과 개수에 상관없이 모두 다허용하는 패턴을 만드려면 “..”을 넣으면 된다.

”…”을 사용해서 뒷부분의 파라미터 조건만 생략할 수 있다

[ throws 예외패턴 ]

)


AspectJ포인트컷 표현식

within

– within(패키지패턴.클래스패턴)

– e.g) within(test.spring.service.MemberService), within(test.spring..MemberServlice)

bean

– bean(bean이름패턴)

– e.g) bean(memberService), bean(*Service)


AspectJ 포인트컷 표현식의 메서드 선정예제

a.b.Target a.b.Bean

void hello()

void hello(String)

int plus( int,int)

int minus(int,int ) throws RuntimeException

void method( )

void method( ) throws RuntimeException

1 execution(* hello(.. ) ) o o

2 execution(* hello( ) ) o

3 execution(* hello(String) o

4 execution(* meth*(..) ) o o

5 execution(* *(int, int) ) o o

6 execution(* *( ) ) o o o

7 execution(* a.b.Target.*(..)) o o o o o

8 execution(* a.b.*.*(..)) o o o o o o

9 execution(* a.b..*.*(..)) o o o o o O

10 execution(* a..*.*(..)) o o o o o O

11 execution(* com..*.*(..)) 12 execution(* *..Target.*(..)) o o o o O

13 execution(* *..Tar*.*(..)) o o o o O

14 execution(* *..*get.*(..)) O o o o o

15 execution(* *..B*.*(..)) O

16 execution(* *..TargetInterface.*(..)) o o o O

17 execution(* *(..) throws Runtime*) O O

18 execution(int *(..)) o O

19 execution(void *(..)) o o o O

ex) a.b.TargetInterface +hello( ) +hello(String) +plus(int, int) +minus(int, int) a.b.Target


AspectJ기반 AOP Advice종류

Before Advice

– 대상객체의메소드가실행되기전에실행됨

– return type : 상관없다.

– argument : 없거나JoinPoint객체를받는다.

<aop:before method="logBefore" pointcut-ref="logPointCut" />

public void logBefore(JoinPoint jp){ }



After Returing Advice

– 대상객체의 메소드 실행이 정상적으로 끝난 뒤 실행됨


– argument :

• 없거나JoinPoint객체를받는다. 없거나JoinPoint객체를받는다. JoinPoint는항상첫argument로사용

된다.

• 대상메소드에서리턴되는값을argument로받을수있다.

• type : Object 또는 대상메소드에서return하는 value의 type

<aop:after-returning pointcut-ref=“publicmethod”

method="returnLogging" returning=“retValue”/>

public void returnLogging(Object retValue){ }

87



After Throwing Advice

– 대상객체의메소드실행중예외가발생한경우실행됨

– return type : 상관없으나void로한다.

– argument :

• 없거나 JoinPoint객체를받는다. JoinPoint는 항상 첫argument로 사용된다.

• 대상메소드에서 전달되는예외객체를 argument로 받을 수 있다.

<aop:after-throwing pointcut-ref=“publicmethod”

method="throwingLogging" throwing="ex"/>

public void throwingLogging(JoinPoint jp, MyException ex){

}



After Advice

– 대상객체의 메소드 실행이 종료된 뒤 오류발생여부와 상관없이 무조건 실행된다.


– argument :

• 없거나JoinPoint객체를받는다.

<aop:afterpointcut-ref=“publicmethod” method=“afterLogging” />

public void afterLogging(){ }



Around Advice

– 위의 네가지Advice를 다 구현할수 있는Advice.

– return type : Object

– argument

• JoinPoint를 반드시 첫argument로 지정한다.

<aop:around pointcut-ref=“publicmethod” method=“aroundLogging” />

public Object aroundLogging(ProceedingJoinPointjoinPoint) throws Throwable{

//대상객체의메소드호출전해야할전처리코드

Object retValue = joinPoint.proceed(); //대상객체의메소드호출

//대상객체처리이후해야할후처리코드

return retValue; //호출한곳으로리턴값넘긴다. –넘기기전수정가능

}


JoinPoint

대상객체에대한정보를가지고있는객체로Spring container로부터받는다.

– org.aspectj.lang패키지에있음

– 반드시Advice 메소드의첫argument로와야한다.

– 메소드들

• Signature: 호출되는대상객체에대한구문정보를가진객체

• Object getTarget() : 대상객체를리턴

• Object[] getArgs() : 파라미터로넘겨진값들을배열로리턴. 넘어온값이없으면빈배열개체가return

됨.

• Signature getSignature() : 호출되는메소드의정보

• String getName() : 대상메소드명리턴

• String toShorString() : 대상메소드명리턴

• String toLongString() : 대상메서드전체syntax를리턴

• String getDeclaringTypeName() : 대상메소드가포함된type을return. (package명.type명)

AspectJ기반 AOP 구현절차

1. Advice클래스 작성하기 (aspectj.LoggingAdvice)

2. 설정파일에 Advice빈 설정한다. (설정파일명 : e.g src/aspectj/aspectjaop.xml )

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:aop="http://www.springframework.org/schema/aop"

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



<bean id="loggingAdvice" class="aspectj.LoggingAdvice" />


AOP 설정태그

<aop:config> : aop설정의root 태그. Aspect 설정들의 묶음

<aop:aspect> :

– Aspect 설정

– 하나의Aspect 설정, Aspect가 여러개일 경우<aop:aspect>태그가 여러개온다.

– 한개의Aspect (advice + pointcut)을설정

– 속성

• ref : 공통관심사항을 설정한Bean(Advice 빈)참조

• id:식별자. 다른Aspect 태그와 구별하기 위한 식별자

– 자식태그

• <aop:pointcut> : pointcut지정

– advice관련태그가 올 수 있다.


AOP 설정태그

<aop:pointcut> : Advice에서 참조할 pointcut설정

– Pointcut(공통기능이적용될곳)을 지정하는 태그

– <aop:config>나<aop:aspect>의 자식태그

– AspectJ표현식을 통해 pointcut지정

– 속성:

• id : 식별자로advice 태그에서사용됨

• expression : pointcut지정

<aop:pointcut id=“publicmethod” expression=“execution(public * org.myspring..*.*(..))”/>

Advice Weaving 설정태그들

A. <aop:before> -메소드실행전실행될Advice

B. <aop:after-returning> -메소드정상실행후실행될Advice

C.<aop:after-throwing> -메소드에서예외발생시실행될Advice

D.<aop:after> -메소드정상또는예외발생상관없이실행될Advice –finally

E.<aop:around> -모든시점에서적용시킬수있는Advice 구현

설정파일 샘플

<aop:config>



<aop:aspect id="logAspece" ref="loggingAdvice">



<aop:pointcut expression="execution(* sayHello() )" id="logPointCut"/>



<aop:before method="logBefore" pointcut-ref="logPointCut" />

<aop:after-returning method="logAfterReturning" pointcut-ref="logPointCut" />

<aop:after method="logAfter" pointcut-ref="logPointCut"/>

<aop:around method="logAround" pointcut-ref="logPointCut"

</aop:aspect>

</aop:config>

<bean id="targetBean" class="aspectj.MessageBeanImpl">

<property name="name"><value>Spring</value></property>

</bean>


AspectJ기반 AOP 구현절차


public class AspectjTest {


FileSystemXmlApplicationContext ctx =

new FileSystemXmlApplicationContext("src/aspectj/aspectjaop.xml");

MessageBean bean = ctx.getBean("targetBean", MessageBean.class);

bean.sayHello();

}

}


@Aspect 어노테이션을이용한AOP

@Aspect 어노테이션을이용하여Aspect 클래스에직접Advice 및Pointcut등을

직접설정

설정파일에<aop:aspectj-autoproxy/> 를추가해야함

Aspect class를<bean>으로등록

– 어노테이션(Annotation)

• @Aspect : Aspect 클래스선언

• @Before(“pointcut”)

• @AfterReturning(pointcut=“”, returning=“”)

• @AfterThrowing(pointcut=“”, throwing=“”)

• @After(“pointcut”)

• @Around(“pointcut”)

– Around를 제외한 나머지 메소드들은 첫argument로 JoinPoint를 가질 수 있다.

– Around메소드는 argument로 ProceedingJoinPoint를 가질 수 있다.


@Aspect 어노테이션을이용한AOP 구현절차

1. Advice클래스 작성하기

@Aspect

public class LoggingAdvice {

@Pointcut("execution(* sayHello() )")

public void pointcut(){ } //포인트컷을 적용한 메서드. Advice관련 어노테이션에서 해당메서드이름으로 포인트컷을 사용할 수 있게된다.

@Before("pointcut()")

public Object logBefore(JoinPoint jp) throws Throwable{

}

@Around("execution(* sayHello() )")

public Object logAround(ProceedingJoinPoint pjp) throws Throwable {

}


@Aspect 어노테이션을이용한AOP 구현절차

2. 설정파일에 aspectj-autoproxy 요소를 설정한다.

(설정파일명 : e.g src/aspectj/aspectjannotation.xml ))

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:aop="http://www.springframework.org/schema/aop"

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

<aop:aspectj-autoproxy />

<bean id="loggingAdvice" class="aspectj.annotation.LoggingAdvice" />

<bean id="targetBean" class="aspectj.annotation.MessageBeanImpl">

<property name="name"> <value>Spring</value> </property>

</bean>


스프링 JDBC


부가기능과 핵심기능

add( )

PreparedStatement pstmt =

추가작업

pstmt.executeUpdate( )

delete( )


삭제작업


기능

변하는 부분

변하지 않는 부분


Template Method Pattern

CustomerDAOAdd

makeStatement( )

PreparedStatement pstmt

= con.prepareStatement( sql );

//추가작업

pstmt.setString(1, id) ;

pstmt.setString(2, name);

pstmt.setString(3, password);

return pstmt;

CustomerDAODelete

makeStatement( )


= con.prepareStatement( sql );

//삭제작업

pstmt.setString(1, id) ;

return pstmt;

<<abstract>>CustomerDAO

add( )


= makeStatement( );


delete( )


= makeStatement( );


abstract makeStatement( ) :

PreparedStatement


Strategy Pattern

Context Strategy

Concrete Strategy

A

Concrete Strategy

B

자주 변하는 부분을 만들어줄 외부기능을 말함 변하지 않는 부분을 말함

client

strategy선택, 생성

Strategy제공 Context정보제공


Strategy Pattern

class Class Model

DeleteStatement

+ makeStatement(Connection) : PreparedStatement

CustomerDAO

+ jdbcContextWithStatementStrategy(StatementStratagy) : void

Connection con=null;

PreparedStatement pstmt =null;

try {

con= dataSource.getConnection();

pstmt = stmt.makeStatement(con);

pstmt.executeUpdate();

}catch(SQLException sqle){

throw sqle;

}finally{

if(pstmt != null) pstmt.close();

if(con != null) con.close();

}

+ add(Customer) : void

StatementStratgy st = new AddStatement(c);

jdbcContextWithStatementStrategy(st);

AddStatement

- c: Customer

+ AddStatement(Customer)


String sql =

"INSERT INTO customer" +

" (ID, PASSWORD, NAME, GENDER,

ZIP, REGDATE, ADDRESS) " +

" VALUES (?, ?, ?, ?, ?,

SYSDATE, ?)";


con.prepareStatement(sql);

pstmt.setString(1, c.getId());

pstmt.setString(2, c.getPassword());

pstmt.setString(3, c.getName());

pstmt.setString(4, c.getGender());

pstmt.setString(5, c.getZip());

pstmt.setString(6, c.getAddress());

return pstmt;

«interface»

StatementStrategy


1. 클 라 이 언 트 가 strategy선택

2. Context

Context정보제공

3 Strategy


Context와 DI

변하지않는 Context부분(jdbcContextWithStatementStrategy) 은 다른 클라

이언트(XXXDAO)들에게도 사용 가능하다. 따라서 Context를 클라이언트

(CustomerDAO)에서 분리해 본다. 이렇게 분리된 Context를 템플릿이라고 할

수 있다.


Context를 템플릿클래스로 분리, 변경


DI 설정

<bean id="customerDAO" class="com.my.dao.CustomerDAO">

<property name="dataSource" ref="dataSource" />

</bean>

<bean id="dataSource" class="org.springframework.jdbc.datasource.SimpleDriverDataSource">

<property name="driverClass" value="oracle.jdbc.driver.OracleDriver"/>

<property name="url" value="jdbc:oracle:thin:@127.0.0.1:1521:XE"/>

<property name="username" value="hr"/>

<property name="password" value="hr"/>

</bean>


구현 Strategy를 클라이언트의 Anonymous Class로 변경

public void add(final Customer c) throws SQLException{

jdbcContext.workWithStatementStrategy(

new StatementStrategy( ){

public PreparedStatement makeStatement(Connection con) throws SQLException{

String sql =


" " (ID, PASSWORD, NAME, GENDER, ZIP, REGDATE, ADDRESS) " +

" VALUES (?, ?, ?, ?, ?, SYSDATE, ?)";

PreparedStatement pstmt = con.prepareStatement(sql);







return pstmt;

}

} );

}


public class JdbcContext { private DataSource dataSource; public void setDataSource(DataSource dataSource) { this.dataSource = dataSource; } //템플릿 public void workWithStatementStrategy( StatementStrategy stmt) throws SQLException{ Connection con=null; PreparedStatement pstmt =null; try { con= dataSource.getConnection(); pstmt = stmt.makeStatement(con); pstmt.executeUpdate(); }catch(SQLException sqle){ throw sqle; }finally{ if(pstmt != null) pstmt.close(); if(con != null) con.close(); } } }

Template Callback 패턴을





String sql =



" VALUES (?, ?, ?, ?, ?, SYSDATE, ?)";








return pstmt;

}

} );

}

1. Callback

생성

2. Template

호출

3. 참조정보 생성

4. Callback호출

5. 클라이언트 final변수참조

6. 작업수행 후 반환

7. 작업수행


콜백부분의 변하는 구문과 변하지 않는 구문 분리 이전





String sql =



" VALUES (?, ?, ?, ?, ?, SYSDATE, ?)";








return pstmt;

}

} );

}

변하는 부분

변하지 않는

부분


콜백부분의 구문 분리이후

public class CustomerDAO {

…..


String sql ="INSERT INTO customer" +

" (ID, PASSWORD, NAME, GENDER, ZIP, REGDATE, ADDRESS) " +

" VALUES (?, ?, ?, ?, ?, SYSDATE, ?)";

jdbcContext.executeSQL(

sql, c.getId(), c.getPassword(), c.getName(), c.getGender(), c.getZip(),c.getAddress());

}

--------------------------------------------------------------------------------------------------------------

public class JdbcContext {

….

private void executeSQL(final String sql, final Object... args) throws SQLException {

jdbcContext.workWithStatementStrategy(new StatementStrategy(){



for(int i=0; i<args.length; i++){

pstmt.setObject(i+1, args[i]);

}

return pstmt;

}

}); }

}


스프링 JDBC API

JdbcTemplate

– 스프링은 JDBC를 이용하는 DAO에서 사용할 수 있도록 준비된 다양한 템플릿을 제공

한다. 거의 모든 종류의 JDBC코드에 사용 가능한 템플릿과 콜백을 제공한다.

SimpleJdbcTemplate

– JdbcTemplate과 NamedParameterJdbcTemplate에서 가장 많이 사용되는 기능을 통

합하고 JAVA5이상의 장점을 최대한 활용할 수 있게 만든 API이다. JDBC의 모든 기능을

최대한 활용할 수 있는 유연성을 갖고 있다.

SimpleJdbcInsert, SimpleJdbcCall

– DB가 제공해주는 메타정보를 활용해서 최소한의 코드만으로 단순한 JDBC코드를 작성

하게 해준다


스프링의 JdbcTemplate

update( ) String sql = "INSERT INTO customer(ID, PASSWORD, NAME) VALUES (?, ?, ?) "; jdbcTemplate.update( sql , c.getId(), c.getPassword(), c.getName() );

queryForObject( ) String sql = "SELECT * FROM customer WHERE id=?"; String idValue = "id0"; jdbcTemplate.queryForObject( sql, new Object[]{ idValue }, new RowMapper<Customer>() {

public Customer mapRow(ResultSet rs, int rowNum) throws SQLException{

Customer c = new Customer(); c.setId(rs.getString("id")); c.setPassword(rs.getString("password")); c.setName(rs.getString("name")); return c;

} } );


스프링의 JdbcTemplate

query String sql = "SELECT * FROM customer ORDER BY id"; jdbcTemplate.query(

sql, new RowMapper<Customer>( ){ public Customer mapRow(ResultSet rs, int rowNum)

throws SQLException { Customer c = new Customer(); c.setId(rs.getString("id")); c.setPassword(rs.getString("password")); c.setName(rs.getString("name")); return c; } }

);

queryForInt String sql = "SELECT COUNT(*) FROM customer"; return this.jdbcTemplate.queryForInt(sql);


스프링JDBC API

스프링JDBC가 해주는 작업

– Connection열기, 닫기

– Statement준비와 닫기

– Statement실행

– ResultSet반복

– 예외처리와 변환 : JDBC작업중 발생하는 모든 예외는 스프링JDBC의 예외 변환기가 처

리해준다. CheckedException인 SQLException을 RuntimeException인

DataAccessException타입으로 변환해준다. 런타임 예외로 전환할 뿐 아니라 DB별 에러

코드를 참고해서 일관된 의미를 가진 DataAccessException 계층구조 내의 예외로 변환

해준다.

– 트랜잭션 처리 : 스프링JDBC는 트랜잭션 동기화 기법을 이용해 선언적 트랜잭션 기능

과 맞물려 돌아간다. 트랜잭션을 시작한 후에 스프링 JDBC의 작업을 요청하면 진행중

인 트랜잭션에 참여한다. 트랜잭션이 없는 채로 호출될 경우에는 새로운 트랜잭션을 만

들어서 사용하고 작업을 마치면 트랜잭션을 종료한다.


SpringJDBC용 Exception

DataAccessException

NonTransient

DataAccessException

DataIntegrityViolation

Exception

DataRetrievalFailure

Exception

PermissionDenied

DataAccessException

InvalidDataAccessResour

ceUsageException

DuplicateKey

Exception

BadSqlGrammar

Exception

TypeMismatch

DataAccessException


SPRING MVC


Spring MVC 구성 주요 컴포넌트

DispatcherServlet - Front Controller

Controller - 클라이언트 요청 처리를 수행하는 Controller

HandlerMapping - 클라이언트의 요청을 처리할

Controller를 찾는 작업처리

View - 응답하는 로직을 처리

ViewResolver - 응답할 View를 찾는 작업을 처리

ModelAndView - 응답할 View와 View에게 전달할 값을 저장하는 용도의 객체


Spring MVC를이용한어플리케이션작성 순서

1. web.xml에 DispacherServlet등록 및 ㅌ 등록

2. 설정파일에 HandlerMapping 설정

3. 컨트롤러구현 및 Spring 설정파일에 등록

4. 컨트롤러와 JSP의 연결위해 View Resolver설정

5. JSP코드작성


web.xml에 DispatcherServlet 설정

<servlet>

<servlet-name>web1</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>


<url-pattern>*.do</url-pattern>

</servlet-mapping>


web.xml의 캐릭터 인코딩 처리를 위한 필터설정

<filter>

<filter-name>encodingFilter</filter-name>

<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>

<init-param>

<param-name>encoding</param-name>

<param-value>EUC-KR</param-value>

</init-param>

</filter>

<filter-mapping>

<filter-name>encodingFilter</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>


스프링설정파일

Spring Container는 설정파일의 내용을읽어 WebApplicationContext객체를

생성

설정파일내용

– MVC 구성요소(HandlerMapping, Controller, ViewResolver, View) 설정

– bean, aop를 설정

설정파일명 기본 작성규칙

– "<servlet-name>-servlet.xml"

– WEB-INF\아래에 추가 한다.



다른이름의 설정파일 또는 여러 설정파일이 필요할 경우

– <servlet>의 하위태그인<init-param>에 contextConfigLocation이름으로 등록

– 경로는Application Root부터 절대경로로표시

– 여러 개의 경우 , 또는 공백으로 구분

<servlet>


<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<load-on-startup>1</load-on-startup>

<init-param>

<param-name>contextConfigLocation</param-name>

<param-value>/WEB-INF/server-service.xml

/WEB-INF/dao-service.xml

</param-value>

</init-param>

</servlet>



공통Spring 설정파일등록

– 공통 스프링설정파일들을 로드하기위해 리스너(ContextLoaderListener) 설정

– 공통 스프링 설정파일명은 applicationContext.xml이다.

공통설정파일이 여러 개인 경우

<listener>

<listener-class>

org.springframework.web.context.ContextLoaderListener

</listener-class>

</listener>

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>/WEB-INF/service-service.xml

/WEB-INF/dao-data.xml

</param-value>

</context-param>


HandlerMapping

RequestURL과 컨트롤러를 매핑시켜준다.

다양한 HandlerMapping 클래스를 Springframework가 제공

Spring 설정파일에<bean>으로 등록해서 설정한다.

HandlerMapping 인터페이스를 구현한 클래스들

매핑방법Ant경로패턴

? : 1개의 문자와 매칭 * : 0개의 문자와 매칭 ** : 0개이상의 디렉터리와 매칭

종류 빈으로 등록여부

BeanNameUrlHandlerMapping DEFAULT

SimpleUrlHandlerMapping

ControllerBeanNameHandlerMapping

ControllerClassNameHandlerMapping

DefaultAnnotationHandlerMapping DEFAULT

HandlerMapping

BeanNameUrlHandlerMapping

– 빈 이름을 이용해 매핑해 주는 핸들러 매핑 전략이다.

– url과 일치하는 빈 이름을 갖는 빈을 컨트롤러로 사용한다.

– 디폴트 핸들러 매핑이기 때문에 BeanNameUrlHandlerMapping을 빈으로 등록하지 않

아도 된다.

<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" />

<bean name="/test.do" class="web1.TestController"/>

– 빈아이디를 이용 못함

• id에는 /추가 못함



public class TestController implements Controller{ }


HandlerMapping

SimpleUrlHandlerMapping

– BeanNameUrlHandlerMapping은 빈 이름에 매핑정보를 넣기 때문에 매핑정보를 관리하기

불편하다는 단점이 있다.

– URL과 컨트롤러의 매핑정보를 한곳에 모아놓을 수 있는 핸들러 매핑이다.

– 매핑정보는 SimpleUrlHandlerMapping빈의 프로퍼티에 넣어준다.

– 디폴트 핸들러 매핑이 아니기 때문에 프로퍼티에 매핑정보를 직접넣어 빈을 등록해야 사

용할 수 있다.

<bean id=”handlerMapping

class=”org.springframework.web.servlet.handler.SimpleUrlHandlerMapping” >

<property name=”mapping”>

<props>

<prop key="/content/**/*.do">indexController</prop>

<prop key="greeting/hello.do">detailController</prop>

</props>

</property>

</bean>

<bean name="indexController" … />

<bean name="detailController" … />


HandlerMapping

ControllerBeanNameHandlerMapping

– 빈의 아이디나 빈 이름을 이용해 매핑해 주는 핸들러 매핑 전략이다.

– ControllerBeanNameHandlerMapping이 자동으로 빈 아이디에 ‘/’를 붙여주기 때문에 빈

의 아이디로도 매핑할 URL을 지정할 수 있다.

– 다음과 같이 컨트롤러 빈이 선언되어 있다면, hello빈을 /hello.do URL에 매핑해준다.

<bean id=”hello.do” class=”controller.AController”>

– 디폴트 핸들러 매핑이 아니기 때문에 ControllerBeanNameHandlerMapping 을 빈으로 등

록해줘야 적용된다.

– 빈 이름 앞뒤에 붙일 수 있는 prefix와 suffix를 지정할 수 있다.

<property name=”urlPrefix” value=”/app/sub/” />

</bean>

@Component(“hello.do”)

public class MyController implements Controller{ }

/app/sub/hello.do

URL에 매핑

<bean class=”org.springframework.web.servlet.mvc.support.ControllerBeanNameUrlHandlerMapping>


HandlerMapping

ControllerClassNameHandlerMapping

– 빈이름 대신 클래스이름을 URL에 매핑해주는 핸들러 매핑 클래스다.

– 기본적으로 클래스 이름을 모두 URL로 사용하지만 Controller로 끝날때는 Controller를 뺀

나머지 이름을 URL에 매핑해준다.

– 다음과 같은 컨트롤러 클래스는 ‘/hello’ URL에 매핑된다.

– 디폴트 핸들러 매핑이 아니기 때문에 ControllerClassNameHandlerMapping을 빈으로 등

록해줘야 적용된다.

<bean class=”org.springframework.web.servlet.mvc.support.ControllerClassNameUrlHandlerMapping />

public class HelloController implements Controller{ }


HandlerMapping

DefaultAnnotationHandlerMapping

– 디폴트 핸들러매핑이므로 기본설정을 바꾸지 않는 한 빈으로 등록할 필요가 없다.

– @Controller클래스에 대한 매핑을 처리한다.


Controller

비즈니스 로직을 호출하여 처리결과 ModelAndView인스턴스를 반환한다

Controller 작성법

– Controller 인터페이스를 구현한 클래스를 이용하는 방법

• public class IndexController implements Controller{

public ModelAndView handleRequest(HttpServletRequest request,

HttpServletResponse response) throws Exception {

}

}

– @Controller 어노테이션을 이용한 방법

• 컨트롤러의 역할을 담당하는 메서드의 파라메터 개수와 타입, 리턴타입등을 자유롭게 결정할 수

있다.

• 여기에 @RequestMapping을 비롯한 다양한 어노테이션을 메서드나 파라미터에 적용해서 컨트

롤러 로직에 대한 추가정보를 제공할 수도 있다.


Controller

@Controller어노테이션 작성절차

1. @Controller 어노테이션 : 컨트롤러 클래스에 적용한다

2. @RequestMapping 어노테이션 : 클라이언트의 요청을 처리할 메서드에 적용한다.

3. 설정파일에 컨트롤러 클래스를 빈으로 등록한다.

<context:annotation-config></context:annotation-config>

<bean id="helloController" class="web1.HelloController"></bean>

@Controller public class HelloController { @RequestMapping("welcome.do") public ModelAndView hello(){ System.out.println("welcome.do용 controller입니다!"); ModelAndView mav = new ModelAndView(); mav.setViewName("/WEB-INF/view/hello.jsp"); Map<String, String> model = new HashMap<String, String>(); model.put("greeting", "WELCOME! OhMoonJeong's SPRING MVC"); mav.addAllObjects(model); return mav; } }


Controller

@Controller

– 컨트롤러용 클래스에 지정한다.

컨트롤러 메서드에 선언하는 어노테이션

– @RequestMapping

– @ModelAttribute

– @InitBinder


Controller의 메서드 파라미터의 종류

파라미터 설명

HttpServletRequest HttpServletResponse

HttpSession

Locale

java.util.Locale타입. DispatcherServlet의 LocaleResolver가 결정한 Locale객체를 받는다.

InputStream, Reader HttpServletRequest의 getInputStream()을 통해 받을 수 있는 콘텐트 스트림

OutputStream,Writer HttpServletResponse의 getOutputStream()을 통해 받을 수 있는 콘텐트 스트림

@PathVariable

@RequestMapping의 URL에 { }로 들어가는 패스 변수를 받는다. 요청 파라미터를 URL의 쿼리스트링으로 보내는 대신 URL패스로 풀어쓰는 방식에 유용. 예를 들어 /user/view?id=10보다 /user/view/10이 이해가 쉽고 보기좋다. @ReqiestMapping(“/user/view/{id}”) public String view(@PathVariable(“id”) int id){ }로 처리가능



@RequestParam

Http요청 파라미터를 메서드 파라미터에 넣어주는 애노테이션 public String view(@RequestParam(“id”) int id,

@RequestParam(“name”) String name){ }

@RequestParam애노테이션을 사용했다면 해당 파라미터가 반드시 있어야한다. 없으면 HTTP400오류 발생. 파라미터를 필수가 아닌 선택 제공하려면 required 속성을 false로 지정할 수 있다 public void view( @RequestParam(value=”id”, request=false, defaultValue=”-1”) int id){ } 요청파라미터의 이름과 메서드파라미터의 이름이 일치하면 @RequestParam의 이름은 생략가능한다. public String view(@RequetsParam int id) { }

@CookieValue

요청과 함께 전달된 쿠키값을 메서드 파라미터에 넣어준다. 애노테이션의 기본값에 쿠키의 이름을 지정한다. public void check(@CookieValue (“auth”) String auth) { } public void check( @CookieValue (value=“auth”, required false, defaultValue=”NONE”) String auth) { }



Map, Model, ModelMap

모델정보를 담을 때 사용하는 객체(컬렉션)가 전달된다. Model과 ModelMap은 addAttribute()메서드를 제공하고, Map은 put()를 제공한다. public void hello(ModelMap model){ User user = new User(1, “Spring”); //모델 model.addAttribute(user); // addAttribute(“user”, user)와 같음 }



@ModelAttribute

메서드파라미터에도 부여할 수 있고 메서드 레벨에 적용할 수도 있음 1. command객체 초기화 @RequestParam으로 여러 HTTP파라미터를 개별적으로 가져오는 것보다, 그 값을 모두 갖고 있는 하나의 객체로 한번에 받을 수 있도록 한다. @RequestMapping(“/user/search”) public String search(@ModelAttribute UserSerch userSearch){ } 2. 별도의 메서드로 Model에 추가될 객체를 생성 @Controller public class ModelAttributeController { @ModelAttribute ("nameArray") public String[] getName(){ System.out.println("getName()"); return new String[ ]{"추신수", "류현진", "이대호"}; } @RequestMapping("/modelAttribute/main.do") public String main(){ System.out.println("main()"); return "main"; //main뷰에 nameArray모델이 함께 전달됨. } @RequestMapping("/modelAttribute/play.do") public String play(){ System.out.println("play()"); return "play"; //play뷰에 nameArray모델이 함께 전달됨. }



SessionStatus 현재 세션을 다룰 수 있는 객체를 제공해준다. 세션안에 저장된 객체를 제거해줄 때 사용. sessionStatus.setComplete( ) ;

@RequestBody HTTP요청의 body부분을 그대로 전달한다. XML이나 JSP기반의 메시지를 사용하는 요청에서 유용. public void message(@RequestBody String body){ }

@Value

값을 파라미터에 부여한다. 주로 시스템 프로퍼티를 가져와 파라미터에 대입가능하다. public String hello(@Value(“#{SystemProperties[‘os.name’]}”) String name) { }


Controller의 메서드 리턴 타입의 종류

리턴 타입 설 명

ModelAndView 뷰정보및 모델정보를 담고있는 ModelAndView객체

Model 뷰에 전달할 객체정보를 담고있는 Model을 리턴한다. 이때 뷰이름은

요청URL로부터 결정된다.

Map 뷰에 전달할 객체정보를 담고있는 Map을 리턴한다. 이때 뷰이름은 요청URL로부터 결정된다.

String 뷰이름을 리턴한다.

View객체 View객체를 직접 리턴, 해당 View객체를 이용해서 뷰를 생성한다.

void 메서드가 ServletResponse나 HttpServletResponse타입의 파라미터를 갖는경우 메서드가 직접 응답을 처리한다고 가정한다. 그렇지 않을

경우 요청URL로 부터 결정된 뷰를 보여준다.

@ResponseBody어노테이션적용

파라미터에서 @ResponseBody어노테이션이 적용된경우, 리턴객체를 HTTP응답으로 전송한다.


Controller

@RequestMapping

– 컨트롤러 클래스나 메서드에 직접 부여하고 이를 이용해서 매핑 한다.

– 메서드 단위로 URL을 매핑할 수 있어서 컨트롤러의 개수를 줄일 수 있다.

– URL뿐 아니라 GET/POST와 같은 HTTP메서드, 심지어는 파라미터와 HTTP헤더정보까지

매핑에 활용할 수 있다

– 특정 파라미터가 지정됐을 때만 따로 분리하는 식의 컨트롤러 매핑이 가능하다

– 매핑정보가 지저분해지고 관리하기 힘들어진다

– 디폴트 핸들러 매핑이므로 기본설정을 바꾸지 않는 한 빈으로 등록할 필요가 없다

@RequestMapping( value="/login.do", method=RequestMethod.GET )

public String form() { return "loginForm"; }

@RequestMapping(value="/login.do", method=RequestMethod.POST)

public ModelAndView submit( @RequestParam("id") String id, @RequestParam String password) { }


Controller

컨트롤러 클래스 자동스캔

– <context:component-scan base-package="web1">


ModelAndView

Controller처리 결과후 응답할 view와 view에 전달할 값을 저장.

생성자

– ModelAndView(String viewName) : 응답할view설정

– ModelAndView(String viewName, Map values) : 응답할view와view로전달할 값들을 저장

한Map 객체

– ModelAndView(String viewName, String name, Object value) : 응답할view이름, view로

넘길 객체의name-value

주요메소드

– setViewName(String view) : 응답할view이름을 설정

– addObject(String name, Object value) : view에 전달할 값을 설정, requestScope에 설정됨

– addAllObjects(Map values) : view에전달할값을Map에name-value로저장하여 한번에 설정

Redirect 방식전송 : view이름에redirect: 접두어붙인다.

ex)mv.setViewName(“redirect:/welcome.html”);


ViewResolver

Controller가 넘긴 view이름을 통해 알맞은view를 찾는 역할

– 1. Controller는 ModelAndView객체에 응답할 view이름을 넣어 return.

– 2. DispatchServlet은 ViewResolver에게 응답할view를 요청한다.

– 3. ViewResolver는 View이름을 이용해 알맞은 view객체를 찾아 DispatcherServlet에게

전달.

Spring 설정파일에 등록 한다.


ViewResolver

ViewResolver의 종류

– InternalResourceViewResolver

• JSP나HTML등의 내부자원을 이용해 뷰 생성

• InternalResourceView를 기본 뷰로 사용

– BeanNameViewResolver

• 뷰의 이름과 동일한 이름을 가지는 빈을 View로 사용

• 사용자정의View객체를 사용하는 경우 주로 사용

– XmlViewResolver

• BeanNameViewResolver와 동일하나 뷰객체를 Xml 파일에 설정해놓는 것이 차이.

• Bean 등록시 location 프러퍼티에 xml 파일을 지정


InternalResourceViewResolver 설정

ModelAndView mav = new ModelAndView(); mav.setViewName("/WEB-INF/view/hello.jsp");

<bean id="viewResolver"

class="org.springframework.web.servlet.view.InternalResourceViewResolver">

<property name="prefix" value="/WEB-INF/view/"></property>

<property name="suffix" value=".jsp"></property>

</bean>

ModelAndView mav = new ModelAndView(); mav.setViewName("hello");


View

JSP를 이용한 뷰 구현

JSP에서 사용가능한 custom tag

– <spring:message>

– <form:errors>


Message 처리

MessageSource를 이용한 메시지 국제화처리

메시지파일의 종류

– message.properties : 기본메시지파일. 시스템의 언어및 지역에 맞는 프로퍼티 파일이

존재하지 않을 경우에 사용한다.

– message_en.properties : 영어 메시지파일

– message_ko.properties : 한글 메시지파일

– message_en_UK.properites : 영국을 위한 영어 메시지파일

메시지파일은 클래스저장경로와 같다.

greeting=WELCOME.

login.success=login success

login.fail.id=ID {0} is not exist

login.fail.password=invalid password

greeting=환영합니다.

login.success=로그인성공

login.fail.id=아이디{0}가 존재하지않습니다

login.fail.password=비밀번호가 일치하지않습니다

Message 처리

ApplicationContext는 MessageSource 인터페이스를 상속받고 있다.

MessageSource API

– String getMessage(String code, Object[ ] args, String defaultMessage, Locale locale);

– String getMessage(String code, Object[ ] args, Locale locale);

– String getMessage(MessageSourceResolvable resolvable, Locale locale);

ApplicationContext는 등록된 빈 객체중에서 이름이 "messageSource"인

MessageSource타입의 빈객체를 이용하여 메시지를 가져온다.

<bean id="messageSource"

class="org.springframework.context.support.ResourceBundleMessageSource">

<property name="basenames">

<list>

<value>message</value>

</list>

</property>



</bean>


Message 처리

빈객체에서 메시지 이용하기

MessageSourceAware 인터페이스를 구현한뒤 setMessageSource( )메서드를 통

해 전달받은 MessageSource의 getMessage( )메서드를 이용하여 메시지 사용

public class LoginController implements MessageSourceAware{

private MessageSource messageSource;

@Override

public void setMessageSource(MessageSource messageSource) {

this.messageSource = messageSource;

}

:

Locale kr = Locale.getDefault();

String msg = messageSource.getMessage("login.success", new Object[0], kr);

String []args = new String[]{ "id0" };

msg = messageSource.getMessage("login.fail.id", args, kr);

mav.addObject("message",msg);

mav.setViewName("msg");

:

greeting=환영합니다.

login.success=로그인성공

login.fail.id=아이디{0}가 존재하지않습니다

login.fail.password=비밀번호가 일치하지않습니다

Validation

validation.properties파일

설정파일

#errorcode=value

required=필수입력항목입니다

<bean id="messageSource"

class="org.springframework.context.support.ResourceBundleMessageSource">

<property name="basenames">

<list>

<value>message</value>

<value>validation</value>

</list>

</property>



</bean>


Validation

Validator인터페이스 ( org.springframework.validation.Validator )

– 폼값을 저장한 Command객체의 유효성 여부를 검사

– boolean supports(Class<?>class)

• Validator가 해당클래스에 대한 값 검증을 지원하는지 여부를 리턴한다

– void validate(Object target, Errors errors)

• target객체에 대한 검증을 실행한다. 검증 결과 문제가 있을 경우 Errors객체에 어떤 문제인지에

대한 정보를 저장한다

public class CustomerValidator implements Validator {

public boolean supports(Class<?> arg0) {

return Customer.class.isAssignableFrom(arg0);

}

public void validate(Object target, Errors errors) {

Customer c = (Customer)target;

if( c.getId()==null|| c.getId().trim().equals("")) {

errors.rejectValue("id", "required"); //타깃객체의 id프로퍼티에 required에러코드를 등록

}

}


Validation

Error인터페이스 ( org.springframework.validation.Errors )

– 입력한 값이 유효하지 않은 경우 Errors에 에러메시지를 저장해서 뷰에 전달

BindingResult인터페이스

– 폼값을 Command객체에 바인딩한 결과를 저장하고, 에러코드로부터 에러메시지를 가

져온다

Errors

BindingResult

AbstractBindingResult


Validation

Errors인터페이스

– reject메서드 : 검증대상객체의 전체에러를 설정

• reject(String errorCode) : 전체 객체에 대한 글로벌 에러코드를 추가한다

• reject(String errorCode, String defaultMessage) : 전체객체에 대한 글로벌 에러코드를 추가한다.

에러코드에 대한 메시지가 존재하지 않을경우 defaultMessage를 사용한다

• reject(String errorCode, Object[]errorArgs, String defaultMessage) : 전체객체에 대한 글로벌 에

러코드를 추가한다. 메시지 인자로 errorArgs를 전달한다. 에러코드에 대한 메시지가 존재하지

않을 경우 defaultMessage를 사용한다

– rejectValue메서드 : 특정프로퍼티의 검증에러를 설정

• rejectValue(String filed, String errorCode) : 필드에 대한 에러코드를 추가한다

• rejectValue(String field, String errorCode, String defaultMessage):필드에 대한 에러코드를 추가

한다. 에러코드에 대한 메시지가 존재하지 않을 경우 defaultMessage를 사용한다

public void validate(Object target, Errors errors) {

errors.rejectValue("id", "required"); //타깃객체의 id프로퍼티에 required에러코드를 등록

}


Validation

Errors

– hasErrors( ) 에러가 존재하는 경우 true를 리턴

– getErrorCount( ) 에러개수를 리턴

– hasGlobalErrors( ) reject()메서드를 이용해서 추가된 글로벌 에러가 존재할 경우 true리

턴

– getGlobalErrorCount( ) reject()메서드를 이용해서 추가된 글로벌 에러 개수를 리턴

– hasFieldErrors( ) rejectValue( )메서드를 이요해서 추가된 에러가 존재할 경우 true리

턴

– getFieldErrorCount( ) rejectValue( )메서드를 이용해서 추가된 에러개수를 리턴

– hasFieldErrors(String field) rejectValue( )메서드를 이용해서 추가한 특정필드의 에러

가 존재할 경우 true리턴

– getFieldErrorCount(String field) rejectValue( )메서드를 이용해서 추가한 특정 필드의

에러 개수를 리턴


Validation

Controller에서 검증

– @RequestMapping 메서드에 BindingResult타입 또는 Error타입의 파라미터를 추가한

다.

@RequestMapping(method=RequestMethod.POST)

public ModelAndView submit( @Valid

@ModelAttribute("c") Customer command,

BindingResult result){

CustomerValidator validator = new CustomerValidator();

validator.validate(command, result);

if(result.hasErrors()){

mav.setViewName("signupForm");

}

}


Validation

JSP에서 에러메시지 설정방법

– <%@taglib uri="http://www.springframework.org/tags" prefix="spring" %>

• <spring:hasBindErrors> name속성에 명시한 커맨드 객체와 관련된 정보를 <form:errors>태그

에서 사용할 수 있도록 설정한다.

– <%@taglib uri="http://www.springframework.org/tags/form" prefix="form" %>

• <form:errors> path속성에 명시한 커맨드객체.프로퍼티와 관련된 모든 에러메시지를 출력한다.

<%@taglib uri="http://www.springframework.org/tags" prefix="spring" %>

<%@taglib uri="http://www.springframework.org/tags/form" prefix="form" %>

<spring:hasBindErrors name="c”/>

<input type="text" name="id“> <form:errors path="c.id"/>


TRANSACTION


Transaction

EJB의 선언적 트랜잭션 경계설정 기능을 복잡한 환경이나 구현조건없이 POJO

의 장점을 유지한 채 SPRING에도 제공한다.

트랜잭션 방법

– 코드에 의한 트랜잭션 경계 설정

– 선언적 트랜잭션 경계 설정

• 코드 내에서 직접 트랜잭션을 관리하지 않아도 된다.

• 프록시 AOP를 이용해서 트랜잭션기능을 부여하는 방법

1. AOP와 tx네임스페이스

2. @Transactional어노테이션


AOP와 tx네임스페이스

1. 트랜잭션 어드바이스

2. 포인트컷 : 기본적으로 인터페이스에 적용된다.

3. 어드바이저

<tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes> <tx:method name="*" />

</tx:attributes> </tx:advice>

<aop:pointcut id="a" expression="execution(public void com.my.dao.CustomerDAO.*(..))"/>

<aop:config > <aop:pointcut id="a" expression="execution(public void com.my.dao.CustomerDAO.*(..))"/>

<aop:advisor advice-ref="txAdvice" pointcut-ref="a"/> </aop:config> 또는 <aop:config >

<aop:advisor advice-ref="txAdvice" pointcut=" execution(public void com.my.dao.CustomerDAO.*(..))"/> </aop:config>


@Transactional 어노테이션

1. 설정파일

<tx:annotation-driven transaction-manager="txManager"/>

<bean id="txManager"

class="org.springframework.jdbc.datasource.DataSourceTransactionManager">


</bean>

<bean id="customerDAO" class="com.my.dao.CustomerDAOImpl">


</bean>

2. 트랜잭션이 적용될 타깃 인터페이스나 클래스, 메서드등에 @Transactional

어노테이션을 부여해서 트랜잭션 대상으로 지정하고 트랜잭션 속성을 제공한다

어노테이션 적용 우선순위

클래스의 메서드@Transactional ( 높음 )

클래스@Transactional

인터페이스의 메서드@ Transactional

인터페이스 @Transactional ( 낮음 )

트랜잭션 속성

트랜잭션 어드바이스 @Transactional어노테이션

<tx:attributes> <tx:method name=” ” read-only=” “ isolation=” “ propagation=” “ timeout=” “ rollback-for=” “ no-rollback-for=” “ /> </tx:attributes>

@Transactional(

readOnly= , isolation= ,

propagation= , timeout= ,

rollback-for= , no-rollback-for= )

e. g) <tx:advice id="txAdvice" transaction-manager="txManager"> <tx:attributes> <tx:method name="add*" propagation="REQUIRED"/>  

e.g) @Transactional( propagation=Propagation.REQUIRED, rollbackFor=Exception.class ) public void add(Customer c) throws Exception{ }


트랜잭션 전파

트랜잭션 경계의 시작점에서 트랜잭션 전파 속성을 참조해서 해당 범위의 트랜

잭션을 어떤식으로 진행시킬지 결정할 수 있다. 모든 속성이 모든 종류의 트랜

잭션 매니저와 데이터 액세스 기술에서 다 지원되지 않을 수 있으니 각 트랜잭

션 매니저의 API문서를 참고해야 한다.


트랜잭션의 전파(PROPAGATION_REQUIRED)

호출된 메소드가 호출한 쪽의 트랜잭션에서 실행되는 경우

uncheckedException


트랜잭션의 전파(PROPAGATION_ NOT_SUPPORTED)

호출된 메소드가 트랜잭션 없이 실행되는 경우


트랜잭션의 전파(PROPAGATION_REQUIRES_NEW)

호출된 메소드가 별도의 새로운 트랜잭션내에서 실행되는 경우


트랜잭션의 전파속성(propagation)

전파 설명

PROPAGATION_REQUIRED 활성화된 트랜잭션이 존재한다면 스프링은 이 트랜잭션을 사용하고 그렇지 않다면 새로운 트랜잭션을 시작한다.

PROPAGATION_ SUPPORTS 활성화된 트랜잭션이 존재한다면 스프링은 이 트랜잭션을 사용하지만 활성화된 트랜잭션이 없다면 새로운 트랜잭션을 시작하지 않는다.

PROPAGATION_MANDATORY 활성화된 트랜잭션이 존재한다면 스프링은 이 트랜잭션을 사용하지만 활성화된 트랜잭션이 없다면 스프링은 예외를 던진다.

PROPAGATION_REQUIRES_NEW 스프링은 항상 새로운 트랜잭션을 시작한다. 만약 활성화된 트랜잭션이 이미 존재한다면 이 트랜잭션은 잠시 중지된다.

PROPAGATION_ NOT_SUPPORTED

스프링은 활성화된 트랜잭션 내에서 코드를 실행하지 않는다. 코드는 항상 트랜잭션이 아닌 상태에서 실행되며 기존에 존재하는 트랜잭션이 있다면 모두 잠시 중지시킨다.

PROPAGATION_NEVER 활성화된 트랜잭션이 존재해도 항상 트랜잭션 없이 코드를 실행한다. 만약 활성화된 트랜잭션이 존재한다면 예외를 던진다.

PROPAGATION_NESTED

활성화된 트랜잭션이 존재 하면 중첩된 트랜잭션 내에서 실행된다. 만약 활성화된 트랜잭션이 없다면 코드는 TransactionDefinition.PROPAGATION_REQUIRED가 설정된 것처럼 실행된다.


트랜잭션 propagation과 rollback-for속성

spring framework 3kbm.mcircle.co.kr/wp/wp-content/uploads/2014/01/spring... · 2014-01-11 ·...

Documents