AOP의 개념 정리를 위한 TEST

SPRING_SETTING/spring

AOP의 개념 정리를 위한 TEST

우혁이 아빠 2010. 12. 17. 17:42

package springbook.learningtest.jdk.proxy;

import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.*;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.junit.Test;
import org.springframework.aop.ClassFilter;
import org.springframework.aop.Pointcut;
import org.springframework.aop.framework.ProxyFactoryBean;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.aop.support.NameMatchMethodPointcut;

public class DynamicProxyTest {
	
	/*
	 * 1 단계 테스트
	 * HelloTarget Class는 Hello Interface를 구현한 Class로써 
	 * 다른 인사말을 출력하게 각각의 method들을 구현하였다.
	 * 그런데, 갑돌이의 요구사항이 발생.
	 * 모든 인사말이 대문자로 출력하고 싶단다.
	 * 이런경우 대부분 Hello Interface를 다시 HelloUpperCase Class를 만들 것이다.
	 * java.lang.reflect.Proxy Class를 이용하여 처리해보자.
	 * 장점은 구현해야 할 메소드가 100개, 200개일 경우 작업량을 줄일 수 있다.
	 */
	@Test
	public void simpleProxy() throws Exception {
		Hello hello = new HelloTarget();
		assertThat(hello.sayHello("Toby"), is("Hello Toby"));
		assertThat(hello.sayHi("Toby"), is("Hi Toby"));
		assertThat(hello.sayThankYou("Toby"), is("Thank You Toby"));
		
		/*
		 * 특정 클래스의 메소드가 실행될 때 전처리 또는 후처리를 해주고 싶다면
		 * Proxy Class를 이용해 보자.
		 */
		Hello proxiedHello = (Hello) Proxy.newProxyInstance(
				// ClassLoader 객체
				getClass().getClassLoader(), 
				// 담을 객체
				new Class[]{ Hello.class }, 
				// InvocationHandler 인터페이스의 invoke 메소드를 구현한 객체
				new UppercaseHandler(new HelloTarget())
		);
		
		assertThat(proxiedHello.sayHello("Toby"), is("HELLO TOBY"));
		assertThat(proxiedHello.sayHi("Toby"), is("HI TOBY"));
		assertThat(proxiedHello.sayThankYou("Toby"), is("THANK YOU TOBY"));
	}
	
	static class UppercaseHandler implements InvocationHandler {

Object target;
		
		private UppercaseHandler(Object target) {
			this.target = target;
		}
		
		// 메소드가 호출 될 때마다 실행이 된다.
		@Override
		public Object invoke(Object proxy, Method method, Object[] args)
				throws Throwable {
			
			// 메소드를 실행하고 결과값을 Object에 넣는다.
			Object ret = method.invoke(target, args);
			
			// 결과값이 String.class이고 mthod의 이름이 say로 시작하면
			if (ret instanceof String && method.getName().startsWith("say")) {
				// 대문자로 바꿔라 라는 갑돌이의 요구사항을 적용시켜준다.
				return ((String) ret).toUpperCase();
			} else {
				return ret;
			}
		}
		
	}
	
	static interface Hello {
		String sayHello(String name);
		String sayHi(String name);
		String sayThankYou(String name);
	}
	
	static class HelloTarget implements Hello {

@Override
		public String sayHello(String name) {
			return "Hello " + name;
		}

@Override
		public String sayHi(String name) {
			return "Hi " + name;
		}

@Override
		public String sayThankYou(String name) {
			return "Thank You " + name;
		}
		
	}

/*
	 * 2 단계 테스트
	 * org.springframework.aop.framework.ProxyFactoryBean Class를 이용하여
	 * Proxy Class를 이용하여 HelloTarger Class의 결과값을 대문자로 찍어보자.
	 */
	@Test
	public void proxyFactoryBean() throws Exception {
		// 우선 ProxyFactoryBean 객체를 생성하고
		ProxyFactoryBean pfBean = new ProxyFactoryBean();
		// 목표가 되는 Class를 세팅해주고
		pfBean.setTarget(new HelloTarget());
		// advice를 부착하면 끝
		// 여기서 advice(조언-작업지시서)란 MethodInterceptor Interface를 구현한 
		// 객체로 InvocationHandler 구현과 마찬가지로 invoke()메소드를 
		// 구현하면 된다.
		pfBean.addAdvice(new UppercaseAdvice());
		
		// 그리고 객체를 얻어온다.
		Hello proxiedHello = (Hello) pfBean.getObject();
		
		assertThat(proxiedHello.sayHello("Toby"), is("HELLO TOBY"));
		assertThat(proxiedHello.sayHi("Toby"), is("HI TOBY"));
		assertThat(proxiedHello.sayThankYou("Toby"), is("THANK YOU TOBY"));
	}
	
