Java中的反射机制和动态代理

一、反射概述

　　反射机制指的是Java在运行时候有一种自观的能力，能够了解自身的情况为下一步做准备，其想表达的意思就是：在运行状态中，对于任意一个类，都能够获取到这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性(包括私有的方法和属性)，这种动态获取的信息以及动态调用对象的方法的功能就称为java语言的反射机制。通俗点讲，通过反射，该类对我们来说是完全透明的，想要获取任何东西都可以，这是一种动态获取类的信息以及动态调用对象方法的能力。

　　想要使用反射机制，就必须要先获取到该类的字节码文件对象(.class)，通过该类的字节码对象，就能够通过该类中的方法获取到我们想要的所有信息(方法，属性，类名，父类名，实现的所有接口等等)，每一个类对应着一个字节码文件也就对应着一个Class类型的对象，也就是字节码文件对象。

　　Java提供的反射机制，依赖于我们下面要讲到的Class类和java.lang.reflect类库。我们下面要学习使用的主要类有：①Class表示类或者接口；②java.lang.reflect.Field表示类中的成员变量；③java.lang.reflect.Method表示类中的方法；④java.lang.reflect.Constructor表示类的构造方法；⑤Array提供动态数组的创建和访问数组的静态方法。

二、反射之Class类

(1)初识Class类

　　在类Object下面提供了一个方法：，此方法将会被所有的子类继承，该方法的返回值为一个Class，这个Class类就是反射的源头。那么Class类是什么呢？Class类是Java中用来表达运行时类型信息的对应类，我们刚刚也说过所有类都会继承Object类的getClass()方法，那么也体现了着Java中的每个类都有一个Class对象，当我们编写并编译一个创建的类就会产生对应的class文件并将类的信息写到该class文件中，当我们使用正常方式new一个对象或者使用类的静态字段时候，JVM的累加器子系统就会将对应的Class对象加载到JVM中，然后JVM根据这个类型信息相关的Class对象创建我们需要的实例对象或者根据提供静态变量的引用值。将Class类称为类的类型，一个Class对象称为类的类型对象。

(2)Class有下面的几个特点

　　①Class也是类的一种（不同于class，class是一个关键字）；

　　②Class类只有一个私有的构造函数，只有JVM能够创建Class类的实例；

　　③对于同一类的对象，在JVM中只存在唯一一个对应的Class类实例来描述其信息；

　　④每个类的实例都会记得自己是由哪个Class实例所生成；

　　⑤通过Class可以完整的得到一个类中的完整结构；

(3)获取Class类实例

　　刚刚说到过Class只有一个私有的构造函数，所以我们不能通过new创建Class实例 ，有下面这几种获取Class实例的方法：

　　①Class.forName("类的全限定名")，该方法只能获取引用类型的类类型对象。该方法会抛出异常(a.l类加载器在类路径中没有找到该类  b.该类被某个类加载器加载到JVM内存中，另外一个类加载器有尝试从同一个包中加载)

 //Class<T> clazz = Class.forName("类的全限定名");这是通过Class类中的静态方法forName直接获取一个Class的对象
 Class<?> clazz1 = null;
 try {
     clazz1 = Class.forName("reflect.Person");
 } catch (ClassNotFoundException e) {
     e.printStackTrace();
 }
 System.out.println(clazz1); //class reflect.Person

　　②如果我们有一个类的对象实例，那么通过这个对象的getClass()方法可以获得他的Class对象，如下所示

 //Class<T> clazz = xxx.getClass(); //通过类的实例获取类的Class对象
 Class<?> clazz3 = new Person().getClass();
 System.out.println(clazz3); //class reflect.Person

 Class<?> stringClass = "string".getClass();
 System.out.println(stringClass); //class java.lang.String

 /**
  * [代表数组，
  * B代表byte；
  * I代表int；
  * Z代表boolean；
  * L代表引用类型
  * 组合起来就是指定类型的一维数组，如果是[[就是二维数组
  */
 Class<?> arrClass = new byte[20].getClass();
 System.out.println(arrClass); //class [B

 Class<?> arrClass1 = new int[20].getClass();
 System.out.println(arrClass1); //class [I

 Class<?> arrClass2 = new boolean[20].getClass();
 System.out.println(arrClass2); //class [Z

 Class<?> arrClass3 = new Person[20].getClass();
 System.out.println(arrClass3); //class [Lreflect.Person;

 Class<?> arrClass4 = new String[20].getClass();
 System.out.println(arrClass4); //class [Ljava.lang.String;

