代理模式，顾名思义，就是通过代理去完成某些功能。比如，你需要购买火车票，不想跑那么远到火车站售票窗口买，可以去附近的火车票代售点买，或者到携程等第三方网站买。这个时候，我们就把火车站叫做目标对象或者委托对象，也可以叫被代理对象，而火车票代售点和携程就叫做代理对象。

一、静态代理

静态代理是最简单的代理模式。需要定义一个接口，然后委托类和代理类分别实现这个接口

//待实现的接口
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动态代理，感兴趣的小伙伴可以继续深入研究哦。