Java中的静态代理和动态代理

Subject类，定义了RealSubject和Proxy的共用接口，这样就在任何使用RealSubject的地方都可以使用Proxy。

public interface Subject {

/**

* doSomething()

void doSomething();

}

RealSubject类，定义Proxy所代表的真实实体。

public class RealSubject implements Subject {

@Override

public void doSomething() {

// 委托类执行操作

System.out.println("RealSubject.doSomething()");

}

ProxySubject类，保存一个引用使得代理可以访问实体，并提供一个与Subject的接口相同的接口，这样代理就可以用来替代实体。

public class ProxySubject implements Subject {

private RealSubject realSubject;

/**

* 向代理类中注入委托类对象

* @param realSubject 委托类对象

public ProxySubject(RealSubject realSubject){

this.realSubject = realSubject;

}

/**

* 代理类执行操作

@Override

public void doSomething() {

System.out.println("代理类调用委托类方法之前");

realSubject.doSomething();

System.out.println("代理类调用委托类方法之后");

}

测试第一种方式，不使用代理类，直接使用简单委托类执行。

public static void main(String[] args) {

RealSubject realSubject = new RealSubject();

realSubject.doSomething();

}

输出：

RealSubject.doSomething()

测试第二种方式，使用代理类，执行增强逻辑。

public static void main(String[] args) {

RealSubject realSubject = new RealSubject();

ProxySubject proxySubject = new ProxySubject(realSubject);

proxySubject.doSomething();

}

输出：

代理类调用委托类方法之前

RealSubject.doSomething()

代理类调用委托类方法之后

我们在创建代理对象时，通过构造器塞入一个目标对象，然后在代理对象的方法内部调用目标对象同名方法，并在调用前后做增强逻辑。也就是说，代理对象 = 增强代码 + 目标对象。有了代理对象后，就不用原对象了。

静态代理的缺陷

开发者需要手动为目标类编写对应的代理类，而且要对类中的每个方法都编写增强逻辑的代码，如果当前系统中已经存在成百上千个类，工作量太大了，且重复代码过多。所以，有没有什么方法能让我们少写或者不写代理类，却能完成代理功能？

3. 动态代理

静态代理是代理类在代码运行前已经创建好，并生成class文件；动态代理类是代理类在程序运行时创建的代理模式。动态代理类的代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的。相比于静态代理，动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。

3.1 JDK动态代理

基于接口实现。Java的java.lang.reflect包下提供了Proxy类和一个 InvocationHandler 接口，这个类Proxy定义了生成JDK动态代理类的方法getProxyClass(ClassLoader loader,Class<?>... interfaces)生成动态代理类,返回class实例代表一个class文件。可以保存该 class 文件查看jdk生成的代理类文件长什么样。该生成的动态代理类继承Proxy类，(重要特性) ，并实现公共接口。InvocationHandler这个接口，是被动态代理类回调的接口，我们所有需要增加的针对委托类的统一增强逻辑都增加到invoke()方法里面，在调用委托类接口方法之前或之后。

例子。任然使用上面静态代理里的类，只不过这次我们不会再用到代理类ProxySubject，而是让JDK去帮我们生成代理类。方法如下：

public static void main(String[] args) {

// 实例化目标对象

Subject subject = new RealSubject();

// 获取代理对象

Subject proxyInstance = (Subject) Proxy.newProxyInstance(subject.getClass().getClassLoader(), subject.getClass().getInterfaces(),

new InvocationHandler() {

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

// 增强逻辑

System.out.println("动态代理调用委托类方法之前");

Object invoke = method.invoke(subject, args);

System.out.println("动态代理调用委托类方法之后");

return invoke;

}

});

// 执行目标方法

proxyInstance.doSomething();

}

输出：

动态代理调用委托类方法之前

RealSubject.doSomething()

动态代理调用委托类方法之后

Jdk为我们的生成了一个叫$Proxy0（这个名字后面的0是编号，有多个代理类会一次递增）的代理类，这个类文件时默认不会保存在文件，放在内存中的，我们在创建代理对象时，就是通过反射获得这个类的构造方法，然后创建代理对象实例。通过对这个生成的代理类源码的查看，我们很容易能看出，动态代理实现的具体过程。

我们可以对 InvocationHandler看做一个中介类，中介类持有一个被代理对象，被Proxy类回调。在invoke方法中调用了被代理对象的相应方法。通过聚合方式持有被代理对象的引用，把客户端对invoke的调用最终都转为对被代理对象的调用。

客户端代码通过代理类引用调用接口方法时，通过代理类关联的中介类对象引用来调用中介类对象的invoke方法，从而达到代理执行被代理对象的方法。也就是说，动态代理Proxy类提供了模板实现，对外提供扩展点，外部通过实现InvocationHandler接口将被代理类纳入JDK代理类Proxy。

JDK动态代理特点总结

生成的代理类：$Proxy0 extends Proxy implements Subject，我们看到代理类继承了Proxy类，Java的继承机制决定了JDK动态代理类们无法实现对类的动态代理。所以也就决定了JDK动态代理只能对接口进行代理。

每个生成的动态代理实例都会关联一个调用处理器对象，可以通过 Proxy 提供的静态方法 getInvocationHandler去获得代理类实例的调用处理器对象。在代理类实例上调用其代理的接口中所声明的方法时，这些方法最终都会由调用处理器的 invoke 方法执行。

代理类的根类 java.lang.Object 中有三个方法也同样会被分派到调用处理器的 invoke 方法执行，它们是 hashCode，equals 和 toString，可能的原因有：一是因为这些方法为 public 且非 final 类型，能够被代理类覆盖；二是因为这些方法往往呈现出一个类的某种特征属性，具有一定的区分度，所以为了保证代理类与委托类对外的一致性，这三个方法也应该被调用处理器分派到委托类执行。

JDK动态代理的不足

JDK动态代理的代理类字节码在创建时，需要实现业务实现类所实现的接口作为参数。如果业务实现类是没有实现接口而是直接定义业务方法的话，就无法使用JDK动态代理了。(JDK动态代理重要特点是代理接口)并且，如果业务实现类中新增了接口中没有的方法，这些方法是无法被代理的（因为无法被调用）。动态代理只能对接口产生代理，不能对类产生代理。

3.2 CGLib动态代理

基于继承。CGlib是针对类来实现代理的，他的原理是对代理的目标类生成一个子类，并覆盖其中方法实现增强，因为底层是基于创建被代理类的一个子类，所以它避免了JDK动态代理类的缺陷。但因为采用的是继承，所以不能对final修饰的类进行代理。final修饰的类不可继承。

例子。

public class CGlibSubject implements MethodInterceptor {

private Object target;

public Object getInstance(Object target) {

this.target = target;

Enhancer enhancer = new Enhancer();

enhancer.setSuperclass(target.getClass());

// 设置回调方法

enhancer.setCallback(this);

// 创建代理对象

return enhancer.create();

}

@Override

public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

System.out.println("CGlib动态代理调用委托类方法之前");

Object result = methodProxy.invokeSuper(o, objects);

System.out.println("CGlib动态代理调用委托类方法之后");

return result;

}

测试：

public static void main (String[] args) {

CGlibSubject cglibSubject = new CGlibSubject();

RealSubject instance = (RealSubject) cglibSubject.getInstance(new RealSubject());

instance.doSomething();

}

输出：

CGlib动态代理调用委托类方法之前

RealSubject.doSomething()

CGlib动态代理调用委托类方法之后

CGlib动态代理特点总结

CGlib可以传入接口也可以传入普通的类，接口使用实现的方式,普通类使用会使用继承的方式生成代理类；

由于是继承方式,如果是static方法,private方法,final方法等描述的方法是不能被代理的；

做了方法访问优化，使用建立方法索引的方式避免了传统JDK动态代理需要通过Method方法反射调用；

提供callback 和filter设计，可以灵活地给不同的方法绑定不同的callback。编码更方便灵活；

CGLIB会默认代理Object中equals,toString,hashCode,clone等方法。比JDK代理多了clone。

4. 总结

静态代理是通过在代码中显式编码定义一个业务实现类的代理类，在代理类中对同名的业务方法进行包装，用户通过代理类调用委托类的业务方法；

JDK动态代理是通过接口中的方法名，在动态生成的代理类中调用业务实现类的同名方法；

CGlib动态代理是通过继承业务类，生成的动态代理类是业务类的子类，通过重写业务方法进行代理；

静态代理在编译时产生class字节码文件，可以直接使用，效率高。动态代理必须实现InvocationHandler接口，通过invoke调用被委托类接口方法是通过反射方式，比较消耗系统性能，但可以减少代理类的数量，使用更灵活。cglib代理无需实现接口，通过生成类字节码实现代理，比反射稍快，不存在性能问题，但cglib会继承目标对象，需要重写方法，所以目标对象不能为final类。

深圳网站建设www.sz886.com