顺德网站建设价位,微信朋友圈推广文案,响应式一页网站,网上企业推广代理模式及常见的3种代理类型对比 代理模式代理模式分类静态代理JDK动态代理CGLIBFastclass机制 三种代理方式之间对比常见问题 代理模式
代理模式是一种设计模式#xff0c;提供了对目标对象额外的访问方式#xff0c;即通过代理对象访问目标对象#xff0c;这样可以在不修… 代理模式及常见的3种代理类型对比 代理模式代理模式分类静态代理JDK动态代理CGLIBFastclass机制 三种代理方式之间对比常见问题 代理模式
代理模式是一种设计模式提供了对目标对象额外的访问方式即通过代理对象访问目标对象这样可以在不修改原目标对象的前提下提供额外的功能操作扩展目标对象的功能
一个比方在租房的时候有的人会通过房东直租有的人会通过中介租房。
这两种情况哪种比较方便呢当然是通过中介更加方便。
这里的中介就相当于代理用户通过中介完成租房的一系列操作看房、交押金、租房、清扫卫生代理模式可以有效的将具体的实现与调用方进行解耦通过面向接口进行编码完全将具体的实现隐藏在内部。 代理模式分类 静态代理 在编译时就已经实现编译完成后代理类是一个实际的class文件 动态代理 在运行时动态生成的即编译完成后没有实际的class文件而是在运行时动态生成类字节码并加载到JVM中 基于JDK的动态代理(反射) 基于CGLIB的动态代理(字节码技术)
静态代理
使用方式:
1.创建一个接口然后创建被代理的类实现该接口并且实现该接口中的抽象方法。
2.之后再创建一个代理类同时使其也实现这个接口。
3.在代理类中持有一个被代理对象的引用而后在代理类方法中调用该对象的方法。
public interface UserDao {void save();
}
public class UserDaoImpl implements UserDao {Overridepublic void save() {System.out.println(正在保存用户...);}
}
public class TransactionHandler implements UserDao {//目标代理对象private UserDao target;//构造代理对象时传入目标对象public TransactionHandler(UserDao target) {this.target target;}Overridepublic void save() {//调用目标方法前的处理System.out.println(开启事务控制...);//调用目标对象的方法target.save();//调用目标方法后的处理System.out.println(关闭事务控制...);}
}
public class Main {public static void main(String[] args) {//新建目标对象UserDaoImpl target new UserDaoImpl();//创建代理对象, 并使用接口对其进行引用UserDao userDao new TransactionHandler(target);//针对接口进行调用userDao.save();}
}使用JDK静态代理很容易就完成了对一个类的代理操作。但是JDK静态代理的缺点也暴露了出来由于代理只能为一个类服务如果需要代理的类很多那么就需要编写大量的代理类比较繁琐
JDK动态代理
使用JDK动态代理的五大步骤
1.通过实现InvocationHandler接口来自定义自己的InvocationHandler 2.通过Proxy.getProxyClass获得动态代理类 3.通过反射机制获得代理类的构造方法方法签名为getConstructor(InvocationHandler.class) 4.通过构造函数获得代理对象并将自定义的InvocationHandler实例对象传为参数传入 5.通过代理对象调用目标方法
public interface IHello {void sayHello();
}public class HelloImpl implements IHello {Overridepublic void sayHello() {System.out.println(Hello world!);}
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;public class MyInvocationHandler implements InvocationHandler {/** 目标对象 */private Object target;public MyInvocationHandler(Object target){this.target target;}Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println(------插入前置通知代码-------------);// 执行相应的目标方法Object rs method.invoke(target,args);System.out.println(------插入后置处理代码-------------);return rs;}
}
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Proxy;public class MyProxyTest {public static void main(String[] args)throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {// 第一种// 1、生成$Proxy0的class文件System.getProperties().put(sun.misc.ProxyGenerator.saveGeneratedFiles, true);// 2、获取动态代理类Class proxyClazz Proxy.getProxyClass(IHello.class.getClassLoader(),IHello.class);// 3、获得代理类的构造函数并传入参数类型InvocationHandler.classConstructor constructor proxyClazz.getConstructor(InvocationHandler.class);// 4、通过构造函数来创建动态代理对象将自定义的InvocationHandler实例传入IHello iHello1 (IHello) constructor.newInstance(new MyInvocationHandler(new HelloImpl()));// 5、通过代理对象调用目标方法iHello1.sayHello();// 第二种/*** Proxy类中还有个将2~4步骤封装好的简便方法来创建动态代理对象*其方法签名为newProxyInstance(ClassLoader loader,Class?[] instance, InvocationHandler h)*/IHello iHello2 (IHello) Proxy.newProxyInstance(IHello.class.getClassLoader(), // 加载接口的类加载器new Class[]{IHello.class}, // 一组接口new MyInvocationHandler(new HelloImpl())); // 自定义的InvocationHandleriHello2.sayHello();}
}JDK静态代理与JDK动态代理之间有些许相似比如说都要创建代理类以及代理类都要实现接口等。
不同之处 在静态代理中我们需要对哪个接口和哪个被代理类创建代理类所以我们在编译前就需要代理类实现与被代理类相同的接口并且直接在实现的方法中调用被代理类相应的方法但是动态代理则不同我们不知道要针对哪个接口、哪个被代理类创建代理类因为它是在运行时被创建的。
一句话来总结一下JDK静态代理和JDK动态代理的区别
JDK静态代理是通过直接编码创建的而JDK动态代理是利用反射机制在运行时创建代理类的。
其实在动态代理中核心是InvocationHandler。每一个代理的实例都会有一个关联的调用处理程序(InvocationHandler)。对待代理实例进行调用时将对方法的调用进行编码并指派到它的调用处理器(InvocationHandler)的invoke方法
对代理对象实例方法的调用都是通过InvocationHandler中的invoke方法来完成的而invoke方法会根据传入的代理对象、方法名称以及参数决定调用代理的哪个方法。
CGLIB
CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM来转换字节码并生成新的类
CGLIB代理实现如下
首先实现一个MethodInterceptor方法调用会被转发到该类的intercept()方法。然后在需要使用的时候通过CGLIB动态代理获取代理对象。
使用案例 public class HelloService {public HelloService() {System.out.println(HelloService构造);}/*** 该方法不能被子类覆盖,Cglib是无法代理final修饰的方法的*/final public String sayOthers(String name) {System.out.println(HelloService:sayOthersname);return null;}public void sayHello() {System.out.println(HelloService:sayHello);}
}
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;import java.lang.reflect.Method;/*** 自定义MethodInterceptor*/
public class MyMethodInterceptor implements MethodInterceptor{/*** subcglib生成的代理对象* method被代理对象方法* objects方法入参* methodProxy: 代理方法*/Overridepublic Object intercept(Object sub, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {System.out.println(插入前置通知);Object object methodProxy.invokeSuper(sub, objects);System.out.println(插入后者通知);return object;}
}
import net.sf.cglib.core.DebuggingClassWriter;
import net.sf.cglib.proxy.Enhancer;public class Client {public static void main(String[] args) {// 代理类class文件存入本地磁盘方便我们反编译查看源码System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, D:\\code);// 通过CGLIB动态代理获取代理对象的过程Enhancer enhancer new Enhancer();// 设置enhancer对象的父类enhancer.setSuperclass(HelloService.class);// 设置enhancer的回调对象enhancer.setCallback(new MyMethodInterceptor());// 创建代理对象HelloService proxy (HelloService)enhancer.create();// 通过代理对象调用目标方法proxy.sayHello();}
}JDK代理要求被代理的类必须实现接口有很强的局限性。
而CGLIB动态代理则没有此类强制性要求。简单的说CGLIB会让生成的代理类继承被代理类并在代理类中对代理方法进行强化处理(前置处理、后置处理等)。
总结一下CGLIB在进行代理的时候都进行了哪些工作
生成的代理类继承被代理类。在这里我们需要注意一点如果委托类被final修饰那么它不可被继承即不可被代理同样如果委托类中存在final修饰的方法那么该方法也不可被代理代理类会为委托方法生成两个方法一个是与委托方法签名相同的方法它在方法中会通过super调用委托方法另一个是代理类独有的方法当执行代理对象的方法时会首先判断一下是否存在实现了MethodInterceptor接口的CGLIB$CALLBACK_0;如果存在则将调用MethodInterceptor中的intercept方法
在intercept方法中我们除了会调用委托方法还会进行一些增强操作。在Spring AOP中典型的应用场景就是在某些敏感方法执行前后进行操作日志记录
在CGLIB中方法的调用并不是通过反射来完成的而是直接对方法进行调用通过FastClass机制对Class对象进行特别的处理比如将会用数组保存method的引用每次调用方法的时候都是通过一个index下标来保持对方法的引用
Fastclass机制
CGLIB采用了FastClass的机制来实现对被拦截方法的调用。
FastClass机制就是对一个类的方法建立索引通过索引来直接调用相应的方法
public class test10 {//这里tt可以看作目标对象fc可以看作是代理对象首先根据代理对象的getIndex方法获取目标方法的索引//然后再调用代理对象的invoke方法就可以直接调用目标类的方法避免了反射public static void main(String[] args){Test tt new Test();Test2 fc new Test2();int index fc.getIndex(f()V);fc.invoke(index, tt, null);}
}class Test{public void f(){System.out.println(f method);}public void g(){System.out.println(g method);}
}
class Test2{public Object invoke(int index, Object o, Object[] ol){Test t (Test) o;switch(index){case 1:t.f();return null;case 2:t.g();return null;}return null;}//这个方法对Test类中的方法建立索引public int getIndex(String signature){switch(signature.hashCode()){case 3078479:return 1;case 3108270:return 2;}return -1;}
}上例中Test2是Test的Fastclass在Test2中有两个方法getIndex和invoke。
在getIndex方法中对Test的每个方法建立索引并根据入参方法名方法的描述符来返回相应的索引。
Invoke根据指定的索引以ol为入参调用对象O的方法。这样就避免了反射调用提高了效率
三种代理方式之间对比
这里对三钟代理方式做一个简单对比:
代理方式实现优点缺点特点JDK静态代理代理类与委托类实现同一接口并且在代理类中需要硬编码接口实现简单容易理解代理类需要硬编码接口在实际应用中可能会导致重复编码浪费存储空间并且效率很低好像没啥特点JDK动态代理代理类与委托类实现同一接口主要是通过代理类实现InvocationHandler并重写invoke方法来进行动态代理的在invoke方法中将对方法进行增强处理不需要硬编码接口代码复用率高只能够代理实现了接口的委托类底层使用反射机制进行方法的调用CGLIB动态代理代理类将委托类作为自己的父类并为其中的非final委托方法创建两个方法一个是与委托方法签名相同的方法它在方法中会通过super调用委托方法另一个是代理类独有的方法。在代理方法中它会判断是否存在实现了MethodInterceptor接口的对象若存在则将调用intercept方法对委托方法进行代理可以在运行时对类或者是接口进行增强操作且委托类无需实现接口不能对final类以及final方法进行代理底层将方法全部存入一个数组中通过数组索引直接进行方法调用
常见问题
CGlib比JDK快
使用CGLiB实现动态代理CGLib底层采用ASM字节码生成框架使用字节码技术生成代理类 在jdk6之前比使用Java反射效率要高。唯一需要注意的是CGLib不能对声明为final的方法进行代理 因为CGLib原理是动态生成被代理类的子类。在jdk6、jdk7、jdk8逐步对JDK动态代理优化之后在调用次数较少的情况下JDK代理效率高于CGLIB代理效率。只有当进行大量调用的时候jdk6和jdk7比CGLIB代理效率低一点但是到jdk8的时候jdk代理效率高于CGLIB代理总之每一次jdk版本升级jdk代理效率都得到提升而CGLIB代理消息确有点跟不上步伐。
Spring如何选择用JDK还是CGLIB
当Bean实现接口时Spring就会用JDK的动态代理。当Bean没有实现接口时Spring使用CGlib实现。可以强制使用CGlib