	static class UppercaseAdvice implements MethodInterceptor {

@Override
		public Object invoke(MethodInvocation invocation) throws Throwable {
			// 메소드를 실행하고 결과값을 얻어낸다.
			String ret = (String) invocation.proceed();
			// 그리고 원하는 작업을 수행하면 끝
			return ret.toUpperCase();
		}
		
	}

/*
	 * 3 단계 테스트
	 * 갑돌이들의 요구사항은 끝이 없다. sayH로 시작하는 메소드는 대문자로,
	 * 나머지 기존대로 인사말이 보고 싶단다. ㅋㅋㅋ 갑돌이 들이란...
	 * org.springframework.aop.support.NameMatchMethodPointcut Class와
	 * org.springframework.aop.support.DefaultPointcutAdvisor를 이용하여
	 * 완성시켜보자
	 */
	@Test
	public void pointcutAdvisor() throws Exception {
		// NameMatchMethodPointcut Class 객체를 생성하고
		// 원하는 메소드의 이름을 세팅해주고
		NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();
		pointcut.setMappedName("sayH*");

ProxyFactoryBean pfBean = new ProxyFactoryBean();
		pfBean.setTarget(new HelloTarget());
		
		// advice가 아닌 advisor를 부착해 준다.
		// 인자로는 아까 생성한 NameMatchMethodPointcut 객체, 그리고 전에 생성한
		// MethodInterceptor의 구현 객체를 넣어주면 된다.
		pfBean.addAdvisor(new DefaultPointcutAdvisor(pointcut, new UppercaseAdvice()));
		
		// 그리고 Proxy가 적용된 객체를 불러오면 끝...
		Hello proxiedHello = (Hello) pfBean.getObject();
		
		assertThat(proxiedHello.sayHello("Toby"), is("HELLO TOBY"));
		assertThat(proxiedHello.sayHi("Toby"), is("HI TOBY"));
		assertThat(proxiedHello.sayThankYou("Toby"), is("Thank You Toby"));
	}
	
	/*
	 * 4 단계 테스트
	 * 요구사항에 맞춰 개발하다보니 원하는 메소드뿐만 아니라 원하는 클래스에서만
	 * 대문자를 출력 기능을 넣어보고 싶다.
	 */
	@SuppressWarnings("serial")
	@Test
	public void classNamePointcutAdvisor() throws Exception {
	// 원하는 Class 설정은 NameMatchMethodPointcut Class의 getClassFilter() 메소드를
	// overriding 해주면 된다. 그런데 ClassFilter 객체를 만들면서도 matches() 메소드를
	// overriding 해주어야 한다. 두번의 overriding 복잡다....
		NameMatchMethodPointcut classMethodPointcut = new NameMatchMethodPointcut() {
			
			@Override
			public ClassFilter getClassFilter() {
				return new ClassFilter() {

@Override
					public boolean matches(Class<?> clazz) {
						return clazz.getSimpleName().startsWith("HelloT");
					}
					
				};
			}
			
		};
		classMethodPointcut.setMappedName("sayH*");

/*
		 * target이 되는 Class를 세개 만들어서 테스트를 진행하므로 중복되는
		 * ProxyFactoryBean 객체 생성, target setting, 확인 등의 코드를 
		 * 추출하여 checkAdvice() 메소드로 만들었다.
		 */
		checkAdvice(new HelloTarget(), classMethodPointcut, true);
		
		class HelloWorld extends HelloTarget {};
		checkAdvice(new HelloWorld(), classMethodPointcut, false);
		
		class HelloToby extends HelloTarget {};
		checkAdvice(new HelloToby(), classMethodPointcut, true);
	}

private void checkAdvice(Object target,
			Pointcut pointcut, boolean adviced) {
		ProxyFactoryBean pfBean = new ProxyFactoryBean();
		pfBean.setTarget(target);
		pfBean.addAdvisor(new DefaultPointcutAdvisor(pointcut, new UppercaseAdvice()));
		Hello proxiedHello = (Hello) pfBean.getObject();
		
		if (adviced) {
			assertThat(proxiedHello.sayHello("Toby"), is("HELLO TOBY"));
			assertThat(proxiedHello.sayHi("Toby"), is("HI TOBY"));
			assertThat(proxiedHello.sayThankYou("Toby"), is("Thank You Toby"));
		} else {
			assertThat(proxiedHello.sayHello("Toby"), is("Hello Toby"));
			assertThat(proxiedHello.sayHi("Toby"), is("Hi Toby"));
			assertThat(proxiedHello.sayThankYou("Toby"), is("Thank You Toby"));
		}
	}
	
}

토비의 스프링 3.0 에서 가져온 예제... 좋은 책은 사서 보세요...

저작자표시