一、反射的概述
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.
以上的总结就是什么是反射
反射就是把java类中的各种成分映射成一个个的Java对象
例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象。
（其实：一个类中这些成员方法、构造方法、在加入类中都有一个类来描述）
如图是类的正常加载过程：反射的原理在与class对象。
熟悉一下加载的时候：Class对象的由来是将class文件读入内存，并为之创建一个Class对象。
二，反射机制的相关类
与Java反射相关的类如下：
| 类名 | 用途 |
|---|---|
| Class类 | 代表类的实体，在运行的Java应用程序中表示类和接口 |
| Field类 | 代表类的成员变量（成员变量也称为类的属性） |
| Method类 | 代表类的方法 |
| Constructor类 | 代表类的构造方法 |
Class类
Class代表类的实体，在运行的Java应用程序中表示类和接口。在这个类中提供了很多有用的方法，这里对他们简单的分类介绍。
获得类相关的方法
| 方法 | |
|---|---|
| asSubclass(Class< U> clazz) | 把传递的类的对象转换成代表其子类的对象 |
| Cast | 把对象转换成代表类或是接口的对象 |
| getClassLoader() | 获得类的加载器 |
| getClasses() | 返回一个数组，数组中包含该类中所有公共类和接口类的对象 |
| getDeclaredClasses() | 返回一个数组，数组中包含该类中所有类和接口类的对象 |
| forName(String className) | 根据类名返回类的对象 |
| getName() | 获得类的完整路径名字 |
| newInstance() | 创建类的实例 |
| getPackage() | 获得类的包 |
| getSimpleName() | 获得类的名字 |
| getSuperclass() | 获得当前类继承的父类的名字 |
| getInterfaces() | 获得当前类实现的类或是接口获得类中属性相关的方法 |
方法 用途
getField(String name) 获得某个公有的属性对象
getFields() 获得所有公有的属性对象
getDeclaredField(String name) 获得某个属性对象
getDeclaredFields() 获得所有属性对象
获得类中注解相关的方法
方法 用途
getAnnotation(Class< A> annotationClass) 返回该类中与参数类型匹配的公有注解对象
getAnnotations() 返回该类所有的公有注解对象
getDeclaredAnnotation(Class< A> annotationClass) 返回该类中与参数类型匹配的所有注解对象
getDeclaredAnnotations() 返回该类所有的注解对象
获得类中构造器相关的方法
方法 用途
getConstructor(Class…<?> parameterTypes) 获得该类中与参数类型匹配的公有构造方法
getConstructors() 获得该类的所有公有构造方法
getDeclaredConstructor(Class…< ?> parameterTypes) 获得该类中与参数类型匹配的构造方法
getDeclaredConstructors() 获得该类所有构造方法
获得类中方法相关的方法
方法 用途
getMethod(String name, Class…<?> parameterTypes) 获得该类某个公有的方法
getMethods() 获得该类所有公有的方法
getDeclaredMethod(String name, Class…<?> parameterTypes) 获得该类某个方法
getDeclaredMethods() 获得该类所有方法
类中其他重要的方法
方法 用途
isAnnotation() 如果是注解类型则返回true
isAnnotationPresent(Class<? extends Annotation> annotationClass) 如果是指定类型注解类型则返回true
isAnonymousClass() 如果是匿名类则返回true
isArray() 如果是一个数组类则返回true
isEnum() 如果是枚举类则返回true
isInstance(Object obj) 如果obj是该类的实例则返回true
isInterface() 如果是接口类则返回true
isLocalClass() 如果是局部类则返回true
isMemberClass() 如果是内部类则返回true
Field类
Field代表类的成员变量（成员变量也称为类的属性）。
方法 用途
equals(Object obj) 属性与obj相等则返回true
get(Object obj) 获得obj中对应的属性值
set(Object obj, Object value) 设置obj中对应属性值
Method类
Method代表类的方法。
方法 用途
invoke(Object obj, Object… args) 传递object对象及参数调用该对象对应的方法
Constructor类
Constructor代表类的构造方法。
方法 用途
newInstance(Object… initargs) 根据传递的参数创建类的对象
三，Java反射机制实现：
1.）class对象的获取
//第一种方式 通过对象getClass方法
Person person = new Person();
Class<?> class1 = person.getClass();
//第二种方式 通过类的class属性
class1 = Person.class;
try {
//第三种方式 通过Class类的静态方法——forName()来实现
class1 = Class.forName("com.whoislcj.reflectdemo.Person");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
2.）获取class对象的摘要信息
boolean isPrimitive = class1.isPrimitive();//判断是否是基础类型
boolean isArray = class1.isArray();//判断是否是集合类
boolean isAnnotation = class1.isAnnotation();//判断是否是注解类
boolean isInterface = class1.isInterface();//判断是否是接口类
boolean isEnum = class1.isEnum();//判断是否是枚举类
boolean isAnonymousClass = class1.isAnonymousClass();//判断是否是匿名内部类
boolean isAnnotationPresent = class1.isAnnotationPresent(Deprecated.class);//判断是否被某个注解类修饰
String className = class1.getName();//获取class名字 包含包名路径
Package aPackage = class1.getPackage();//获取class的包信息
String simpleName = class1.getSimpleName();//获取class类名
int modifiers = class1.getModifiers();//获取class访问权限
Class<?>[] declaredClasses = class1.getDeclaredClasses();//内部类
Class<?> declaringClass = class1.getDeclaringClass();//外部类
3.）获取class对象的属性、方法、构造函数等
Field[] allFields = class1.getDeclaredFields();//获取class对象的所有属性
Field[] publicFields = class1.getFields();//获取class对象的public属性
try {
Field ageField = class1.getDeclaredField("age");//获取class指定属性
Field desField = class1.getField("des");//获取class指定的public属性
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
Method[] methods = class1.getDeclaredMethods();//获取class对象的所有声明方法
Method[] allMethods = class1.getMethods();//获取class对象的所有方法 包括父类的方法
Class parentClass = class1.getSuperclass();//获取class对象的父类
Class<?>[] interfaceClasses = class1.getInterfaces();//获取class对象的所有接口
Constructor<?>[] allConstructors = class1.getDeclaredConstructors();//获取class对象的所有声明构造函数
Constructor<?>[] publicConstructors = class1.getConstructors();//获取class对象public构造函数
try {
Constructor<?> constructor = class1.getDeclaredConstructor(new Class[]{String.class});//获取指定声明构造函数
Constructor publicConstructor = class1.getConstructor(new Class[]{});//获取指定声明的public构造函数
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
Annotation[] annotations = class1.getAnnotations();//获取class对象的所有注解
Annotation annotation = class1.getAnnotation(Deprecated.class);//获取class对象指定注解
Type genericSuperclass = class1.getGenericSuperclass();//获取class对象的直接超类的 Type
Type[] interfaceTypes = class1.getGenericInterfaces();//获取class对象的所有接口的type集合
四，简单示例
Rebot类
public class Rebot {
private String name;
public void sayHi(String helloSentence){
System.out.println(helloSentence+""+name);
}
private String throwHello(String tag){
return "hello"+tag;
}
}
ReflectSample
public class ReflectSample {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
Class rc=Class.forName("javabasic.reflect.Rebot");
Rebot r=(Rebot)rc.newInstance();
System.out.println("Class name is"+rc.getName());
Method getHello=rc.getDeclaredMethod("throwHello",String.class);//不能获取继承的和实现的接口的方法
getHello.setAccessible(true);
Object str=getHello.invoke(r, "bob");
System.out.println("getHello result is "+str);
Method sayHi=rc.getMethod("sayHi",String.class);//获取继承的方法，实现的共有方法
sayHi.invoke(r,"Welcome");
Field name=rc.getDeclaredField("name");
name.setAccessible(true);
name.set(r,"mimi");
sayHi.invoke(r,"Welcome");
}
}
五，Java反射机制使用场景
1 import java.io.*;
2 import java.util.Properties;
3
4 /*问题描述：存在一个主板--已经定义好，不想修改其代码，还想在主板上面增加一些其他功能？
5 *问题解决方法：主板在定义的时候对外提供一个接口，让其他设备实现该接口，并把这些设备的
6 *信息写在配置文件里面。主板定义的时候读配置文件的信息，动态的获取其他设备的信息，并使用
7 *其他的功能。这样就完全不用修改主板的代码。极大的提高了程序的扩展性。
8 *所以通过反射就可以动态获取扩展类的对象，只需要修改具体配置文件的内容即可。
9 *
10 *反射：动态的获取类的信息。其实是通过类名,加载类，获取类的Class对象，进而做其他的操作。
11 * 使用反射的最大的好处是程序的扩展性大大的提高。
12 *反射涉及的类：Class，java.lang.reflect包里面的Method,Field,Constructor支持
13 * */
14 public class UseReflection {
15
16 public static void main(String[] args) throws IOException, ClassNotFoundException, Exception {
17 MainBoard mb = new MainBoard();
18 mb.run();
19
20 //把添加的设备写在配置文件中，并将该文件封装为对象
21 File f = new File("pci.properties");
22 //将配置文件关联到流
23 FileInputStream fis = new FileInputStream(f);
24 //创建Properties对象
25 Properties prop = new Properties();
26 //将流中的信息加载到prop里面
27 prop.load(fis);
28 //遍历从流中得到的信息
29 for(int i = 0; i < prop.size();i++){
30 String name = prop.getProperty("pci"+(i+1));
31 Class clazz = Class.forName(name);
32 PCI p = (PCI)clazz.newInstance();
33 mb.usePCI(p);
34 }
35
36
37 }
38
39 }
40
41 class MainBoard{
42 public void run(){
43 System.out.println("mainboard run-------");
44 }
45
46 public void usePCI(PCI p){
47 if(p != null){
48 p.open();
49 p.close();
50 }
51 }
52 }
public interface PCI {
public void open();
public void close();
}
class SoundBoard implements PCI{
public SoundBoard() {
}
@Override
public void open() {
System.out.println("open sound");
}
@Override
public void close() {
System.out.println("close sound");
}
}
class WifiBoard implements PCI{
public WifiBoard() {
}
@Override
public void open() {
System.out.println("open wifi");
}
@Override
public void close() {
System.out.println("close wifi");
}
}
上面是一种模拟的反射机制的使用，真实使用反射机制的一个比较常见的例子是Tomcat–web服务器，Tomcat服务器的作用：就是处理浏览器的请求
和给予合适的应答，但是浏览器的请求类型通常不一样，为了提高服务器的扩展性，通常在Tomcat编写时就对外提供一个公共的接口–Servlet，要进行怎样的响应和处理请求，需要开发人员做的就是直接实现该接口，定义合适的处理方式，并将具体实现类信息写在配置文件中，Tomcat在操作的时候根据读取配置文件的内容，动态的获得合适的处理方式，处理浏览器的请求，开发者的编程难度也下降，直接面对的是接口和配置文件。想要修改具体的处理方式，直接
修改配置文件的内容即可。
