Java代理1 代理和动态代理的基础与使用

WindCoder

发布于 2018-09-19 07:53:21

34300

代码可运行

文章被收录于专栏：WindCoderWindCoder

运行总次数：0

代码可运行

前言

预计分两篇写，第一篇是基础和一般用法，第二篇详细写下动态代理。本篇基础主要来自《Think in java》阅读笔记。

代理

代理是基本的设计模式之一。

是为了提供额外的或不同的操作，而插入的用来代替“实际”对象的对象。

将额外的操作从“实际”对象中分离到不同的地方，特别是希望能够容易的做出修改，从没有使用额外操作转为使用这些操作，或者反过来时，代理就显得很有用。

设计模式的关键就是封装修改-因此需要修改事务以证明这种模式的正确性。如，当希望跟踪Dog中的方法调用，或度量这些调用的开销，这些代码肯定不希望将其合并到应用中的代码，此时代理可以很容易的添加或移除他们。

通俗说，代理就是对象需要一些附加或不同的操作时，使用第三方对象操作原对象以及处理这些操作，从而达到不直接修改原对象的目的的一种设计模式。

静态代理是在编译时就将接口、实现类、代理类全部写出来，但若是需要很多代理，就需要每一次都这样写一遍，这就可能导致时间与资源的浪费。此时可以使用动态代理来代替静态代理。

静态代理的实现

接口类 Animal

public interface Animal {
    void doBark();
    void somethingElse(String arg);
}

具体实现类 Dog

public class Dog implements Animal {
    public void doBark() {
        PrintUtill.println("doBark wow");
    }

    public void somethingElse(String arg) {
        PrintUtill.println("somethingElse " + arg);
    }
}

代理类 SimpleProxy

public class SimpleProxy implements Animal {

    private Animal proxied;

    public SimpleProxy(Animal proxied) {
        this.proxied = proxied;
    }

    public void doBark() {
        PrintUtill.println("SimpleProxy doSomething");
        proxied.doBark();
    }

    public void somethingElse(String arg) {
        PrintUtill.println("SimpleProxy somethingElse " + arg);
        proxied.somethingElse(arg);
    }
}

测试代理类 SimpleProxyDemo

/**
 * consumer 接收的Animal，所以它无法知道正则获得的到底是Dog还是SimpleProxy，因为这两者都实现了Animal。
 *
 * 但是SimpleProxy已经被插入到consumer与Dog之间，因此它会执行操作，然后调用Dog上相同的方法。
 */
public class SimpleProxyDemo {
    public static void  consumer(Animal iface){
        iface.doBark();
        iface.somethingElse("WindCoder.com");
    }

    public static void main(String[] args) {
        consumer(new Dog());
        consumer(new SimpleProxy(new Dog()));
    }
}

测试结果：

doBark wow
somethingElse WindCoder.com
SimpleProxy doSomething
doBark wow
SimpleProxy somethingElse WindCoder.com
somethingElse WindCoder.com

动态代理

动态代理可以动态地创建代理并动态地处理对所代理方法的调用。

在动态代理上所做的所有调用都会被重定向到单一的调用处理器上。

该调用处理器的工作是揭示调用的类型并确定相应的对策。

JDK动态代理实现

InvocationHandler接口的实现类DynamicProxyHandler

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DynamicProxyHandler implements InvocationHandler {
    private Object proxied;

    public DynamicProxyHandler(Object proxied) {
        this.proxied = proxied;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("*** proxy: " + proxy.getClass() + " , method: " + method + " , args: " + args);
        if (args != null){
            for (Object arg: args){
                PrintUtill.println(" " + arg);
            }
        }
        return method.invoke(proxied, args);
    }
}

动态代理测试类SimpleDynamicProxy

public class SimpleDynamicProxy {
    public static void consumer(Animal iface){
        iface.doBark();
        iface.somethingElse("windCoder.com DynamicProxy");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        consumer(dog);
        // Insert a proxy and call again
        Animal prox = (Animal) Proxy.newProxyInstance(
                Animal.class.getClassLoader(),
                new Class[]{Animal.class},
                new DynamicProxyHandler(dog)
        );
        consumer(prox);

    }
}

测试结果：

