反射
什么是反射
JAVA 反射机制是在运行状态中，对于任何一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性。
使用反射，可以在运行时对类 Class、构造方法 Constructor、普通方法 Method、字段 Filed 进行操作。
Class 对象
Class 对象，是对 class 文件（字节码文件）的描述对象。
获得 Class 对象
已知类的完整路径名（字符串）：Class.forName(...);
已知类型 : String.class 确定参数列表；
已知对象 ：obj.getClass();
常用方法：使用默认构造方法创建实例：newInstance();
Constructor 对象
Constructor 对象，是构造方法的描述对象。
获得构造方法
公共的构造方法：Constructor<T> getConstructor(Class<?>...parameter Types),可变参数用于确定实际参数列表 ；
已经声明的构造方法：Constructor<T> getDeclaredConstructor(Class<?>...parameterTypes),获得私有的构造；
实例化对象实例
newInstance(Object...initargs),可变参数用于确定实际参数列表
Method 对象
Method 对象，是普通方法的描述对象。
获得方法：
获得公共方法：Method getMethod(String name,Class<?>...parameterTypes)，通过方法 name 获得方法，可变参数为方法的形式参数表；
获得声明方法：Method getDeclaredMethod(String name, Class<?>...parameterTypes) 方法操作；
执行指定方法：Object invoke(Object obj, Object ... args) 执行指定对象 obj 指定方法，可变参数为方法的实际参数列表；
Filed 对象
Filed 对象，是字段的描述对象
获得方法：
所有字段：Filed getFiled(String name),通过字段名称；
声明字段：Filed getDeclaredFiled(String name)
操作：
获取内容：Object get(Object obj)
设置内容：void set(Object obj, Object value),确定实例对象；
获取Class对象的方式一：
通过对象具备的getClass方法(源于Object类的方法)。有点不方便，需要用到该类，并创建该类的对象，再调用getClass方法完成。
Person p = new Person();//创建Peron对象
Class clazz = p.getClass();//通过object继承来的方法(getClass)获取Person对应的字节码文件对象
获取Class对象的方式二：
每一个类型都具备一个class静态属性，通过该属性即可获取该类的字节码文件对象。比第一种简单了一些，仅用一个静态属性就搞定了。但是，还是有一点不方便，还必须要使用到该类。
Class clazz = Person.class;
获取Class对象方式三：
* 去找找Class类中是否有提供获取的方法呢？
* 找到了，static Class forName(className);
* 相对方便的多，不需要直接使用具体的类，只要知道该类的名字即可。
* 而名字完成可以作为参数进行传递 ,这样就可以提高扩展性。
* 所以为了动态获取一个类，第三种方式最为常用。
Class clazz = Class.forName("cn.itcast.bean.Person");//必须类全名
创建一个实例
创建Person对象的方式
以前：
1,先加载cn.itcast.bean.Person类进内存。
2,将该类封装成Class对象。
3,根据Class对象，用new操作符创建cn.itcast.bean.Person对象。
4,调用构造函数对该对象进行初始化。
cn.itcast.bean.Person p = new cn.itcast.bean.Person();
通过方式三：(此外还可以使用构造，构造可以指定参数---如String.class)
String className = "cn.itcast.bean.Person";
//1，根据名称获取其对应的字节码文件对象
1，通过forName()根据指定的类名称去查找对应的字节码文件，并加载进内存。
2，并将该字节码文件封装成了Class对象。
3，直接通过newIntstance方法，完成该对象的创建。
4，newInstance方法调用就是该类中的空参数构造函数完成对象的初始化。
Class clazz = Class.forName(className);
//2，通过Class的方法完成该指定类的对象创建。
Object object = clazz.newInstance();//该方法用的
清单1，获取字节码文件中的字段。
Class clazz = Class.forName("cn.itcast.bean.Person");
//获取该类中的指定字段。比如age
Field field = clazz.getDeclaredField("age");//clazz.getField("age"); //为了对该字段进行操作，必须要先有指定类的对象。
Object obj = clazz.newInstance();
//对私有访问，必须取消对其的访问控制检查，使用AccessibleObject父类中的setAccessible的方法
field.setAccessible(true);//暴力访问。建议大家尽量不要访问私有
field.set(obj, 789);
//获取该字段的值。
Object o = field.get(obj);
System.out.println(o);
备注：getDeclaredField：获取所有属性，包括私有。
getField:获取公开属性，包括从父类继承过来的，不包括非公开方法。
清单2，获取字节码文件中的方法。
//根据名称获取其对应的字节码文件对象
Class clazz = Class.forName("cn.itcast.bean.Person");
//调用字节码文件对象的方法getMethod获取class对象所表示的类的公共成员方法(指定方法)，参数为方法名和当前方法的参数，无需创建对象，它是静态方法
Method method = clazz.getMethod("staticShow", null);
//调用class对象所表示的类的公共成员方法，需要指定对象和方法中的参数列表
method.invoke(null, null);
………………………………………………………………………………………………………
Class clazz = Class.forName("cn.itcast.bean.Person");
//获取指定方法。
Method method = clazz.getMethod("publicShow", null);
//获取指定的类对象。
Object obj = clazz.newInstance();
method.invoke(obj, null);//对哪个对象调用方法，是参数组
好处：大大的提高了程序的扩展性。
模拟框架中使用的 XML 方式解析文件获得类的路径并通过反射调用方法
接口类
package com.ma.web.servlet1;
public interface MyServlet {
public void init();
public void service();
public void destory();
}实现类1
package com.ma.web.servlet1;
public class MyServlet1 implements MyServlet {
@Override
public void init() {
System.out.println("初始化 ！");
}
@Override
public void service() {
System.out.println("执行中 ！");
}
@Override
public void destory() {
System.out.println("销毁 ！");
}
}实现类 2
package com.ma.web.servlet1;
public class MyServlet2 implements MyServlet {
@Override
public void init() {
System.out.println("初始化 ！");
}
@Override
public void service() {
System.out.println("执行中 ！");
}
@Override
public void destory() {
System.out.println("销毁 ！");
}
}web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://www.example.org/web-app_2_5"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.example.org/web-app_2_5 web-app_2_5.xsd"
version="2.5">
<servlet>
<servlet-name>myServlet1</servlet-name>
<servlet-class>com.ma.web.servlet1.MyServlet1</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>myServlet1</servlet-name>
<url-pattern>/myServlet1</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>myServlet2</servlet-name>
<servlet-class>com.ma.web.servlet1.MyServlet2</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>myServlet2</servlet-name>
<url-pattern>/myServlet2</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file></welcome-file>
</welcome-file-list>
</web-app>测试类
package com.ma.web.servlet1;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.junit.Test;
public class TestMyServlet {
@Test
public void testMyServlet(){
try {
//1、创建解析器对象
SAXReader saxReader = new SAXReader();
//2、使用解析器对象加载 web.xml 文件，得到 document 对象
Document document =saxReader.read("src/com/ma/web/servlet1/web.xml");
//3、获取根元素节点
Element rootElement = document.getRootElement();
//4、根据元素名称获取子元素节点
Element servletElement = rootElement.element("servlet");
//5、根据元素名称获取 servlet-class 的文本
String servletClass = servletElement.element("servlet-class").getText();
try {
//6、通过类全名获取字节码文件
Class clazz = Class.forName(servletClass);
//7、创建实例对象
try {
MyServlet1 myServlet1 = (MyServlet1) clazz.newInstance();
//8、调用实例对象的方法
myServlet1.init();
myServlet1.service();
myServlet1.destory();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
} catch (DocumentException e) {
e.printStackTrace();
}
}
}运行结果
