Java 代理模式详解静态代理，动态代理(JDK代理，CGLIB代理)

简介
代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.
这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法。java 中AOP就是基于代理的设计模式。

代理模式的关键点是:代理对象与目标对象.代理对象是对目标对象的扩展,并会调用目标对象

有哪些代理模式
静态代理，动态代理(JDK动态代理,Cglib代理)

静态代理
所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。
静态代理是在编译时就将接口、实现类、代理类一股脑儿全部手动完成，但如果我们需要很多的代理，每一个都这么手动的去创建实属浪费时间，而且会有大量的重复代码。
静态代理的实现比较简单，代理类通过实现与目标对象相同的接口，并在类中维护一个代理对象。通过构造器塞入目标对象，赋值给代理对象，进而执行代理对象实现的接口方法，并实现前拦截，后拦截等所需的业务功能。

• 静态代理类：由程序员创建或者由第三方工具生成，再进行编译；在程序运行之前，代理类的.class文件已经存在了。
• 静态代理类通常只代理一个类。
• 静态代理事先知道要代理的是什么。

静态代理示例

/**
* 共同接口
*/
public interface ProgrammerInterface {
    void goToWork();

    void goOffWork();
}

/**
* 程序员类
*/
public class Programmer implements ProgrammerInterface{
    @Override
    public void goToWork() {
        System.out.print("开始上班了\n");
    }

    @Override
    public void goOffWork() {
        System.out.print("终于下班了\n");
    }
}

/**
* 程序员代理类
*/
public class ProgrammerProxy implements ProgrammerInterface {
    //目标类(程序员类)
    Programmer programmer;

    //构造方法,初始化目标类
    public ProgrammerProxy(Programmer programmer) {
        this.programmer = programmer;
    }

    @Override
    public void goToWork() {
        System.out.print("进入了上班代理\n");
        programmer.goToWork();
        System.out.print("上班时间为:" + new Date() + "\n\n");
    }

    @Override
    public void goOffWork() {
        System.out.print("进入了下班代理\n");
        programmer.goOffWork();
        System.out.print("下班时间为:" + new Date() + "\n");
    }
}

/**
* main 入口
*/
public class ProxyDemoApplication {

    public static void main(String[] args) {
        Programmer programmer = new Programmer();
        ProgrammerProxy programmerProxy = new ProgrammerProxy(programmer);
        programmerProxy.goToWork();
        programmerProxy.goOffWork();
    }
}

运行结果:

总结：静态代理一般都是类对类，一个代理类对应一个目标类，很少能公用的，因为每个类中的方法是不一样的。所以提前就把代理类写好，这样如果需要代理的类很多，就需要创建很多的代理类。

动态代理
在程序运行时，运用反射机制动态创建而成。动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。

• 动态代理类：在程序运行时，通过反射机制动态生成。
• 动态代理类通常代理接口下的所有类。
• 动态代理事先不知道要代理的是什么，只有在运行的时候才能确定。
• 动态代理的调用处理程序必须事先InvocationHandler接口，及使用Proxy类中的newProxyInstance方法动态的创建代理类。
• Java动态代理只能代理接口，要代理类需要使用第三方的CLIGB等类库。

动态代理示例

JDK动态代理示例

/**
* 人员工作接口
*/
public interface WorkInterface {
    void goToWork();

    void goOffWork();
}

/**
* 工程师类
*/
public class Engineer implements WorkInterface {
    @Override
    public void goToWork() {
        System.out.print("工程师某某开始上班了\n");
    }

    @Override
    public void goOffWork() {
        System.out.print("工程师某某下班了\n");
    }
}

/**
* InvocationHandler
*/
public class WorkInvocationHandler implements InvocationHandler {
    private Object obj;

    public WorkInvocationHandler(Object obj) {
        this.obj = obj;
    }

