Java动态代理机制研读

时间 2019-11-07

标签 java 动态代理机制研读栏目 Java 繁體版

原文原文链接

java动态加载类(反射机制)

/*MyClass.java*/
public class MyClass {
    public int id;
    public String name;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public MyClass(int id, String name) {
        this.id = id;
        this.name = name;
    }
    public MyClass(int id) {
        this.id = id;
    }
    public void sayHallo(){
        System.out.println("Hallo " + this.getName() + ", your id is: " + this.getId());
    }
}

/*Main.java*/
public class Main {
    public static void main(String [] args){
        try{
            //根据参数表(int.class)来指定用哪一个构造方法
            /*
            * 这里还想起一道面试题,"返回值不一样,参数相同的两个java 方法,能够存在么?"从这里能够看出答案了,若是一个方法只有返回值不一样,那么咱们经过一样的调用参数是没法定义其中一个方法的.
            */
            Constructor constructor = Class.forName("com.yy.MyClass").getConstructor(int.class);
            Object object = constructor.newInstance(10);

            Method method = Class.forName("MyClass").getMethod("sayHallo");
            method.invoke(object);

            Field field = Class.forName("MyClass").getField("id");
            Integer id = field.getInt(object);
        }
        catch (Exception e){
            e.printStackTrace();
        }
    }
}

那么这种动态加载类机制(也叫反射机制)有什么牛的呢?从代码能够看出来,咱们在不了解目标MyClass 的状况下(仅知道它的类名和方法),构造了它的一个实例.而且像经过普通的构造方法构造的对象同样调用它内部的方法和属性. 而这一切的一切,都只是创建在咱们知道它的”名字”这么简单的条件之上.
so?这又能作什么呢?先不看代码,先从逻辑的层面来推理下这样的一个特性能够实现怎样神奇的功能.java

由于咱们只须要知道类名就能够经过Class.forName("MyClass").getConstructor(int.class); 来获取类的构造方法,并构造它的实例.那么,咱们只知道类名,在代码真正运行以前,甚至不知道这个类是否真的存在(换句话说,咱们不知道有没有编译好的.class文件).也可让本身这部分代码经过编译. 很恐怖是否是?确实,这让咱们的代码在完整性上存在风险,若是找不到咱们经过名字指定的那个类.熟悉的ClassNotFoundException就会出现. 可是,这样换来的好处是让项目各部分代码能够相互独立的灵活性.能够动态地调用ClassLoader把.class文件装载到虚拟机当中来,而后使用其中的方法.这才使得动态连接程序组件成为可能.
另外,由于咱们能够跳过目标代码自己,直接调用其中的方法.根据各类设计模式的思想,咱们是否是能够在调用方法的时候作一些文章呢? 例如打个日志,格式化参数,改变业务逻辑.并且更重要的是,咱们还不会触动到目标代码.这就为AOP打下了基础

动态代理

一句话归纳动态代理,就是经过动态加载类的方式实现的代理模式.
因此,本质上,动态代理也是代理的一个子集.先盗张图来看看纯粹的代理模式.

用户直接操做的是Proxy,由于它和RealSubject同样都实现了Subject借口,因此在接口中定义的方法,能够在Proxy或者RealSubject中随意使用.而实际上Proxy内部经过保留一个RealSubject对象来实现这种一致性,看起来就是借了Proxy之手的代理来访问RealSubject.这就是简单的代理模式.
动态代理简单地说就是在这个基础上把RealSubject的实例化从简单的new建立变成了动态建立.(虽说的过于简单,但核心就是这个思想)面试

在看java官方的实现以前,先来看一个本身写的简单范例.它解释了什么叫动态代理,以及感性地认识到动态代理所带来的好处.算法

*须要代理的目标接口*/
public interface MyProxy {
    int add(int arg1, int arg2);
}