doBark wow
somethingElse windCoder.com DynamicProxy
*** proxy: class com.sun.proxy.$Proxy0 , method: public abstract void Others.base.SimpleProxy.Animal.doBark() , args: null
doBark wow
*** proxy: class com.sun.proxy.$Proxy0 , method: public abstract void Others.base.SimpleProxy.Animal.somethingElse(java.lang.String) , args: [Ljava.lang.Object;@4b67cf4d
 windCoder.com DynamicProxy
somethingElse windCoder.com DynamicProxy

关键代码解析

动态代理测试类SimpleDynamicProxy.java中

        Animal prox = (Animal) Proxy.newProxyInstance(
                Animal.class.getClassLoader(),
                new Class[]{Animal.class},
                new DynamicProxyHandler(dog)
        );

通过调用静态方法Proxy.newProxyInstance()可以创建动态代理，这个方法需要得到：

1. 一个类加载器（你通常可以从已经被加载的对象获取其类加载器，然后传递给它，如此处的Animal.class.getClassLoader()）
2. 一个你希望该代理类实现的接口列表（不是类或抽象类）,如 new Class[]{Animal.class}
3. InvocationHandler接口的一个实现，如DynamicProxyHandler

动态代理可以将所有调用重定向到调用处理器。

通常会向调用处理器的构造器传递一个“实际”对象的引用，从而使得调用处理器在执行其中介任务时，可以将请求转发。

InvocationHandler接口的实现类DynamicProxyHandler.java中：

method.invoke(proxied, args);

亦既：

    public Object invoke(Object obj, Object... args)

invoke()方法中传递进来了代理对象，以防使用时需要区分请求的来源，但在许多情况下并不关心这一点。

在invoke()内部，在代理调用方法时，对接口的调用将被重定向为对代理的调用,因此要格外当心。

通常，执行被代理的操作，然后使用Method.invoke()将请求转发给被代对象，并传入必需的参数。

初看起来可能有些受限，就像只能执行泛化操作一样。

但可以通过传递其他的参数，来过滤某些方法的调用。

CGLIB动态代理(CGLibDemo)

JDK动态代理: 只能代理实现了接口的类,没有实现接口的类不能实现JDK动态代理。

Cglib代理: 针对类来实现代理,对指定目标产生一个子类通过方法拦截技术拦截所有父类方法的调用。

在实现内部，CGLIB库使用了ASM这一个轻量但高性能的字节码操作框架来转化字节码，产生新类。

CGLIB实现方式

1.首先定义业务类，无需实现接口（当然，实现接口也可以，不影响的）

public class DogCGlib {
    public void doBark() {
        PrintUtill.println("doBark wow CGlib");
    }

    public void somethingElse(String arg) {
        PrintUtill.println("somethingElse CGlib" + arg);
    }
}

2.实现 MethodInterceptor方法代理接口，创建代理类

public class CGlibProxy implements MethodInterceptor {

    public Object getInstance(Class  target){
        //创建加强器，用来创建动态代理类
        Enhancer enhancer = new Enhancer();
        //为加强器指定要代理的业务类（即：为下面生成的代理类指定父类）
        enhancer.setSuperclass(target);
        //设置回调：对于代理类上所有方法的调用，都会调用CallBack，而Callback则需要实现intercept()方法进行拦
        enhancer.setCallback(this);
        // 创建动态代理类对象并返回
        return enhancer.create();
    }
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("windcoder.com日志开始...");
        //代理类调用父类的方法
        proxy.invokeSuper(obj, args);
        System.out.println("windcoder.com日志结束...");
        return null;
    }
}

3.创建业务类和代理类对象，然后通过代理类对象.getInstance(业务类对象) 返回一个动态代理类对象（它是业务类的子类，可以用业务类引用指向它）。最后通过动态代理类对象进行方法调用。

public class CGLIBDemo {
    public static void main(String[] args) {
        // 设置输出目录，方便之后查看CGLIB生成的class---非必选项
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "./tmp/");
        // 正式执行
        CGlibProxy proxy = new CGlibProxy();
        DogCGlib dog = (DogCGlib)proxy.getInstance(DogCGlib.class);
        dog.doBark();
        PrintUtill.printlnRule();
        dog.somethingElse("  你好");
    }
}