    /**
     * proxy:代表动态代理对象
     * method：代表正在执行的方法
     * args：代表调用目标方法时传入的实参
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.print("进入了代理\n");
        Object result = method.invoke(obj, args);
        System.out.print("时间为:" + new Date() + "\n\n");
        return result;
    }
}

/**
* 动态代理Main方法
*
* @param args
*/
public static void main(String[] args) {
    //工程师类,Engineer是我们的代理对象
    WorkInterface engineer = new Engineer();
    //创建一个InvocationHandler,与代理对象关联
    InvocationHandler invocationHandler = new WorkInvocationHandler(engineer);
    Class<?> engineerClass = engineer.getClass();
    //新建一个代理类来代理engineer(这里就是动态生成代理类,通过实现相同接口,
    //达到在调用目标类之前先进入InvocationHandler,然后在通过method.invoke()方法调用原有的目标类中方法)
    /**
     * Proxy 代理类中 newProxyInstance方法参数说明
     * loader: 一个classloader对象，定义了由哪个classloader对象对生成的代理类进行加载
     * interfaces: 一个interface对象数组，表示我们将要给我们的代理对象提供一组什么样的接口，如果我们提供了这样一个接口对象数组，
     *             那么也就是声明了代理类实现了这些接口，代理类就可以调用接口中声明的所有方法。
     * h: 一个InvocationHandler对象，表示的是当动态代理对象调用方法的时候会关联到哪一个InvocationHandler对象上，并最终由其调用。
     */
    WorkInterface engineerProxy = (WorkInterface) Proxy.newProxyInstance(engineerClass.getClassLoader(), engineerClass.getInterfaces(), invocationHandler);
    //调用工程师类中的方法
    engineerProxy.goToWork();
    engineerProxy.goOffWork();

    //将我们生成的代理类engineerProxy中相关信息打印出来
    String methodList = "";
    for (Method m : engineerProxy.getClass().getDeclaredMethods()) {
        methodList += m.getName() + "  ";
    }
    System.out.print("engineerProxy中的方法: " + methodList + "\n");
    System.out.print("engineerProxy的父类: " + engineerProxy.getClass().getSuperclass() + "\n");
    String interfaces = "";
    for (Class<?> i : engineerProxy.getClass().getInterfaces()) {
        interfaces += i.getName() + "  ";
    }
    System.out.print("engineerProxy中实现的接口: " + interfaces + "\n");
}

运行结果:

这就是JDK动态代理，通过反射来生成代理类，实现接口，并调用目标类中的方法。他跟静态代理的区别就是，代理类如何生成，静态代理的代理类必须提前去写，一个目标类需要写个代理类。工作量大，且代码体积大。
动态代理就是不需要针对每个类写个代理类，代理类都是动态生成的，这样就少很多代码。例如，现在需要对学生类的方法也需要加上时间打印，我们就可以共用一个InvocationHandler，不需要再写一个了。

/**
* 人员学习接口
*/
public interface StudyInterface {
    void doHomework();

    void read();
}

/**
* 学生类
*/
public class Student implements StudyInterface {
    @Override
    public void doHomework() {
        System.out.print("学生某某开始写作业了\n");
    }