/*代理类*/
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MyProxyImpl implements MyProxy {
    protected InvocationHandler handler;
    public MyProxyImpl(InvocationHandler handler){
        this.handler = handler;
    }
    @Override
    public int add(int arg1, int arg2) {
        Method method = null;
        try{
            method = MyProxy.class.getMethod("add",new Class[]{int.class, int.class});
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        Object result = null;
        try {
            result = handler.invoke(this,method,new Object[]{new Integer(arg1), new Integer(arg2)});
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        return (Integer)result;
    }
}

/*真正执行方法的handler,这里采用a+b+...的方法来计算add()方法*/
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MyHandler implements InvocationHandler {
    public MyHandler(){
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (method.getName().equals("add")){
            Integer sum = 0;
            for (Object object : args){
                sum = (Integer) object + sum;
            }
            return sum;
        }
        else {
            return null;
        }
    }
}
/*真正执行方法的handler2,与handler不一样,本类把add()方法按照a*b...的方法来处理**/
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MyHandler2 implements InvocationHandler {
    public MyHandler2(){
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (method.getName().equals("add")){
            Integer sum = 1;
            for (Object object : args){
                sum = (Integer) object * sum;
            }
            return sum;
        }
        else {
            return null;
        }
    }
}

/*业务类*/
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
public class MyMain {
    public static void main(String [] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //只须要简单的修改实际执行add()方法的类名,即可彻底一致地调用两种算法.业务代码不用作任何修改.
        //反过来,若是业务代码中类名不变,无论MyHandler怎样去实现add()方法都是能够的.
        Class cl = MyMain.class.forName("com.yy.MyHandler");
        //Class cl = MyMain.class.forName("com.yy.MyHandler2");
        Constructor constructor = cl.getConstructor();
        InvocationHandler invocationHandler = (InvocationHandler) constructor.newInstance();
        MyProxy myProxy = new MyProxyImpl(invocationHandler);
        Integer i = myProxy.add(32,18);
        System.out.println(i);
    }
}

经过上面这个例子,咱们能够看到利用动态代理.咱们一方面能够保证业务代码和底层代码实现的解耦,另外一方面又能够对任何可能添加进来的底层组件进行修饰.举个例子,咱们能够对MyProxyImpl.add()作如下修改设计模式

 @Override
    public int add(int arg1, int arg2) {
        System.out.println("计算的参数是:" + arg1 + "," + arg2);//加了这一行
        Method method = null;
        try{
            method = MyProxy.class.getMethod("add",new Class[]{int.class, int.class});
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        Object result = null;
        try {
            result = handler.invoke(this,method,new Object[]{new Integer(arg1), new Integer(arg2)});
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        return (Integer)result;
    }

注意到咱们添加了一行代码,让任何经过代理调用add()方法的操做都会打印出参数.不论底层你调用的是hander1仍是handler2.是否是很方便?!app

固然,咱们这样所谓的动态代理还有不少问题,下面仍是来看看Java官方利用Proxy实现的动态代理机制.ide

java.lang.reflect.Proxy

经过官方的Proxy,要实现上面的代码逻辑,能够这样写:this

public class MyMain {

    public static void main(String [] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class cl = MyMain.class.forName("MyHandler");
        Constructor constructor = cl.getConstructor();
        InvocationHandler invocationHandler = (InvocationHandler) constructor.newInstance();
        MyProxy myProxy = (MyProxy) Proxy.newProxyInstance(MyMain.class.getClassLoader(),new Class[]{MyProxy.class},invocationHandler);
        Integer result = myProxy.add(1,2);
        System.out.println(result);
    }
}

核心在Proxy.newProxyInstance(MyMain.class.getClassLoader(),new Class[]{MyProxy.class},invocationHandler); 用心的读者会发现,其实这里跟咱们本身的实现差了一个MyProxyImpl实现类. 咱们最终调用的是类MyProxyImpl的实例对象,而官方方法调用的倒是MyProxy接口的实例对象.
并且,若是你试图得到一个实现类的实例对象,会报错说MyProxyImpl不是一个接口!spa

MyProxyImpl myProxy = (MyProxyImpl) Proxy.newProxyInstance(MyMain.class.getClassLoader(),new Class[]{MyProxyImpl.class},invocationHandler);

>>>Exception in thread "main" java.lang.IllegalArgumentException: MyProxyImpl is not an interface

看到Proxy类有一个私有内部静态类ProxyClassFactory,这个类就是用来获取Class实例的.里面有一个apply()方法,这个方法会遍历Proxy.newProxyInstance()第二个参数传进来的全部类是否是接口.设计

/*
  * Verify that the Class object actually represents an
  * interface.
  */
 if (!interfaceClass.isInterface()) {
     throw new IllegalArgumentException(
         interfaceClass.getName() + " is not an interface");
 }

因此才有了上面咱们遇到的报错.那么,如今问题成了为何Proxy要作这个限制呢?简单的理解就是,java的单继承机制决定了.若是第二个参数传进来的是多个实体类,那么他们是没法实例化一个对象的.代理