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?这又能做什么呢?先不看代码,先从逻辑的层面来推理下这样的一个特性可以实现怎样神奇的功能.

• 因为我们只需要知道类名就可以通过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.是不是很方便?!

当然,我们这样所谓的动态代理还有很多问题,下面还是来看看Java官方利用Proxy实现的动态代理机制.

java.lang.reflect.Proxy

通过官方的Proxy,要实现上面的代码逻辑,可以这样写:

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不是一个接口!

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的单继承机制决定了.如果第二个参数传进来的是多个实体类,那么他们是无法实例化一个对象的.