　　③通过类的class字节码文件获取，通过类名.class获取该类的Class对象

 //Class<T> clazz = XXXClass.class; 当类已经被加载为.class文件时候，
 Class<Person> clazz2 = Person.class;
 System.out.println(clazz2);
 System.out.println(int [][].class);//class [[I
 System.out.println(Integer.class);//class java.lang.Integer

(4)关于包装类的静态属性

　　我们知道，在Java中对于基本类型和void都有对应的包装类。在包装类中有一个静态属性TYPE保存了该类的类类型。如下所示

     /**
      * The {@code Class} instance representing the primitive type
      * {@code int}.
      *
      * @since   JDK1.1
      */
     @SuppressWarnings("unchecked")
     public static final Class<Integer>  TYPE = (Class<Integer>) Class.getPrimitiveClass("int");

　　我们使用这个静态属性来获得Class实例，如下所示

 Class c0 = Byte.TYPE; //byte
 Class c1 = Integer.TYPE; //int
 Class c2 = Character.TYPE; //char
 Class c3 = Boolean.TYPE; //boolean
 Class c4 = Short.TYPE; //short
 Class c5 = Long.TYPE; //long
 Class c6 = Float.TYPE; //float
 Class c7 = Double.TYPE; //double
 Class c8 = Void.TYPE; //void

(5)通过Class类的其他方法获取

①public native Class<? super T> getSuperclass()：获取该类的父类

 Class c1 = Integer.class;
 Class par = c1.getSuperclass();
 System.out.println(par); //class java.lang.Number

②public Class<?>[] getClasses()：获取该类的所有公共类、接口、枚举组成的Class数组，包括继承的；

③public Class<?>[] getDeclaredClasses()：获取该类的显式声明的所有类、接口、枚举组成的Class数组；

④(Class/Field/Method/Constructor).getDeclaringClass()：获取该类/属性/方法/构造器所在的类

三、Class类的API

