代理模式，顾名思义，就是通过代理去完成某些功能。比如，你需要购买火车票，不想跑那么远到火车站售票窗口买，可以去附近的火车票代售点买，或者到携程等第三方网站买。这个时候，我们就把火车站叫做目标对象或者委托对象，也可以叫被代理对象，而火车票代售点和携程就叫做代理对象。
一、静态代理
静态代理是最简单的代理模式。需要定义一个接口，然后委托类和代理类分别实现这个接口
//待实现的接口
public interface UserManager {
public void getName(String name);
public void getId(int id);
}
//委托类
public class UserManagerImpl implements UserManager {
@Override
public void getName(String name) {
System.out.println("UserManagerImpl.getName:" + name);
}
@Override
public void getId(int id) {
System.out.println("UserManagerImpl.getId:" + id);
}
}
//代理类
public class UserManagerProxy implements UserManager {
UserManager userManager;
public UserManagerProxy(UserManager userManager) {
this.userManager = userManager;
}
@Override
public void getName(String name) {
System.out.println("before getName");
userManager.getName(name);
System.out.println("after getName");
}
@Override
public void getId(int id) {
userManager.getId(id);
}
public static void main(String[] args) {
UserManagerProxy proxy = new UserManagerProxy(new UserManagerImpl());
proxy.getName("zhangsan");
}
}
//before getName
//UserManagerImpl.getName:zhangsan
//after getName
可以看到，在编译成class之前，就已经确定了委托类UserManagerImpl和代理类UserManagerProxy。因此，才叫静态代理。这样虽然定义比较方便，实现也简单，但是有一个弊端。当接口再新加一个方法时，委托类和代理类都需要同步地去实现方法，因此维护起来比较麻烦。而动态代理解决了这个问题。
二、JDK动态代理
动态代理分为JDK动态代理和cglib动态代理。动态是指，代理类是通过反射等机制动态生成的，委托类和代理类的关系在运行时才确定。他们的主要区别就是，JDK动态代理需要实现接口，而cglib是通过继承来实现的，不需要定义接口。
JDK动态代理，需要定义一个类去实现InvocationHandler接口
public class LogHandler implements InvocationHandler {
private Object targetObj;
public Object newProxyObject(Object targetObj){
this.targetObj = targetObj;
return Proxy.newProxyInstance(
targetObj.getClass().getClassLoader(), //获取委托类的类加载器
targetObj.getClass().getInterfaces(), //获取委托类实现的所有接口
this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object ret;
try {
System.out.println("before method");
ret = method.invoke(targetObj, args);
System.out.println("after method");
} catch (IllegalAccessException e) {
e.printStackTrace();
System.out.println("error");
throw e;
}
return ret;
}
}
public class TestProxy {
public static void main(String[] args) {
LogHandler logHandler = new LogHandler();
UserManager o = (UserManager)logHandler.newProxyObject(new UserManagerImpl());
o.getName("ls");
o.getId(2);
}
}
/**
运行结果如下：
before method
UserManagerImpl.getName:ls
after method
before method
UserManagerImpl.getId:2
after method
*/
JDK动态代理其实是在运行时动态生成了一个代理类去实现接口，只是隐藏了这个过程，我们不知道而已。
class $JDKProxy implements UserManager{}
需要注意的是，实现JDK动态代理的一个前提就是，需要定义一个接口，然后委托类去实现这个接口。那如果我不想定义接口，只定义一个委托类能不能实现呢？这就需要用到cglib代理了。（因为cglib是通过继承方式）
三、cglib动态代理
需要定义一个类实现MethodInterceptor接口（注意，这个类可不是代理类，也不是委托类哦）。
//委托类，不需要实现接口
public class CgTarget {
public void getContent(){
System.out.println("cglib被代理类getContent方法");
}
}
public class CglibProxy implements MethodInterceptor {
private Object target;
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("cglib开始");
Object invoke = method.invoke(target, objects);
System.out.println("cglib结束");
return invoke;
}
//代理方法
public Object getCglibProxy(Object target){
this.target = target;
Enhancer enhancer = new Enhancer();
//设置增强类的父类,即被代理类
enhancer.setSuperclass(target.getClass());
//设置回调函数
enhancer.setCallback(this);
//返回创建的代理类
return enhancer.create();
}
}
public class TestCglib {
public static void main(String[] args) {
CglibProxy cglibProxy = new CglibProxy();
CgTarget o = (CgTarget)cglibProxy.getCglibProxy(new CgTarget());
o.getContent();
}
}
/**
打印结果如下：
cglib开始
cglib被代理类getContent方法
cglib结束
*/
可以看到，cglib动态代理是通过Enhancer类的create方法创建了代理类。其实，其内部是通过继承委托类来动态生成代理类的。它隐藏了以下过程
class $cglibProxy extends CgTarget{}
因此，委托类不能定义成final类型的，因为final修饰的类是不能被继承的。
了解spring AOP的同学应该知道，AOP是面向切面编程，在管理事物的时候会用到。其实，AOP就是通过动态代理来实现的，具体是用的JDK动态代理还是cglib动态代理，感兴趣的小伙伴可以继续深入研究哦。