java动态代理的实现

本文探讨两种java动态代理技术，JDK和cglib

代理有什么用？

Spring的面向切面编程（Aspect）就是利用代理技术实现，获取注入对象的时候获取的其实并不是注入类的对象（target），而是其代理类的对象（proxyTarget）只是通过动态代理实现，对于编码者而言是透明的，在代理方法中可以对目标方法做事务控制、日志记录、异常捕获、错误处理等等工作。

代理方式有哪两种？

JDK动态代理和cglib

在Spring中如何使用他们，有什么区别？

Spring默认使用JDK的动态代理，如果在spring配置文件中添加<aop:aspectj-autoproxy proxy-target-class="true" />，则使用cglib，false还是使用JDK

使用JDK的代理只能对有接口的类做代理，且不能代理接口之外的方法（实现类中扩展的），cglib可以对无接口的类做代理，不受接口的限制

以下对两种代理方式进行剖析，通过模拟Spring的注入依赖(IOC)和面向切面（AOP）

<?xml version="1.0" encoding="UTF-8"?>
<beans>
<aspectj-autoproxy proxy-target-class="false" />

<bean id="target1" class="com.java.advice151.TargetClass"></bean>

<bean id="target2" class="com.java.advice151.TargetImpl"></bean>
</beans

首先看XML配置文件的内容，配置文件模拟Spring配置文件，第一个标签用来设置代理类型，后两个是注入的bean，然后看代码：

public class Advice106 {
static Map<String, String> beans = new HashMap<String, String>();
private static boolean proxy_target_class = false;
public static void main(String[] args) throws Exception,
Exception {
parseXml2Beans(beans, "beans.xml");

TargetInterface pi = getBean("target2");

pi.save();
}

/**
* 解析XML文件，以获取文件中注入的类
*
* @param beans
* @param string
*/
private static void parseXml2Beans(Map<String, String> beans, String string) {
SAXReader reader = new SAXReader();
try {
InputStream xmlPath = Advice106.class.getClassLoader()
.getResourceAsStream("beans.xml");
Document document = reader.read(xmlPath);
Element root = document.getRootElement();
List<Element> elements = root.elements();

for (Element element : elements) {
if ("bean".equals(element.getName())) {
beans.put(element.attributeValue("id"),
element.attributeValue("class"));
} else if ("aspectj-autoproxy".equals(element.getName())) {
proxy_target_class = Boolean.parseBoolean(element.attributeValue("proxy-target-class"));
}
}
} catch (DocumentException e) {
e.printStackTrace();
}
}

/**
* 根据解析出来的参数判断代理方式
*
* @param id
* @return
* @throws Exception
*/
@SuppressWarnings("unchecked")
private static <T> T getBean(String id)
throws Exception {
String className = beans.get(id);

T target = (T) Class.forName(className).newInstance();
if (proxy_target_class) {
return cglibProxy(target);
} else {
return jdkProxy(target);
}
}

/**
* JDK动态代理 直接创建代理对象
*
* @param target
* @return
*/
private static <T> T jdkProxy(T target) {
InvocationHandler handler = new JDKHandler<T>(target);
return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target
.getClass().getInterfaces(), handler);
}

/**
* JDK动态代理 先创建代理类，然后创建代理对象
*
* @param target
* @return
*/
private static <T> T jdkProxy2(T target) {
InvocationHandler handler = new JDKHandler<T>(target);
Class<T> proxyClass = (Class<T>) Proxy.getProxyClass(target.getClass()
.getClassLoader(), target.getClass().getInterfaces());
T proxyObject = null;
try {
Constructor<T> con = proxyClass
.getConstructor(new Class[] { InvocationHandler.class });
proxyObject = con.newInstance(new Object[] { handler });
} catch (Exception e) {
e.printStackTrace();
}
return proxyObject;
}

/**
* 使用cglib方式代理
*
* @param target
* @return
*/
@SuppressWarnings("unchecked")
public static <T> T cglibProxy(T target){

Enhancer enhancer = new Enhancer();

enhancer.setSuperclass(target.getClass());

enhancer.setCallback(new CglibHandler<T>(target));

return (T) enhancer.create();
}
}

/**
* 目标接口
*
* @author 201507160235
*
*/
interface TargetInterface {
public void save();

public void add();

public void query();
}

/**
* 目标接口实现类
*
* @author 201507160235
*
*/
class TargetImpl implements TargetInterface {

@Override
public void save() {
System.out.println("real business save method");

}

@Override
public void add() {
System.out.println("real business add method");

}

@Override
public void query() {
System.out.println("real business add method");

}
}

/**
* 目标类
*
* @author 201507160235
*
*/
class TargetClass {
public void save() {
System.out.println("no interface save method");

}

public void add() {
System.out.println("no interface add method");

}

public void query() {
System.out.println("no interface add method");

}

}

代码都加着注释，运行结果：
代理句柄中预处理！
real business save method
代理句柄中最终处理


可以看到在配置文件proxy-target-class设置为false的时候可以使用JDK动态代理，当然了，如果改为true就会使用cglib代理。
cglib代理，事务开始！
real business save method
cglib代理，事务结束！
但是如果proxy-target-class=false的时候，强制获取TargetClass的代理对象，则会报错：

Exception in thread "main" java.lang.ClassCastException: com.sun.proxy.$Proxy0 cannot be cast to com.java.advice151.TargetClass
at com.java.advice151.Advice106.main(Advice106.java:25)

当然了，这个错误是可控的，在类型检查的过程中直接把无接口的类过滤掉，不使用代理直接返回对象不就可以了，把getBean方法修改为：
private static <T> T getBean(String id)
throws Exception {
String className = beans.get(id);

T target = (T) Class.forName(className).newInstance();
if (proxy_target_class) {
return cglibProxy(target);
} else {
<span style="color:#ff6666;">if (target.getClass().getInterfaces().length <= 0) {
return target;
}</span>

return jdkProxy(target);
}
}

红体字是添加的内容，若是不符合代理条件，直接返回，也就是本业务受理，自己玩去！运行后结果：
no interface save method

这里还有两个类的代码没贴出来，其实就是回调函数而已，你的业务所在的方法，请看，JDK代理的句柄类：
public class JDKHandler<T> implements InvocationHandler {
T obj;

public JDKHandler(T obj) {
this.obj = obj;
}
@Override
public T invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("代理句柄中预处理！");
T result = (T) method.invoke(obj, args);
System.out.println("代理句柄中最终处理");
return result;
}

}

必须继承Invocationhandler 实现其invoke方法，在其中书写业务员代码。
cglib的处理拦截器：

public class CglibHandler<T> implements MethodInterceptor {
T target;

public CglibHandler(T target) {
this.target = target;
}

@Override
public T intercept(Object obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable {
System.out.println("cglib代理，事务开始！");
T proxyObj = (T) proxy.invoke(target, args);
System.out.println("cglib代理，事务结束！");
return proxyObj;
}
}

多了一个参数而已，其他的结构上基本没区别。
他们之间最大的区别在哪儿呢？是代理的实现部分，JDK传入的是结构数组，而cglib传入的是superClass，回调函数类都是需要传入的，毕竟是你的业务所在。

另外再说下，jdkProxy2和jdkProxy是等价的，这个可以参考官方文档，只是比较麻烦一点而已，最常用的方式是jdkProxy