　　这是下面测试用例中使用的Person类和实现的接口

 package reflect;

 interface Test {
     String test = "interface";
 }

 public class Person  implements Test{

     private String id;
     private String name;

     public void sing(String name) {
         System.out.println(getName() + "会唱" + name +"歌");
     }

     private void dance(String name) {
         System.out.println(getName() + "会跳" + name + "舞");
     }

     public void playBalls() {
         System.out.println(getName() + "会打篮球");
     }

     public String getId() {
         return id;
     }

     public void setId(String id) {
         this.id = id;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public Person() {
     }

     public Person(String id, String name) {
         this.id = id;
         this.name = name;
     }

     public Person(String id) {
         this.id = id;
     }

     @Override
     public String toString() {
         return "Person{" +
                 "id='" + id + '\'' +
                 ", name='" + name + '\'' +
                 '}';
     }
 }

Person

1、创建实例对象

 public void test4() throws Exception{
     Class clazz =Class.forName("reflect.Person");
     Person person = (Person)clazz.newInstance();
     System.out.println(person);
 }

　　创建运行时类的对象，使用newInstance()，实际上就是调用运行时指定类的无参构造方法。这里也说明要想创建成功，需要对应的类有无参构造器，并且构造器的权限要足够，否则会抛出下面的异常。

　　①我们显示声明Person类一个带参构造，并没有无参构造，这种情况会抛出InstantiationException

　　

　　②更改无参构造器访问权限为private

　　

2、获取构造器

(1)获取指定可访问的构造器创建对象实例

　　上面我们所说的使用newInstance方法创建对象，如果不指定任何参数的话默认是调用指定类的无参构造器的。那么如果没有无参构造器，又想创建对象实例怎么办呢，就使用 Class类提供的获取构造器的方法，显示指定我们需要调用哪一个无参构造器。

 @Test
 public void test5() throws Exception {
     Class clazz = Class.forName("reflect.Person");
     //获取带参构造器
     Constructor constructor = clazz.getConstructor(String.class, String .class);
     //通过构造器来实例化对象
     Person person = (Person) constructor.newInstance("p1", "person");
     System.out.println(person);
 }

　　当我们指定的构造器全部不够（比如设置为private），我们在调用的时候就会抛出下面的异常

　　

(2)获得全部构造器

 @Test
 public void test6() throws Exception {
     Class clazz1 = Class.forName("reflect.Person");
     Constructor[] constructors = clazz1.getConstructors();
     for (Constructor constructor : constructors) {
         Class[] parameters = constructor.getParameterTypes();
         System.out.println("构造函数名：" + constructor + "\n" + "参数");
         for (Class c: parameters) {
             System.out.print(c.getName() + " ");
         }
         System.out.println();
     }
 }

　　运行结果如下

　　

3、获取成员变量并使用Field对象的方法

　　（1）Class.getField(String)方法可以获取类中的指定字段(可见的), 如果是私有的可以用getDeclaedField("name")方法获取,通过set(对象引用,属性值)方法可以设置指定对象上该字段的值, 如果是私有的需要先调用setAccessible(true)设置访问权限,用获取的指定的字段调用get(对象引用)可以获取指定对象中该字段的值。

 @Test
 public void test7() throws Exception {
     Class clazz1 = Class.forName("reflect.Person");
     //获得实例对象
     Person person = (Person) clazz1.newInstance();
     /**
      * 获得类的属性信息
      * 使用getField(name),通过指定的属性name获得
      * 如果属性不是public的，使用getDeclaredField(name)获得
      */
     Field field = clazz1.getDeclaredField("id");
     //如果是private的，需要设置权限为可访问
     field.setAccessible(true);
     //设置成员变量的属性值
     field.set(person, "person1");
     //获取成员变量的属性值，使用get方法，其中第一个参数表示获得字段的所属对象，第二个参数表示设置的值
     System.out.println(field.get(person)); //这里的field就是id属性，打印person对象的id属性的值
 }

　　（2）获得全部成员变量

 @Test
 public void test8() throws Exception{
     Class clazz1 = Class.forName("reflect.Person");
     //获得实例对象
     Person person = (Person) clazz1.newInstance();
     person.setId("person1");
     person.setName("person1_name");
     Field[] fields = clazz1.getDeclaredFields();
     for (Field f : fields) {
         //打开private成员变量的可访问权限
         f.setAccessible(true);
         System.out.println(f+ ":" + f.get(person));
     }
 }

　　

4、获取方法并使用method

　　(1)使用Class.getMethod(String, Class...) 和 Class.getDeclaredMethod(String, Class...)方法可以获取类中的指定方法，如果为私有方法，则需要打开一个权限。setAccessible(true);用invoke(Object, Object...)可以调用该方法。如果是私有方法而使用的是getMethod方法来获得会抛出NoSuchMethodException

 @Test
 public void test9() throws Exception{
     Class clazz1 = Class.forName("reflect.Person");
     //获得实例对象
     Person person = (Person) clazz1.newInstance();
     person.setName("Person");
     //①不带参数的public方法
     Method playBalls = clazz1.getMethod("playBalls");
     //调用获得的方法，需要指定是哪一个对象的
     playBalls.invoke(person);

     //②带参的public方法：第一个参数是方法名，后面的可变参数列表是参数类型的Class类型
     Method sing = clazz1.getMethod("sing",String.class);
     //调用获得的方法，调用时候传递参数
     sing.invoke(person,"HaHaHa...");

     //③带参的private方法：使用getDeclaredMethod方法
     Method dance = clazz1.getDeclaredMethod("dance", String.class);
     //调用获得的方法，需要先设置权限为可访问
     dance.setAccessible(true);
     dance.invoke(person,"HaHaHa...");
 }

　　(2)获得所有方法(不包括构造方法)

 @Test
 public void test10() throws Exception{
     Class clazz1 = Class.forName("reflect.Person");
     //获得实例对象
     Person person = (Person) clazz1.newInstance();
     person.setName("Person");
     Method[] methods = clazz1.getDeclaredMethods();
     for (Method method: methods) {
         System.out.print("方法名" + method.getName() + "的参数是：");
         //获得方法参数
         Class[] params = method.getParameterTypes();
         for (Class c : params) {
             System.out.print(c.getName() + " ");
         }
         System.out.println();
     }
 }

5、获得该类的所有接口

　　Class[] getInterfaces()：确定此对象所表示的类或接口实现的接口，返回值：接口的字节码文件对象的数组

 @Test
 public void test11() throws Exception{
     Class clazz1 = Class.forName("reflect.Person");
     Class[] interfaces = clazz1.getInterfaces();
     for (Class inter : interfaces) {
         System.out.println(inter);
     }
 }

6、获取指定资源的输入流

　　InputStream getResourceAsStream(String name)，返回值：一个 InputStream 对象；如果找不到带有该名称的资源，则返回 null；参数：所需资源的名称，如果以"/"开始，则绝对资源名为"/"后面的一部分。

 @Test
 public void test12() throws Exception {
     ClassLoader loader = this.getClass().getClassLoader();
     System.out.println(loader);//sun.misc.Launcher$AppClassLoader@18b4aac2 ,应用程序类加载器
     System.out.println(loader.getParent());//sun.misc.Launcher$ExtClassLoader@31befd9f ,扩展类加载器
     System.out.println(loader.getParent().getParent());//null ,不能获得启动类加载器

     Class clazz = Person.class;//自定义的类
     ClassLoader loader2 = clazz.getClassLoader();
     System.out.println(loader2);//sun.misc.Launcher$AppClassLoader@18b4aac2

     //下面是获得InputStream的例子
     ClassLoader inputStreamLoader = this.getClass().getClassLoader();
     InputStream inputStream = inputStreamLoader.getResourceAsStream("person.properties");
     Properties properties = new Properties();
     properties.load(inputStream);
     System.out.println("id:" + properties.get("id"));
     System.out.println("name:" + properties.get("name"));
 }

　　其中properties文件内容

 id = person001
 name = person-name1

五、反射的应用之动态代理

　　代理模式在Java中应用十分广泛，它说的是使用一个代理将对象包装起来然后用该代理对象取代原始对象，任何原始对象的调用都需要通过代理对象，代理对象决定是否以及何时将方法调用转到原始对象上。这种模式可以这样简单理解：你自己想要做某件事情(被代理类)，但是觉得自己做非常麻烦或者不方便，所以就叫一个另一个人(代理类)来帮你做这个事情，而你自己只需要告诉要做啥事就好了。上面我们讲到了反射，在下面我们会说一说java中的代理

1、静态代理

　　静态代理其实就是程序运行之前，提前写好被代理类的代理类，编译之后直接运行即可起到代理的效果，下面会用简单的例子来说明。在例子中，首先我们有一个*接口(ProductFactory)，这个接口需要代理类(ProxyTeaProduct)和被代理类(TeaProduct)都去实现它，在被代理类中我们重写需要实现的方法(action)，该方法会交由代理类去选择是否执行和在何处执行；被代理类中主要是提供*接口的的一个引用但是引用实际指向的对象则是实现了该接口的代理类(使用多态的特点，在代理类中提供构造器传递实际的对象引用)。分析之后，我们通过下面这个图理解一下这个过程。

 package proxy;

 /**
  * 静态代理
  */
 //产品接口
 interface ProductFactory {
     void action();
 }

 //一个具体产品的实现类,作为一个被代理类
 class TeaProduct implements ProductFactory{
     @Override
     public void action() {
         System.out.println("我是生产茶叶的......");
     }
 }

 //TeaProduct的代理类
 class ProxyTeaProduct implements ProductFactory {
     //我们需要ProductFactory的一个实现类，去代理这个实现类中的方法（多态）
     ProductFactory productFactory;

     //通过构造器传入实际被代理类的对象，这时候代理类调用action的时候就可以在其中执行被代理代理类的方法了
     public ProxyTeaProduct(ProductFactory productFactory) {
         this.productFactory = productFactory;
     }

     @Override
     public void action() {
         System.out.println("我是代理类，我开始代理执行方法了......");
         productFactory.action();
     }
 }
 public class TestProduct {

     public static void main(String[] args) {
         //创建代理类的对象
         ProxyTeaProduct proxyTeaProduct = new ProxyTeaProduct(new TeaProduct());
         //执行代理类代理的方法
         proxyTeaProduct.action();
     }
 }

　　那么程序测试的输出结果也很显然了，代理类执行自己实现的方法，而在其中有调用了被代理类的方法

　　

　　那么我们想一下，上面这种称为静态代理的方式有什么缺点呢？因为每一个代理类只能为一个借口服务(因为这个代理类需要实现这个接口，然后去代理接口实现类的方法)，这样一来程序中就会产生过多的代理类。比如说我们现在又来一个接口，那么是不是也需要提供去被代理类去实现它然后交给代理类去代理执行呢，那这样程序就不灵活了。那么如果有一种方式，就可以处理新添加接口的以及实现那不就更加灵活了吗，在java中反射机制的存在为动态代理创造了机会

2、JDK中的动态代理

　　动态代理是指通过代理类来调用它对象的方法，并且是在程序运行使其根据需要创建目标类型的代理对象。它只提供一个代理类，我们只需要在运行时候动态传递给需要他代理的对象就可以完成对不同接口的服务了。看下面的例子。(JDK提供的代理正能针对接口做代理，也就是下面的newProxyInstance返回的必须要是一个接口)

 package proxy;

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

 /**
  * JDK中的动态代理
  */
 //第一个接口
 interface TargetOne {
     void action();
 }
 //第一个接口的被代理类
 class TargetOneImpl implements TargetOne{
     @Override
     public void action() {
         System.out.println("我会实现父接口的方法...action");
     }
 }

 //动态代理类
 class DynamicProxyHandler implements InvocationHandler {
     //接口的一个引用，多态的特性会使得在程序运行的时候，它实际指向的是实现它的子类对象
     private TargetOne targetOne;
     //我们使用Proxy类的静态方法newProxyInstance方法，将代理对象伪装成那个被代理的对象
     /**
      * ①这个方法会将targetOne指向实际实现接口的子类对象
      * ②根据被代理类的信息返回一个代理类对象
      */
     public Object setObj(TargetOne targetOne) {
         this.targetOne = targetOne;
         //    public static Object newProxyInstance(ClassLoader loader, //被代理类的类加载器
         //                                          Class<?>[] interfaces, //被代理类实现的接口
         //                                          InvocationHandler h) //实现InvocationHandler的代理类对象
         return Proxy.newProxyInstance(targetOne.getClass().getClassLoader(),targetOne.getClass().getInterfaces(),this);
     }
     //当通过代理类的对象发起对接口被重写的方法的调用的时候，都会转换为对invoke方法的调用
     @Override
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         System.out.println("这是我代理之前要准备的事情......");
         /**
          *      这里回想一下在静态代理的时候，我们显示指定代理类需要执行的是被代理类的哪些方法；
          *      而在这里的动态代理实现中，我们并不知道代理类会实现什么方法，他是根据运行时通过反射来
          *  知道自己要去指定被代理类的什么方法的
          */
         Object returnVal = method.invoke(this.targetOne,args);//这里的返回值，就相当于真正调用的被代理类方法的返回值
         System.out.println("这是我代理之后要处理的事情......");
         return returnVal;
     }
 }
 public class TestProxy {
     public static void main(String[] args) {
         //创建被代理类的对象
         TargetOneImpl targetOneImpl = new TargetOneImpl();
         //创建实现了InvocationHandler的代理类对象，然后调用其中的setObj方法完成两项操作
         //①将被代理类对象传入，运行时候调用的是被代理类重写的方法
         //②返回一个类对象，通过代理类对象执行接口中的方法
         DynamicProxyHandler dynamicProxyHandler = new DynamicProxyHandler();
         TargetOne targetOne = (TargetOne) dynamicProxyHandler.setObj(targetOneImpl);
         targetOne.action(); //调用该方法运行时都会转为对DynamicProxyHandler中的invoke方法的调用
     }
 }

