本文主要是介绍Java 代理模式详解静态代理，动态代理(JDK代理，CGLIB代理)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
简介
代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.
这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法。java 中AOP就是基于代理的设计模式。
代理模式的关键点是:代理对象与目标对象.代理对象是对目标对象的扩展,并会调用目标对象
有哪些代理模式
静态代理，动态代理(JDK动态代理,Cglib代理)
静态代理
所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。
静态代理是在编译时就将接口、实现类、代理类一股脑儿全部手动完成，但如果我们需要很多的代理，每一个都这么手动的去创建实属浪费时间，而且会有大量的重复代码。
静态代理的实现比较简单，代理类通过实现与目标对象相同的接口，并在类中维护一个代理对象。通过构造器塞入目标对象，赋值给代理对象，进而执行代理对象实现的接口方法，并实现前拦截，后拦截等所需的业务功能。
- 静态代理类：由程序员创建或者由第三方工具生成，再进行编译；在程序运行之前，代理类的.class文件已经存在了。
- 静态代理类通常只代理一个类。
- 静态代理事先知道要代理的是什么。
静态代理示例
/**
* 共同接口
*/
public interface ProgrammerInterface {void goToWork();void goOffWork();
}
/**
* 程序员类
*/
public class Programmer implements ProgrammerInterface{@Overridepublic void goToWork() {System.out.print("开始上班了\n");}@Overridepublic void goOffWork() {System.out.print("终于下班了\n");}
}
/**
* 程序员代理类
*/
public class ProgrammerProxy implements ProgrammerInterface {//目标类(程序员类)Programmer programmer;//构造方法,初始化目标类public ProgrammerProxy(Programmer programmer) {this.programmer = programmer;}@Overridepublic void goToWork() {System.out.print("进入了上班代理\n");programmer.goToWork();System.out.print("上班时间为:" + new Date() + "\n\n");}@Overridepublic 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 {@Overridepublic void goToWork() {System.out.print("工程师某某开始上班了\n");}@Overridepublic 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：代表调用目标方法时传入的实参*/@Overridepublic 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 {@Overridepublic void doHomework() {System.out.print("学生某某开始写作业了\n");}@Overridepublic 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修饰过的方法不可被重写。
也是看了很多文章，才整理出来，感谢那些写文章的大神。
这篇关于Java 代理模式详解静态代理，动态代理(JDK代理，CGLIB代理)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
