代理模式之静态代理，JDK动态代理和cglib动态代理

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

1、静态代理

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

//待实现的接口
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。所以，才叫静态代理。这样虽然定义比较方便，实现也简单，可是有一个弊端。当接口再新加一个方法时，委托类和代理类都须要同步地去实现方法，所以维护起来比较麻烦。而动态代理解决了这个问题。

2、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是经过继承方式）

3、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动态代理，感兴趣的小伙伴能够继续深刻研究哦。