首页 > 代码库 > java动态代理【一】

java动态代理【一】

2024-09-21 01:06:26   215人阅读

java动态代理的定义：为其他目标类的方法增加切面的逻辑，即在执行目标类方法的时候，先去执行一段如校验检测的逻辑代码。java通俗一点就是生成一个继承目标类的子类，并在每个调用方法都添加一段逻辑。

应用场景：当我们从别的项目迁移过来的代码进行修改的时候，如果有一个需求是当要执行某个业务类的所有方法前，需要校验其权限或其他的时候，如果这个类是源代码，我们还可以在类的基础上对每个方法区更改，但若是打包成jar包的类，若该类有接口还可以实现一个代理模式创建一个代理类，没有接口就比较麻烦，但接口一旦多起来，那编写的话也比较麻烦。这时我们就需要用到动态代理，由jdk动态创建一个proxy类，我们通过proxy类来调用目标类的方法。

动态代理的实现有三种方法：
1、使用代理模式。
    1）创建一个Star（明星）类，其实现了Speak，Eat接口
    
  1. package cglib;
  3. public class Star implements Speak,Eat{
  5.     @Override
  6.     public void say() {
  7.         // TODO Auto-generated method stub
  8.         System.out.println("i am a star");
  9.     }
  11.     @Override
  12.     public void eat() {
  13.         // TODO Auto-generated method stub
  14.         System.out.println("star eats some fruit");
  15.     }
  16.     
  17. }
    2）创建一个Broker（经纪人）类，其实现了Speak接口，如下代码：
        
  1. package cglib;
  4. //装饰器模式
  5. public class Broker implements Speak{
  6.     private Speak speak;
  7.     public Broker(Speak speak){
  8.         this.speak=speak;
  9.     }
  10.     @Override
  11.     public void say() {
  12.         // TODO Auto-generated method stub
  13.         speak.say();
  14.     }
  16. }

    3）测试代码：
    技术分享
 
       输出I am Star！ 一个经纪人可以代理不同的明星表述，这在现实中是符合的。
2、使用JDK动态代理（原理是通过映射，动态生成java字节码Proxy类）
    1）同样以Star类为目标类，实现JDK动态代理需要实现InvocationHandler接口，如下：
        
  1. package cglib;
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Method;
  5. import java.lang.reflect.Proxy;
  7. public class JDKDynamicProxy implements InvocationHandler{
  8.     private Object speak;
  9.     private JDKDynamicProxy(Object speak){
  10.         //传入star对象
  11.         this.speak=speak;
  12.     }
  13.     
  14.     
  15.     //创建一个静态方法，生成代理类，
  16.     public static Object newProxyInstance(Object speak){
  17.         System.out.println(JDKDynamicProxy.class.getClassLoader().toString());
  18.         return Proxy.newProxyInstance(JDKDynamicProxy.class.getClassLoader(),new Class[]{Speak.class,Eat.class}, new JDKDynamicProxy(speak));
  19.     }
  20.     
  21.     
  22.     //覆盖InvocationHandler的invoke方法，从参数可以看出，这个方法明显使用了jdk的方法映射来调用Star的方法，在调用Star的方法前后，我们都可以增加自己的逻辑代码
  23.     @Override
  24.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  25.         // TODO Auto-generated method stub
  26.         System.out.println("call the JDKDynamicProxy");
  27.         
  28.         return method.invoke(speak, args);
  29.     }
  30.     
  31. }

        2)测试类
    
  1. package cglib;
  3. import java.lang.reflect.Constructor;
  5. public class ProxyTest {
  6.     public static void main(String[] args) {
  7.         //装饰者模式
  8.         Star star=new Star();
  9.         Speak b=new Broker(star);
  10.         b.say();
  11.       //jdk动态代理模式
  12.         Speak s=(Speak) JDKDynamicProxy.newProxyInstance(star);
  13.         s.say();
  14.         Eat e=(Eat) JDKDynamicProxy.newProxyInstance(star);
  15.         e.eat();
  16.         //CGlib动态代理
  17.         Speak sp=CGProxy.newCGproxyInstance(Star.class);
  18.         sp.say();
  19.     }
  20. }
技术分享
 可以看出在调用Star的say（）方法之前，调用了JDKDynamicProxy 的invoke方法。
   3、使用CGLib动态代理（原理使用了asm）
        1）CGProxy类，因为是方法拦截，故实现的是MethodInterceptor 接口，下面是一个简单的实现方法。
                
 
  1. package cglib;
  3. import java.lang.reflect.Method;
  5. import net.sf.cglib.proxy.Enhancer;
  6. import net.sf.cglib.proxy.MethodInterceptor;
  7. import net.sf.cglib.proxy.MethodProxy;
  9. public class CGProxy implements MethodInterceptor {
  10.     
  11.     public static <T extends Speak> Speak newCGproxyInstance(Class<T> superClass){
  12.         Enhancer en=new Enhancer();
  13.         en.setSuperclass(superClass);
  14.         en.setCallback(new CGProxy());
  15.         return (Speak)en.create();
  16.     }
  17.     
  18.     
  19.     @Override
  20.     public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {
  21.         // TODO Auto-generated method stub
  22.         System.out.println("call the CGProxy");
  23.         return arg3.invokeSuper(arg0, arg2);
  24.     }
  26. }
    看代码和JDK动态代理的写法差不多，但其内部实现的原理却不同。明显的区别从代码可以看出，JDK动态代理要传入目标类的接口作为参数，所以目标类必须要有一个统一的接口，即如上的Speak，Eat接口，这就使得JDK动态代理有一定的局限性。而CGlib从代码看出，传入的是Class，不是接口，使用范围更广一些。


下一章探讨一下JDK动态代理内部的实现原理。




null


java动态代理【一】


联系
我们