Java两种方式实现动态代理

一、jdk动态代理

java 在 java.lang.reflect 包中有自己的代理支持，该类（proxy.java）用于动态生成代理类，只需传入目标接口、目标接口的类加载器以及 invocationhandler 便可为目标接口生成代理类及代理对象。我们称这个java技术为：动态代理

@callersensitive
public static object newproxyinstance(classloader loader,
                   class<?>[] interfaces,
                   invocationhandler h)
  throws illegalargumentexception
{
//...
}

在 java 中规定，要想产生一个对象的代理对象，那么这个对象必须要有一个接口，因此 interfaces 必须是一个接口。

在动态代理技术里，由于不管用户调用代理对象的什么方法，都是调用开发人员编写的 invocationhandler 的 invoke 方法（这相当于 invoke 方法拦截到了代理对象的方法调用）。

因此 jdk 动态代理的整体流程为：

1. 实现 invocationhandler，用来处理对象拦截后的逻辑。（该对象必须是接口，或者父类是接口）
2. 使用 proxy.newproxyinstance 产生代理对象。

以下是一个用 jdk 动态代码实现 aop 的具体例子：

1.目标（target）类

public interface userservice {
  void eat();
}

public class userserviceimpl implements userservice {
  @override
  public void eat() {
    system.out.println("吃东西");
  }
}

2.切面（aspect）类

public class myaspect {
  /**
   * 前置通知
   */
  public void before() {
    system.out.print("先洗手再");
  }
}

3. 织入（weaving）过程

/**
 * 产生代理对象的工厂类
 */
public class myfactorybean {

  private myfactorybean() {
  }
  
  public static userservice getinstance() {
    // target ： 目标类
    final userservice userservice = new userserviceimpl();
    // aspect : 切面类
    final myaspect myaspect = new myaspect();
    // weaving : 织入，也就是产生代理的过程
    userservice proxyinstance = (userservice) proxy.newproxyinstance(userservice.class.getclassloader(),
        new class[]{userservice.class}, (object proxy, method method, object[] args) -> {
          // 模拟切点 - pointcut
          if ("eat".equals(method.getname())) {
            myaspect.before();
          }
          return method.invoke(userservice, args);
        });
    return proxyinstance;
  }
}

  public static void main(string[] args) {
    userservice userservice = myfactorybean.getinstance();
    // 先洗手再吃东西
    userservice.eat();
  }

想想看，这其实跟我们平常使用的 aop 已经很相似了，spring 里面定义了前置通知（@before）、异常通知（@afterthrowing）等等，spring 只是换成了甄别这些注解来选择什么时候调用通知方法，另外，spring 还通过切点表达式来选择目标类和切入点。

二、cglib动态代理

cglib 动态代理需要引入第三方的库，它通过修改代理对象生成子类的方式来实现调用拦截，代理对象不需要实现接口，但是代理类不能是 final，代理的方法也不能是 final。

/**
 * 产生代理对象的工厂类
 */
public class myfactorybean {

  private myfactorybean() {
  }

  public static userservice getinstance() {
    // target ： 目标类
    final userservice userservice = new userserviceimpl();
    // aspect : 切面类
    final myaspect myaspect = new myaspect();
    // weaving : 织入，也就是产生代理的过程
    enhancer enhancer = new enhancer();
    enhancer.setsuperclass(userservice.getclass());
    enhancer.setusecache(false);
    enhancer.setcallback(new methodinterceptor() {
      @override
      public object intercept(object o, method method, object[] objects, methodproxy methodproxy) throws throwable {
        // 模拟 pointcut-切点
        if ("eat".equals(method.getname())) {
          myaspect.before();
        }
        return methodproxy.invokesuper(o, objects);
      }
    });
    return (userservice) enhancer.create();
  }

  public static void main(string[] args) {
    userservice proxyinstance = myfactorybean.getinstance();
    // 先洗手再吃东西
    proxyinstance.eat();
  }
}

三、总结

在 jdk 中实现动态代理时，要求代理类必须是接口或继承接口的类，因为 jdk 最后生成的 proxy class 其实就是实现了代理类所代理的接口并且继承了 java 中的 proxy 类（继承 proxy 类是为了判断该类是否为代理类），通过反射找到接口的方法，调用 invocationhandler的invoke 方法实现拦截。

cglib 字节码增强是jdk动态代理的一个很好的补充， cglib 中最后生成的 proxy class 是一个继承代理类所代理的 class，通过重写被代理类中的非 final 的方法实现代理。

总结为：

• jdk 动态代理：代理类必须是接口或继承接口的类。
• cglib 字节码增强： 代理类不能是 final，代理的方法也不能是 final（继承限制） 。

关于在 spring 的 aop 中采用何种代理手段，我们不强加限制的话，会根据类是否有接口来区别对待：

1. 当一个类有接口的时候，就会选用 jdk 的动态代理。
2. 当一个类没有实现接口的时候，就会选用 cglib 代理的方式。

以上就是java两种方式实现动态代理的详细内容，更多关于java 动态代理的资料请关注其它相关文章！