写在前面

想必开发过接口的童鞋们，应该或多或少写过一些接口说明文档。那么，有没有可能把现有的接口做成一个界面在页面展现出来而不用去写什么接口文档,在页面展示的信息包括接口名，入参，属性，注释…… 如果有提供这些接口信息的池的话就用池的方式来做，我觉得做起来也挺方便的，效率也高。如果项目中没有这样的池，可以考虑用反射的方式来实现。那么，今天先来回顾一下java反射机制。关于反射的介绍，了解请看 官方文档。

JAVA反射机制

1、Java反射的概念
反射含义：可以获取正在运行的Java对象。

详细解释见百度百科：

AVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 JAVA反射（放射）机制：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。但是JAVA有着一个非常突出的动态相关机制：Reflection，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。

2、Java反射的功能
1)可以判断运行时对象所属的类
2)可以判断运行时对象所具有的成员变量和方法
3)通过反射甚至可以调用到private的方法
4)生成动态代理
Java反射的功能，一句话总结就是：反射用于在运行时检测和修改某个对象的结构及其行为。
3、实现Java反射的类
1)Class：它表示正在运行的Java应用程序中的类和接口
2)Field：提供有关类或接口的属性信息，以及对它的动态访问权限
3)Constructor：提供关于类的单个构造方法的信息以及对它的访问权限
4)Method：提供关于类或接口中某个方法信息
注意：Class类是Java反射中最重要的一个功能类，所有获取对象的信息(包括：方法/属性/构造方法/访问权限)都需要它来实现
4、编写Java反射程序的步骤 　　1)必须首先获取一个类的Class对象 　　例如： 　　Class c1 = Test.class; 　　Class c2 = Class.forName(“com.mysql.jdbc.Driver ”); 　　Class c3 = new Test().getClass(); 　　2)然后分别调用Class对象中的方法来获取一个类的属性/方法/构造方法的结构 　　注意：如果要能够正常的获取类中方法/属性/构造方法应该重点掌握如下的反射类 　　Field 　　Constructor 　　Method
5、例子

<pre>
package wblearn;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**

• @author wblearn

• @date 2016-9-25
  */
  public class TestReflection {
  private String name;
  private boolean learn;
  private int[] age;

  public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException,
  SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException {
  Class c1 = TestReflection.class;
  Class c2 = Class.forName("wblearn.TestReflection");
  //获取指定的包名
  String package01 = c1.getPackage().getName();
  String package02 = c2.getPackage().getName();
  System.out.println("package01 = " + package01);
  System.out.println("package02 = " + package02);
  //获取类的修饰符
  int mod = c1.getModifiers();
  String modifier = Modifier.toString(mod);
  System.out.println("modifier = " + modifier);
  //获取指定类的完全限定名
  String className = c1.getName();
  System.out.println("className = " + className);
  //获取指定类的父类
  Class superClazz = c1.getSuperclass();
  String superClazzName = superClazz.getName();
  System.out.println("superClazzName = " + superClazzName);
  //获取实现的接口
  Class[] interfaces = c1.getInterfaces();
  for (Class t : interfaces) {
  System.out.println("interfacesName = " + t.getName());
  }
  //获取指定类的成员变量
  Field[] fields = c1.getDeclaredFields();
  for (Field field : fields) {
  modifier = Modifier.toString(field.getModifiers()); //获取每个字段的访问修饰符
  Class type = field.getType(); //获取字段的数据类型所对应的Class对象
  String name = field.getName(); //获取字段名
  if (type.isArray()) { //如果是数组类型则需要特别处理
  String arrType = type.getComponentType().getName() +
  "[]";
  System.out.println("" + modifier + " " + arrType + " "
  + name + ";");
  } else {
  System.out.println("" + modifier + " " + type + " " +
  name + ";");
  }
  }
  //获取类的构造方法
  Constructor[] constructors = c1.getDeclaredConstructors();
  for (Constructor constructor : constructors) {
  String name = constructor.getName(); //构造方法名
  modifier = Modifier.toString(constructor.getModifiers()); //获取访问修饰符
  System.out.println("" + modifier +" " + name + "(");
  Class[] paramTypes = constructor.getParameterTypes(); //获取构造方法中的参数
  for (int i = 0; i < paramTypes.length; i++) {
  if (i > 0) {
  System.out.print(",");
  }
  if (paramTypes[i].isArray()) {
  System.out.println(paramTypes
  [i].getComponentType().getName()+"[]");
  } else {
  System.out.print(paramTypes[i].getName());
  }
  }
  System.out.println(");");
  }
  //获取成员方法
  Method[] methods = c1.getDeclaredMethods();
  for (Method method: methods) {
  modifier = Modifier.toString(method.getModifiers());
  Class returnType = method.getReturnType(); //获取方法的返回类型
  if (returnType.isArray()) {
  String arrType = returnType.getComponentType
  ().getName()+"[]";
  System.out.print(""+modifier+" " + arrType + " " +
  method.getName() + "(");
  } else {
  System.out.print("" + modifier + " " +
  returnType.getName() + " " + method.getName() + "(");
  }
  Class[] paramTypes = method.getParameterTypes();
  for (int i = 0; i < paramTypes.length; i++) {
  if (i > 0) {
  System.out.print(",");
  }
  if (paramTypes[i].isArray()) {
  System.out.println(paramTypes
  [i].getComponentType().getName()+"[]");
  } else {
  System.out.print(paramTypes[i].getName());
  }
  }
  System.out.println(");");
  }

    TestReflection t1 = (TestReflection) c1.newInstance(); //利用反射来创建类的对象
    System.out.println("name == " + t1.name);
    System.out.println("learn == " + t1.learn);
    Method method = c1.getDeclaredMethod("setName", String.class);
    method.invoke(t1, "我是wblearn");
    System.out.println("name == " + t1.name);
    method = c1.getDeclaredMethod("setLearn", boolean.class);
    method.setAccessible(true);
    method.invoke(t1, true);
    System.out.println("learn == " + t1.learn);
    
    }

public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public boolean isLearn() {
    return learn;
}
public void setLearn(boolean learn) {
    this.learn = learn;
}
public int[] getAge() {
    return age;
}
public void setAge(int[] age) {
    this.age = age;
}

}

</pre>

打印结果：

这里写图片描述
6、反射的优缺点
优点：
（1）能够运行时动态获取类的实例，大大提高系统的灵活性和扩展性。
（2）与Java动态编译相结合，可以实现无比强大的功能
缺点：
（1）使用反射的性能较低
（2）使用反射相对来说不安全
（3）破坏了类的封装性，可以通过反射获取这个类的私有方法和属性

写在最后

任何事物，都有两面性，反射的优点，也同是就是它的缺点，所以，没有好与坏，合适的场景应用才是最好的，正如前面说的，如果能有提供接口信息的池就用池的方式。这篇就简单的回顾一下java反射机制，下篇就将反射应用到项目中将接口信息呈现在界面。另外，在学习编程的过程中，我觉得不止要获得各种知识，更多的是通过学习技术知识提高解决问题的能力，这样我们才能立于不败之地！