    @Override
    public void read() {
        System.out.print("学生某某读书了\n");
    }
}

main方法中只要在加上下面这段代码，就可以了，可以看到 用的同一个WorkInvocationHandler，没有重新去写个InvocationHandler。因为构造函数里面参数是Object的，可以实现任何对象的代理。

StudyInterface student = new Student();
InvocationHandler studentInvocationHandler = new WorkInvocationHandler(student);
StudyInterface studentProxy = (StudyInterface) Proxy.newProxyInstance(student.getClass().getClassLoader(), student.getClass().getInterfaces(), studentInvocationHandler);
studentProxy.doHomework();
studentProxy.read();

String stuProxyMethodList = "";
for (Method m : studentProxy.getClass().getDeclaredMethods()) {
    stuProxyMethodList += m.getName() + "  ";
}
System.out.print("studentProxy中的方法: " + stuProxyMethodList + "\n");
System.out.print("studentProxy的父类: " + studentProxy.getClass().getSuperclass() + "\n");
String stuProxyInterfaces = "";
for (Class<?> i : studentProxy.getClass().getInterfaces()) {
    stuProxyInterfaces += i.getName() + "  ";
}
System.out.print("studentProxy中实现的接口: " + stuProxyInterfaces + "\n\n");

运行结果：

可以看到，JDK动态代理只能用在目标类中实现了接口的，如果没有实现接口会怎么样那？
我们把代码稍微改造下，直接使用Student，不用接口了，看看运行结果。

Student student = new Student();
InvocationHandler studentInvocationHandler = new WorkInvocationHandler(student);
Student studentProxy = (Student) Proxy.newProxyInstance(student.getClass().getClassLoader(), student.getClass().getInterfaces(), studentInvocationHandler);
studentProxy.doHomework();
studentProxy.read();

运行结果:

$Proxy1 为代码动态生成的代理类，为什么？可以看我们的运行结果中

engineerProxy中的方法: equals  toString  hashCode  goOffWork  goToWork  
engineerProxy的父类: class java.lang.reflect.Proxy
engineerProxy中实现的接口: dynamicproxy.EngineerWorkInterface 

studentProxy中的方法: equals  toString  hashCode  read  doHomework  
studentProxy的父类: class java.lang.reflect.Proxy
studentProxy中实现的接口: dynamicproxy.StudyInterface  

总结：engineerProxy的父类为Proxy，也就是说我们的代理类其实已经继承了一个类了，java不能多继承，现在通过反射我们需要知道目标类中有哪些方法。如果不能再去继承类，就只能通过代理接口去实现代理。所以JDK动态代理只支持代理实现了接口的类，代理的是接口。具体为什么要继承Proxy，然后如何生成代理类的，代理类源码是什么样的会在其他文章写。既然JDK动态代理只能代理接口，不能代理类，那我们如果遇到目标类中没有实现接口怎么办那？就是使用CGLIB代理，下面我们看看CGLIB代理是如何实现动态代理的。

CGLIB动态代理示例
引包

<dependency>
  <groupId>cglib</groupId>
  <artifactId>cglib</artifactId>
  <version>3.2.12</version>
</dependency>

/**
* 教师类
*/
public class Teacher {
    public void attendClass() {
        System.out.print("老师某某上课了\n");
    }
}

/**
* 代理类拦截
*/
public class TeacherProxyCglib implements MethodInterceptor {
    /**
     * 实现接口,拦截方法执行增强方法，然后在回调
     *
     * @param obj
     * @param method
     * @param args
     * @param proxy
     * @return
     * @throws Throwable
     */
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.print("进入了代理\n");
        proxy.invokeSuper(obj, args);   //回调父类方法,也就是目标类的方法
        System.out.print("时间为:" + new Date() + "\n\n");
        return null;
    }
}

/**
* 动态代理Main方法
*
* @param args
*/
public static void main(String[] args) {
    Enhancer enhancer = new Enhancer(); //创建加强器
    enhancer.setSuperclass(Teacher.class);  //设置父类
    enhancer.setCallback(new TeacherProxyCglib());  //设置回调
    Teacher teacher = (Teacher) enhancer.create();  //创建代理类
    teacher.attendClass();  //执行教师上课方法

    //将我们生成的代理类teacher中相关信息打印出来
    String methodList = "";
    for (Method m : teacher.getClass().getDeclaredMethods()) {
        methodList += m.getName() + "  ";
    }
    System.out.print("teacher中的方法: " + methodList + "\n");
    System.out.print("teacher的父类: " + teacher.getClass().getSuperclass() + "\n");
    String interfaces = "";
    for (Class<?> i : teacher.getClass().getInterfaces()) {
        interfaces += i.getName() + "  ";
    }
    System.out.print("teacher中实现的接口: " + interfaces + "\n\n");
}

运行结果：

总结：可以看到实现了代理增强，且我们的目标类并没有实现接口，CGLIB是通过继承目标类，生成子类，重写父类方法进行的代理。所以不能代理final修饰的方法，因为final修饰过的方法不可被重写。

也是看了很多文章，才整理出来，感谢那些写文章的大神。