动态代理两种方式
1.动态代理两种方式简述
JDK动态代理：利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。
CGLib动态代理：利用ASM（开源的Java字节码编辑库，操作字节码）开源包，将代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。
区别：JDK代理只能对实现接口的类生成代理；CGlib是针对类实现代理，对指定的类生成一个子类，并覆盖其中的方法，这种通过继承类的实现方式，不能代理final修饰的类。
2.动态代理的特点
1.字节码随用随创建，随用随加载。
2.它与静态代理的区别也在于此。因为静态代理是字节码一上来就创建好，并完成加载。
3.装饰者模式就是静态代理的一种体现。
3.动态代理常用的有两种方式
3.1 基于接口的动态代理
提供者：JDK 官方的 Proxy 类。
要求：被代理类最少实现一个接口。
3.2 基于子类的动态代理
提供者：第三方的 CGLib，如果报 asmxxxx 异常，需要导入 asm.jar。
要求：被代理类不能用 final 修饰的类（最终类）。
4.使用JDK官方的Porxy类创建对象
实体类：
package com.jh.spring13jdk动态代理; import lombok.Data; @Data public class Game implements Open{ //游戏的网速 private int ms = 460; @Override public int openApp() { System.out.println("打开游戏后的网速是：" + this.getMs()); return this.getMs(); } }
接口：
package com.jh.spring13jdk动态代理; public interface Open { int openApp(); }
测试类：
package com.jh.spring13jdk动态代理; import org.junit.Test; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class Spring13Test { //JDK动态代理 省略了代理对象！！！ 直接有jdk中的代理类来实现，但是目标类必须有接口 @Test public void test01() { final Game game = new Game(); /** * 代理： * 间接。 * 获取代理对象： * 要求： * 被代理类最少实现一个接口 * 创建的方式 * Proxy.newProxyInstance(三个参数) * 参数含义： * ClassLoader：和被代理对象使用相同的类加载器。 * Interfaces：和被代理对象具有相同的行为。实现相同的接口。 * InvocationHandler：如何代理。 * 策略模式：使用场景是： * 数据有了，目的明确。 * 如何达成目标，就是策略。 * */ //使用JDK动态类对象，当作迅游加速器的类，代替了静态的代理类 //Proxy:代理的意思。 newProxyInstancece创建代理对象 Open jdkProxy = (Open) Proxy.newProxyInstance( game.getClass().getClassLoader(), //类的加载器 game.getClass().getInterfaces(), //类的所有接口 new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Integer ms = (Integer) method.invoke(game, args); if (ms != null) { ms = ms - 400; } return ms; } } ); int i = jdkProxy.openApp(); System.out.println("i=" + i); } }
5.使用CGLib的Enhancer类创建代理对象
对于没有接口的类，如何实现动态代理呢，这就需要CGLib了，CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。但因为采用的是继承。所以不能对final修饰的类进行代理。
实体类：
package com.jh.spring14cjlib动态代理; import lombok.Data; /** * 目标类 * 父母 */ @Data public class Parents { //成绩 private int score = 599; //高考 public int gaoKao(){ System.out.println("父母参加高考,分数是："+this.getScore()); return this.getScore(); } }
工厂类：
package com.jh.spring14cjlib动态代理; import org.springframework.cglib.proxy.Enhancer; import org.springframework.cglib.proxy.MethodInterceptor; import org.springframework.cglib.proxy.MethodProxy; import java.lang.reflect.Method; //MethodInterceptor:方法上的拦截 public class ParentsFactory implements MethodInterceptor { private Parents parents; public ParentsFactory() { parents = new Parents(); } /** * 基于子类的动态代理 * 要求： * 被代理对象不能是最终类 * 用到的类： * Enhancer * 用到的方法： * create(Class, Callback) * 方法的参数： * Class：被代理对象的字节码 * Callback：如何代理 */ //增强器 ，把parents创造一个子类 public Parents createParentsSon() { //使用字节码增强器，去增强我们的父类 Enhancer enhancer = new Enhancer(); //字节码增强器，可以读懂class文件 //enhancer 指定一个对象 enhancer.setSuperclass(Parents.class);//反射 //使用工厂，换行（创建子类） enhancer.setCallback(this); //创建子类 Parents son = (Parents) enhancer.create(); //多态 return son; } /** * 执行被代理对象的任何方法，都会经过该方法。在此方法内部就可以对被代理对象的任何 方法进行增强。 * * 参数： * 前三个和基于接口的动态代理是一样的。 * MethodProxy：当前执行方法的代理对象。 * 返回值： * 当前执行方法的返回值 */ //方法的拦截 @Override public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { Integer score = (Integer) method.invoke(parents, objects); if (score != null) { score = score + 30; } return score; } }
测试类：
package com.jh.spring14cjlib动态代理; import org.junit.Test; public class Spring14Test { @Test public void test01(){ ParentsFactory parentsFactory = new ParentsFactory(); Parents parentsSon = parentsFactory.createParentsSon(); int score = parentsSon.getScore(); System.out.println(score); } }
6.总结：
CGLib创建的动态代理对象比JDK创建的动态代理对象的性能更高，但是CGLib创建对象时所花费的时间却比JDK多的的。
7.问题：
为什么，要在不改变源代码的基础上，去写一个代理类增强一些功能呢？
因为项目大了，就有主要的功能和次要的功能，要想主要功能和次要功能一起运行，必须用AOP
我再解释下面向对象和面向切面，面向对象OOP，面向的是主要功能的对象，而AOP是面向对象OOP的一个补充，面向次要功能的对象
目的是为了降低耦合度，提高代码的复用性。(自己总结的，仅供参考，你懂的，嘻嘻)。
