[Thinking in Java] - No.5 Java反射机制和动态代理

1. Java反射机制：

WiKi百科：In computer science, reflection is the ability of a computer program to examine, introspect, and modify its own structure and behavior at runtime.

意思大概是：反射，是计算机程序的一种在运行时检查，反省(自省)并且修改自身行为、结构的能力。

我们再浅显一点的理解就是：我们在运行时，对于任意一个人类可以知道这个类有什么方法属性，并且对于任意一个对象，我们可以在运行时调用它的一个方法，这就是反射。反射机制为我们提供了一下功能：

1.判断类所具有的成员变量、方法。

2.构造一个类的对象。

3.判断一个对象的属于什么类

4.调用一个对象的方法。

Class和java.lang.reflect类库一起对反射的概念进行了支持，包括Field、Method、Constructor类（均实现的Member 接口），这些类型的对象是 由JVM在运行的时候创建的，主要方法有：

getName()：获得类的完整名字。
getFields()：获得类的public类型的属性。
getDeclaredFields()：获得类的所有属性。
getMethods()：获得类的public类型的方法。
getDeclaredMethods()：获得类的所有方法。
getMethod(String name, Class[] parameterTypes)：获得类的特定方法，name参数指定方法的名字，parameterTypes 参数指定方法的参数类型。
getConstructors()：获得类的public类型的构造方法。
getConstructor(Class[] parameterTypes)：获得类的特定构造方法，parameterTypes 参数指定构造方法的参数类型。
newInstance()：通过类的不带参数的构造方法创建这个类的一个对象。

Member接口：

public interface Member{  
   public static final int PUBLIC = 0; //标识类或接口的所有已声明成员的集合。  
   public static final int DECLARED = 1; //标识类或接口的所有公共成员（包括继承成员）的集合。  
     
   public Class<?> getDeclaringClass();// 所在类  
   public String getName(); //返回此 Member 表示的底层成员或构造方法的简单名称。  
   public int getModifiers(); //作为整数返回由此 Member 所表示的成员或构造方法的 Java 语言修饰符。  
   public boolean isSynthetic(); //如果此成员是编译器引入的，则返回 true；否则，返回 false。  
  
}  

那么反射机制和我们平常创建类、调用方法的方式有什么区别呢？

平常：已知某个类名-new实例化对象-调用相关函数

反射机制：实例化对象-getClass()-获取类名

我们来看Wiki中给出的一个例子：

// Without reflection
Foo foo = new Foo();


foo.hello();


// With reflection
Object foo = Class.forName("complete.classpath.and.Foo").newInstance();
// Alternatively: Object foo = Foo.class.newInstance();
Method m = foo.getClass().getDeclaredMethod("hello", new Class<?>[0]);
m.invoke(foo);

最上面的就是最普通的实例化对象的例子。

下面，我们首先通过Class.forName()获取这个类的一个引用，然后创建了该类的一个对象。

然后通过getClass()获取类名，通过getDeclaredMethod()方法，返回一个method对象。

调用该方法(foo对象)

2.动态代理:

代理的概念：代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。详情参见静态代理。

动态代理则是，动态的创建代理并动态地处理所代理方法的调用。在动态代理上所做的调用都会被重定向到单一的调用处理器上。

我们给出动态代理的一个例子：

定义一个接口BorrowService：

/**
 * Created by YanMing on 2017/3/20.
 */
public interface BorrowService {
   void borrowBook();
   void borrowOthers(String str);
}

创建类实现接口：

/**
 * Created by YanMing on 2017/3/20.
 */
public class bsImpl implements BorrowService{
    @Override
    public void borrowBook() {
        System.out.println("Borrow Book");
    }

    @Override
    public void borrowOthers(String str) {
        System.out.println("Borrow " + str);
    }
}

创建动态代理：

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

/**
 * Created by YanMing on 2017/3/20.
 */
public class DynamicBorrowProxyHandler implements InvocationHandler {
    private Object proxied;
    public DynamicBorrowProxyHandler(Object proxied){
        this.proxied = proxied;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("=====Before=====");
        System.out.println("proxy: " + proxy.getClass());
        System.out.println("method: " + method);
        System.out.println("args: " + args);
        Object result = method.invoke(proxied,args);
        System.out.println("=====End======");
        return  result;
    }

}

我们来测试一下：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.*;
/**
 * Created by YanMing on 2017/3/20.
 */
public class Reflection {
    
    public static void test(BorrowService borrowService){
        borrowService.borrowBook();
        borrowService.borrowOthers("ReadingRoom");
    }

    public  static  void main(String [] args){
        bsImpl library = new bsImpl();
        test(library);
        BorrowService dynamicLibrary = (BorrowService)Proxy.newProxyInstance(
                BorrowService.class.getClassLoader(),
                new Class[] {BorrowService.class},
                new DynamicBorrowProxyHandler(library));
        test(dynamicLibrary);
    }
}

动态代理要实现实现InvocationHandler接口的invoke函数。该Invoke函数会在你通过接口调用实例函数的时候被调用。例如上面的dynamicLibrary，我们并没有通过new来创建一个实例对象，而是使用Proxy.newProxyInstance创建并转型。 Proxy.newProxyInstance签名如下：

static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)

运行如下：

总结一下我们使用动态代理的过程：

1.将你需要实现的方法封装成接口

2.编写一个类实现该接口

3.编写一个继承InvocationHandler的动态代理，并覆盖invoke函数

4.在使用时使用Proxy.newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)创建一个对象并转型为接口类型。

5.直接调用接口函数

本文Githu源码下载

P.S.文章不妥之处还望指正