关于动态代理，大家显式使用的可能比較少，可是说到Spring的Interceptor、各种各样的事务管理，大家会更熟悉一些，没错，这些在底层实现上，都是使用的动态代理，确切的说，想要为一个类的方法，动态加入功能，比方验证、资源释放、日志处理等，大部分都是借助动态代理。
为了平缓的过渡，先来说一下静态代理。
静态代理
静态代理的思路非常easy：把一个真实对象的实例放到代理对象的实例中。然后调用代理对象方法，代理对象的方法调用真实对象的方法，以事务管理为例。例如以下：
UserDao
package com.tgb.staticproxy;
public interface UserDao {
public void add();
public void deleteAll();
}
UserDaoImpl
package com.tgb.staticproxy;
public class UserDaoImpl implements UserDao {
public void add()
{
System.out.println("加入一名用户到数据库");
}
public void deleteAll()
{
System.out.println("删除全部用户");
}
}
UserDaoProxy
package com.tgb.staticproxy;
public class UserDaoProxy implements UserDao {
UserDao userDao=null;
public UserDaoProxy(UserDao userDao)
{
this.userDao=userDao;
}
public void add()
{
System.out.println("开启本地事务");
userDao.add();
System.out.println("提交或回滚事务");
}
public void deleteAll()
{
System.out.println("开启本地事务");
userDao.deleteAll();
System.out.println("提交或回滚事务");
}
}
Test
package com.tgb.staticproxy;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
UserDao userDao=new UserDaoImpl();
UserDaoProxy userDaoProxy=new UserDaoProxy(userDao);
//測试加入
userDaoProxy.add();
System.out.println("..........分隔符..........");
//測试删除
userDaoProxy.deleteAll();
}
}
运行结果
开启本地事务 加入一名用户到数据库 提交或回滚事务 ..........分隔符.......... 开启本地事务 删除全部用户 提交或回滚事务
可是静态代理管理事务的方式问题非常大，每一个Dao类的每一个方法都须要开启和关闭事务，不仅代码反复严重，而事务本来是和业务没什么关联，却耦合到一起。
动态代理
JDK动态代理
相同以事务管理为例，例如以下：
UserDao
package com.tgb.dynamicproxy;
public interface UserDao {
public void add();
public void deleteAll();
}
UserDaoImpl
package com.tgb.dynamicproxy;
public class UserDaoImpl implements UserDao {
@Override
public void deleteAll() {
System.out.println("删除全部用户信息");
}
@Override
public void add() {
System.out.println("加入一名用户到数据库");
}
}
Handler
package com.tgb.dynamicproxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class Handler implements InvocationHandler {
private Object target;
public Handler(Object target)
{
this.target=target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
//开启事务
before();
//运行业务
method.invoke(target, args);
//提交或回滚事务
after();
return null;
}
public void before()
{
System.out.println("開始本地事务");
}
public void after()
{
System.out.println("提交或回滚事务");
}
}
Test
package com.tgb.dynamicproxy;
import java.lang.reflect.Proxy;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
try{
UserDao impl=new UserDaoImpl();
Handler handler=new Handler(impl);
UserDao proxy=(UserDao)Proxy.newProxyInstance
(impl.getClass().getClassLoader(), impl.getClass().getInterfaces(), handler);
//測试加入
proxy.add();
System.out.println("..........分隔符..........");
//測试删除
proxy.deleteAll();
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
运行结果
開始本地事务 加入一名用户到数据库 提交或回滚事务 ..........分隔符.......... 開始本地事务 删除全部用户信息 提交或回滚事务
JDK的动态代理克服了静态代理耦合和代码反复的问题，可是JDK的代理模式有个比較严重的问题。如UserDao必需要有接口才干够使用JDK动态代理，这就大大限制了JDK动态代理的范围。
cglib动态代理
asm能够动态生成字节码，cglib对asm进行了再封装，cglib并非为了动态代理而生的，可是利用它的特性。却能够非常好的实现动态代理。UserDaoImpl
package com.tgb.cglib;
public class UserDaoImpl {
public void deleteAll() {
System.out.println("删除全部用户信息");
}
public void add() {
System.out.println("加入一名用户到数据库");
}
}
CglibProxy
package com.tgb.cglib;
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class CglibProxy implements MethodInterceptor {
private Object target;
private CglibProxy(Object target){
this.target = target;
}
//产生代理对象
@SuppressWarnings("unchecked")
public static <T> T proxyTarget(T t){
Enhancer en = new Enhancer();
en.setSuperclass(t.getClass());
en.setCallback((Callback) new CglibProxy(t));
T tt = (T) en.create();
return tt;
}
//运行拦截
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable {
System.out.println("开启本地事务");
Object o = method.invoke(target, args);
System.out.println("提交或回滚事务");
return o;
}
}
Test
package com.tgb.cglib;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
//获代替理对象
UserDaoImpl impl=CglibProxy.proxyTarget(new UserDaoImpl());
//測试加入
impl.add();
System.out.println("..........分隔符..........");
//測试删除
impl.deleteAll();
}
}
执行结果
开启本地事务 加入一名用户到数据库 提交或回滚事务 ..........分隔符.......... 开启本地事务 删除全部用户信息 提交或回滚事务
能够看到，这次UserDaoImpl并没有实现不论什么接口接口实现动态代理的功能。
总结
这篇博客本来打算写JDK和cglib动态代理的源代码介绍的。写着写着就写成介绍代理都有哪些类型及实现方式了，再写篇幅就有点长了。所以放到下篇博客说明。