　　运行结果如下。现在我们对比jdk提供的动态代理和我们刚刚实现的静态代理，刚刚说到静态代理对于新添加的接口需要定义对应的代理类去代理接口的实现类。而上面的测试程序所使用的动态代理规避了这个问题，即我们不需要显示的指定每个接口对应的代理类，有新的接口添加没有关系，只需要在使用的时候传入接口对应的实现类然后返回代理类对象（接口实现类型），然后调用被代理类的方法即可。

　　

六、动态代理与AOP简单实现

1、AOP是什么

　　AOP（Aspect Orient Programming）我们一般称之为面向切面编程，作为一种面向对象的补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理、日志记录等。AOP实现的关键在于AOP的代理(实际实现上有静态代理和动态代理)，我们下面使用JDK的动态代理的方式模拟实现下面的场景。

2、模拟实现AOP

　　我们先考虑下面图中的情况和说明。然后我们使用动态代理的思想模拟简单实现一下这个场景

 package aop;

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

 //基于jdk的针对接口实现动态代理，要求的接口
 interface Target {
     void login();

     void logout();
 }

 //被代理类
 class TargetImpl implements Target {
     @Override
     public void login() {
         System.out.println("log......");
     }

     @Override
     public void logout() {
         System.out.println("logout......");
     }
 }

 class Util {
     public void printLog() {
         System.out.println("我是记录打印日志功能的方法......");
     }

     public void getProperties() {
         System.out.println("我是获取配置文件信息功能的方法......");
     }
 }

 //实现了InvocationHandler的统一代理类
 class DynamicProxyHandler implements InvocationHandler {
     private Object object;

     /**
      * 参数为obj，是应对对不同的被代理类，都能绑定与该代理类的代理关系
      * 这个方法会将targetOne指向实际实现接口的子类对象,即当前代理类实际要去代理的那个类
      */
     public void setObj(Object obj) {
         this.object = obj;
     }

     @Override
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         Util util = new Util();
         util.getProperties();
         Object object = method.invoke(this.object, args); //这个方法是个动态的方法，可以是login,可以是logout，具体在测试调用中调用不同方法
         util.printLog();
         return object;
     }
 }

 //该类的主要作用就是动态的创建一个代理类的对象，同时需要执行被代理类
 class MyDynamicProxyUtil {
     //参数obj表示动态的传递进来被代理类的对象
     public static Object getProxyInstance(Object object) {
         //获取代理类对象
         DynamicProxyHandler dynamicProxyHandler = new DynamicProxyHandler();
         dynamicProxyHandler.setObj(object);
         //设置好代理类与被代理类之间的关系后，返回一个代理类的对象
         return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(), dynamicProxyHandler);
     }
 }

 public class TestAop {
     public static void main(String[] args) {
         //获得被代理类
         Target target = new TargetImpl();
         //通过代理类工具类，设置实际与代理类绑定的被代理类，并返回一个代理类对象执行实际的方法
         Target execute = (Target) MyDynamicProxyUtil.getProxyInstance(target);
         execute.login();
         execute.logout();
     }
 }

　　现在来分析一下上面的代码，首先我们看一下下面的这个图。在图中动态代理增加的通用日志方法、配置文件方法就是增加的方法，他在执行用户实际自己开发的方法之前、之后调用。对应于上面的程序就是Target接口的实现类实现的login、logout方法被代理类动态的调用，在他们执行之前会调用日志模块和配置文件模块的功能。