动态代理工厂

代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。
为了保持行为的一致性，代理类和委托类通常会实现相同的接口，所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层，能有效控制对委托类对象的直接访问，也可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性。Java 动态代理机制以巧妙的方式近乎完美地实践了代理模式的设计理念。

【JDK方式的动态代理】

package com.xcl.common;

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

public class ProxyFactory implements InvocationHandler {

	private Object targetObj;

	public Object createProxyInstance(Object targetObj) {
		this.targetObj = targetObj;
		return Proxy.newProxyInstance(this.targetObj.getClass().getClassLoader(), 
				this.targetObj.getClass().getInterfaces(),this);
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		UserServiceBean bean = (UserServiceBean) this.targetObj;
                  Object result = null;
		if (bean.getUser() != null && !"".equals(bean.getUser())) {
			//把方法的调用委派给目标对象
			result = method.invoke(this.targetObj, args);			
		}
		return result;
	}
}

class UserServiceBean implements UserService {

	private String user = null;

	public String getUser() {
		return user;
	}

	public void setUser(String user) {
		this.user = user;
	}

	public UserServiceBean() {
	}

	public UserServiceBean(String user) {
		this.user = user;
	}

	@Override
	public String getUserName(Integer personId) {

		System.out.println("我是getUserName方法");
		return "xxx";
	}

	@Override
	public String saveUser(String user) {
		System.out.println("我是saveUser方法");
		return "yyy";
	}

}

interface UserService {
	public String getUserName(Integer personId);

	public String saveUser(String user);
}

【cglib方式的动态代理】

package com.xcl.common;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CglibProxyFactory implements MethodInterceptor {

	private Object targetObj;//目标类的对象

	public Object createProxyInstance(Object targetObj) {
		this.targetObj = targetObj;
		Enhancer enhancer = new Enhancer();//代理对象
		enhancer.setSuperclass(this.targetObj.getClass());//设置代理对象的父类，继承了这个目标类，非final的方法都被覆盖
		enhancer.setCallback(this);
		return enhancer.create();
	}

	@Override
	public Object intercept(Object proxy, Method method, Object[] args,
			MethodProxy methodProxy) throws Throwable {
		//环绕通知
		InformationServiceBean bean = (InformationServiceBean) this.targetObj;
		Object result = null;
		if (bean.getUser() != null && !"".equals(bean.getUser())) {
			// 把方法的调用委派给目标对象
			beforeAdvice();
			try {
				result = method.invoke(this.targetObj, args);
				afterAdvice();
			} catch (Exception e) {
				exceptionAdvice();
			} finally {
				finallyAdvice();
			}
		}
		return result;
	}

	private void finallyAdvice() {
		System.err.println("我是finallyAdvice");

	}

	private void exceptionAdvice() {
		System.err.println("我是exceptionAdvice");

	}

	private void afterAdvice() {
		System.err.println("我是afterAdvice");

	}

	private void beforeAdvice() {
		System.err.println("我是beforeAdvice");

	}
}

class InformationServiceBean {

	private String user = null;

	public String getUser() {
		return user;
	}

	public void setUser(String user) {
		this.user = user;
	}

	public InformationServiceBean() {
	}

	public InformationServiceBean(String user) {
		this.user = user;
	}

	public String getUserName(Integer personId) {

		System.out.println("我是getUserName方法");
		return "xxx";
	}

	public String saveUser(String user) {
		System.out.println("我是saveUser方法");
		return "yyy";
	}

}

【测试动态代理】

package com.xcl.common;


import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

public class ProxyTest {

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
	}

	@AfterClass
	public static void tearDownAfterClass() throws Exception {
	}

	@Before
	public void setUp() throws Exception {
	}

	@After
	public void tearDown() throws Exception {
	}

	@Test public void proxyTest() {

		ProxyFactory factory = new ProxyFactory();	
		UserService service = (UserService) factory.createProxyInstance(new UserServiceBean("xy"));
		service.saveUser("abc");
	}

         @Test public void cglibProxyTest() {

		CglibProxyFactory factory = new CglibProxyFactory();	
		InformationServiceBean service = (InformationServiceBean) factory.createProxyInstance(new InformationServiceBean("abc"));
		service.saveUser("abc");

	}

}

动态代理的核心代码

package com.xcl.common;

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

public class DynamicProxyFactory implements InvocationHandler {

	private Object targetObj;

	public Object createProxyInstance(Object targetObj) {
		this.targetObj = targetObj;
		return Proxy.newProxyInstance(this.targetObj.getClass()
				.getClassLoader(), this.targetObj.getClass().getInterfaces(),
				this);
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		UserServiceBean bean = (UserServiceBean) this.targetObj;
		Object result = null;
		if (bean.getUser() != null && !"".equals(bean.getUser())) {
			// 把方法的调用委派给目标对象
			result = method.invoke(this.targetObj, args);
		}
		return result;
	}
}