黑马程序员—— 反射总结

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

反射

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法;对于任意一个对象，都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

JAVA反射(放射)机制:"程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言"。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。但是JAVA有着一个非常突出的动态相关机制:Reflection，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造(但不包括methods定义)，并生成其对象实体、或对其fields设值、或唤起其methods。

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

有时候我们说某个语言具有很强的动态性，有时候我们会区分动态和静态的不同技术与作法。我们朗朗上口动态绑定（dynamic binding）、动态链接（dynamic linking）、动态加载（dynamic loading）等。然而“动态”一词其实没有绝对而普遍适用的严格定义，有时候甚至像对象导向当初被导入编程领域一样，一人一把号，各吹各的调。

一般而言，开发者社群说到动态语言，大致认同的一个定义是：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。

尽管在这样的定义与分类下Java不是动态语言，它却有着一个非常突出的动态相关机制：Reflection。这个字的意思是“反射、映象、倒影”，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。这种“看透class”的能力（the ability of the program to examine itself）被称为introspection（内省、内观、反省）。Reflection和introspection是常被并提的两个术语。

Java如何能够做出上述的动态特性呢？这是一个深远话题，本文对此只简单介绍一些概念。整个篇幅最主要还是介绍Reflection APIs，也就是让读者知道如何探索class的结构、如何对某个“运行时才获知名称的class”生成一份实体、为其fields设值、调用其methods。本文将谈到java.lang.Class，以及java.lang.reflect中的Method、Field、Constructor等等classes。

众所周知Java有个Object class，是所有Java classes的继承根源，其内声明了数个应该在所有Java class中被改写的methods：hashCode()、equals()、clone()、toString()、getClass()等。其中getClass()返回一个Class object。

Class class十分特殊。它和一般classes一样继承自Object，其实体用以表达Java程序运行时的classes和interfaces，也用来表达enum、array、primitive Java types（boolean, byte, char, short, int, long, float, double）以及关键词void。当一个class被加载，或当加载器（class loader）的defineClass()被JVM调用，JVM 便自动产生一个Class object。如果您想借由“修改Java标准库源码”来观察Class object的实际生成时机（例如在Class的constructor内添加一个println()），这样是行不通的！因为Class并没有public constructor（见图1）。本文最后我会拨一小块篇幅顺带谈谈Java标准库源码的改动办法。

Class是Reflection故事起源。针对任何您想探勘的class，唯有先为它产生一个Class object，接下来才能经由后者唤起为数十多个的Reflection APIs。这些APIs将在稍后的探险活动中一一亮相。

#001 public final

#002 class Class<T> implements Serializable,

#003 java.lang.reflect.GenericDeclaration,

#004 java.lang.reflect.Type,

#005 java.lang.reflect.AnnotatedElement {

#006 private Class() {}

#007 public String toString() {

#008 return ( isInterface() ? "interface " :

#009 (isPrimitive() ? "" : "class "))

#010 + getName();

#011 }

Class class片段。注意它的private Class() {}，意指不允许任何人经由编程方式产生Class object。是的，其object 只能由JVM 产生。
获取Class对象的三种方式；

1.Object类中的：getClass()：此方法不是静态的，必须对象的引用调用；
2.class属性：任何的数据类型(包括基本数据类型)都有一个静态的class属性，它可以获取这个类的Class对象；
3.Class类中有个静态方法：
Class forName(String className);className要是全名限定的类名(带包名的类名)
 常用：第3种；

class Student{
public static Class class = new Class();

<span style="font-size:18px;">public class Demo {
	public static void main(String[] args) throws ClassNotFoundException {
		Student stu = new Student();//会产生：Student对象空间，Class对象空间
		//方式一：获取Class对象
		Class stuClass1 = stu.getClass();
		//方式二：静态的class属性
		Class stuClass2 = Student.class;
	//	Class intClass = int.class;//基本数据类型也有
		System.out.println("stuClass1 == stuClass2 : " + (stuClass1 == stuClass2));
		
		//方式三：Class的静态方法forName()
	//	Class stuClass3 = Class.forName("Student");//运行时异常：java.lang.ClassNotFoundException
		Class stuClass3 = Class.forName("cn.we.demo01_获取Class对象的三种方式.Student");
		System.out.println("stuClass1 == stuClass3 : " + (stuClass1 == stuClass3));
		
	}
}</span>

通过反射获取无参_有参构造方法并使用：

Class:
//---批量的；
Constructor[] getConstructors():获取所有的"公有"构造方法；
Constructor[] getDeclaredConstructors():：获取所有的(包括私有的)构造方法；

每一个Constructor内部都包含了"一个构造方法"的详细信息；

//---获取某个Constructor对象
public Constructor getConstructor(Class ... parameterTypes):
获取某个公有的构造方法
public Constructor getDeclaredConstructor(Class<?>... parameterTypes)：
获取某个构造方法(包括私有的)

//Constructor的成员方法：
public Object newInstance(Object... initargs)：创建这个Class类所表示的类的一个对象；

<span style="font-size:18px;">public class Demo {
	public static void main(String[] args) throws Exception{
		//*********获取Class对象************//
		Class stuClass = Class.forName("cn.we.demo02_通过反射获取无参_有参构造方法并使用.Student");
		//*********获取所有的"公有的"构造方法*********
		Constructor[] conArray = stuClass.getConstructors();
		//遍历
		System.out.println("**********所有   公共的       构造方法***********");
		for(Constructor c : conArray){
			System.out.println(c);
		}
		
		//********获取所有的构造方法***********//
		System.out.println("**********所有构造方法(包括私有)***********");
		conArray = stuClass.getDeclaredConstructors();
		for(Constructor c : conArray){
			System.out.println(c);
		}
		/*
		 * class Class{
		 * 		public Constructor getConstructor(){
		 * 			return new Constructor();
		 * 		}
		 * }
		 * class Constructor{
		 * }
		 */
		System.out.println("**********获取单个，公有，无参的构造方法，并调用***********");
		Constructor con = stuClass.getConstructor();//获取无参的
		Object obj = con.newInstance();
		System.out.println("obj = " + obj);
		System.out.println("**********获取单个，公有，带参的构造方法，并调用***********");
		con = stuClass.getConstructor(int.class);//获取int参数的公有构造方法
		con.newInstance(20);//20就是"实参"，使用这个实参去调用此构造方法
		
		System.out.println("**********获取私有，带参的构造方法，并调用***********");
		con = stuClass.getDeclaredConstructor(String.class,boolean.class);
		con.setAccessible(true);//如果是私有的，设置暴力访问
		con.newInstance("刘德华",false);
		
		
		
	}
}</span>

<span style="font-size:18px;">public class Student {
	//************构造方法************//
	//公有无参
	public Student(){
		System.out.println("Student类的公有，无参的构造方法被执行......");
	}
	//公有带参
	public Student(int n){
		System.out.println("Student类的公有，带参的构造方法被执行，n = " + n);
	}
	
	//受保护的
	protected Student(String s){
		System.out.println("Student类的受保护的构造方法被执行，s = " + s);
	}
	
	//默认的
	Student(char c){
		System.out.println("Student类的默认的构造方法被执行， c = " + c);
	}
	//私有的
	private Student(String s ,boolean b){
		System.out.println("Student类的私有的构造方法被执行，s = " + s + ",b = " + b);
	}
}</span>

通过反射获取成员变量并使用
Class类：

   ----批量的：
Field[] getFields():获取所有公有的成员变量
Field[] getDeclaredFields()：获取所有成员变量(包括私有)
   ----单个的：
    Field getField():获取单个，公有的成员变量
    Field getDeclaredField():获取单个的成员变量，包括私有的
   ----为成员变量赋值：
    Filed --> set(Object obj,Object value)

<span style="font-size:18px;">public class Demo {
	public static void main(String[] args) throws Exception {
		//1.获取Class对象
		Class stuClass = Class.forName("cn.we.demo03_通过反射获取成员变量并使用.Student");
		System.out.println("*********获取所有公有的成员变量************");
		Field[] fieldArray = stuClass.getFields();
		for(Field f : fieldArray){
			System.out.println(f);
		}
		System.out.println("*********获取所有的成员变量(包括私有的)************");
		fieldArray = stuClass.getDeclaredFields();
		for(Field f : fieldArray){
			System.out.println(f);
		}
		System.out.println("*********获取单个公有的成员变量，并赋值************");
		Field f = stuClass.getField("name");
		//赋值前，一定要确保堆中有"对象空间"，所有要先创建一个对象
		Object obj = stuClass.getConstructor().newInstance();//调用公有无参的构造方法
		f.set(obj, "刘德华");
		
		System.out.println("*********获取私有的成员变量，并赋值*********************");
		f = stuClass.getDeclaredField("address");
		f.setAccessible(true);//设置暴力访问
		f.set(obj, "北京市");
		//验证
		Student stu = (Student)obj;
		System.out.println("Student的 name = " + stu.name + " address = " + stu.getAddress());
		
		
		
	}
}
</span>

获取成员方法：

Class类的：
 ----批量的：
Method[] getMethods():获取所有公有的成员方法；
Method[] getDeclaredMethods():获取所有的成员方法包括私有的。
----单个：
Method getMethod():获取单个公有的成员方法；
Method getDeclaredMethod():获取单个成员方法，包括私有的；

----调用方法：
Method --> public Object invoke(Object obj,Object... args)

<span style="font-size:18px;">public class Demo {
	public static void main(String[] args) throws Exception{
		//1.获取Class对象
		Class stuClass = Class.forName("cn.we.demo04_通过反射获取成员方法并使用.Student");
		System.out.println("*****************************获取所有公有的成员方法*****************************");
		Method[] methodArray = stuClass.getMethods();//包含了父类的公有的
		for(Method m : methodArray){
			System.out.println(m);
		}
		
		System.out.println("*****************************获取所有的成员方法(包括私有的)*****************************");
		methodArray = stuClass.getDeclaredMethods();//不包含继承的；
		for(Method m : methodArray){
			System.out.println(m);
		}
		System.out.println("*****************************获取单个公有的，无参的并调用*****************************");
		Method m = stuClass.getMethod("show1");
		//实例化一个对象
		Object obj = stuClass.newInstance();
		m.invoke(obj);
		
		System.out.println("*****************************获取单个公有的，带参的，带返回值并调用*****************************");
		
		m = stuClass.getMethod("show2", String.class,int.class);
		Object result = m.invoke(obj, "张三",20);//传递实参，并接受返回值；
		System.out.println("返回值为：" + result);
		
		System.out.println("*****************************获取单个私有的，带参的并调用*****************************");
		m = stuClass.getDeclaredMethod("show5", int.class);
		m.setAccessible(true);//暴力访问
		m.invoke(obj, 20);
		
	}
}</span>

<span style="font-size:18px;">public class Student {
	public void show1(){
		System.out.println("公有的，无参的show1()方法......");
	}
	public int show2(String s,int n){
		System.out.println("公有 show2()方法：s = " + s + " , n = " + n );
		return 1000;
	}
	
	protected void show3(int n){
		System.out.println("受保护的show3()方法：n = " + n);
	}
	
	void show4(int n){
		System.out.println("默认的show4()方法：n = " + n);
	}
	private void show5(int n){
		System.out.println("私有的show5()方法：n = " + n);
	}
}</span>

通过反射运行陪着文件内容

<span style="font-size:18px;">public class Demo {
	public static void main(String[] args) throws Exception{
		/*Student stu = new Student();
		stu.show();*/
		
		//后期升级，Student类需要改为：Teacher，
		//		 show()方法需要改为：fun()方法；
		//1.新建Teacher类，并添加fun()方法；
		//2.此Demo类中的代码需要修改；
		
		//为了在更新程序时，避免修改其它已有的源码，可以使用："反射机制"
	//	Class stuClass = Class.forName("cn.we.demo05_通过反射运行配置文件内容.Student");
		//1.建立配置文件；
		//2.在配置文件中，建立：键值对；
		//3.此处，使用"键名"；获取相应的"值"
		Class stuClass = Class.forName(getValue("className"));//"cn.we.demo05_通过反射运行配置文件内容.Student"
		//获取Method对象
	//	Method m = stuClass.getMethod("show");
		Method m = stuClass.getMethod(getValue("methodName"));//show
		//调用show()方法
		m.invoke(stuClass.newInstance());
		
		
	}
	//此方法，从配置文件中，根据某个key获取对应的value
	private static String getValue(String key) throws IOException{
		FileReader in = new FileReader("my.properties");
		Properties pro = new Properties();
		//读取配置文件
		pro.load(in);
		in.close();
		
		return pro.getProperty(key);
		
	}
}</span>

通过反射越过泛型检查 
 1.有一个具有String泛型的ArrayList，问：怎么可以向集合中添加一个数字：

<span style="font-size:18px;">public class Demo {
	public static void main(String[] args) throws Exception{
		ArrayList<String> strList = new ArrayList<>();
	//	strList.add(20);
		
		//泛型，只在"编译期",生成class后，泛型就没有了
		//1.获取ArrayList的Class对象
		Class listClass = strList.getClass();
		//2.获取add()方法
		Method addMethod = listClass.getMethod("add", Object.class);
		//3.调用Method对象的方法，执行add()方法
		addMethod.invoke(strList, 20);
		addMethod.invoke(strList, 30);
		addMethod.invoke(strList, "abc");
		
		//测试：遍历strList
		for(Object obj : strList){
			System.out.println(obj);
		}
		
	}
}</span>

代理模式

1.在不改变原类的基础上，可以为原类增加一些其他功能；
2.当有代理后，我们可以直接面对：代理类

有一个类，访问数据库中的Student表：
class StudentService{
public void add(){
//添加一条Student信息；
}
public void delete(){
//删除数据库中一条Student信息；
}
}

现在要求，在不更改原类的基础上，在调用这两个方法时，都要做两个操作：
1.在调用此方法之前：检查：是否有权限；
  2.在调用此方法之后：写日志；
 
 建立一个"代理类"，后期使用，直接使用此代理类；
 
缺陷：如果其它类，也需要加这两个方法，也得添加代理类，这样会导致类太多；

<span style="font-size:18px;">public class Demo {
	public static void main(String[] args) {
		/*StudentService stuService = new StudentService();
		stuService.add();
		stuService.delete();*/
		
		//直接面对代理
		StudentServiceProxy proxy = new StudentServiceProxy();
		proxy.add();
		proxy.delete();
	}
}</span>

<span style="font-size:18px;">public class StudentService {
	public void add(){
		System.out.println("添加一条数据......");
	}
	public void delete(){
		System.out.println("删除一条数据......");
	}
}</span>

<span style="font-size:18px;">public class StudentServiceProxy {
	private StudentService stuService = new StudentService();
	
	public void add(){
		check();
		stuService.add();
		log();
	}
	public void delete(){
		check();
		stuService.delete();
		log();
	}
	
	private void check(){
		System.out.println("先期进行权限检查......");
	}
	private void log(){
		System.out.println("后期进行记录日志.....");
	}
	
	
}</span>

之前的代理模式有个缺陷，如果其它类也需要增加那两个操作，也必须要增加一个代理类，
这样使用起来比较麻烦；

Java中提供了"动态代理"：不需要"代理类"，动态代理机制会为要代理的类，自动产生一个代理对象；
Java中的动态代理是基于"接口"的，需要代理的类，一定要是某个接口的实现类；

步骤：
1.定义一个类，实现：InvocationHandler
 2.在使用时，使用Proxy：newProxyInstance()方法产生代理对象；

<span style="font-size:18px;">public class Demo {
	public static void main(String[] args) {
		IService stuService = (IService)Proxy.newProxyInstance(
												StudentService.class.getClassLoader(), 
												StudentService.class.getInterfaces(), 
												new MyInvocationHandler(new StudentService())
				);
		
		
		stuService.add();
		stuService.delete();
		
		IService teaService = (IService)Proxy.newProxyInstance(TeacherService.class.getClassLoader(), 
																TeacherService.class.getInterfaces(), 
																new MyInvocationHandler(new TeacherService()));
		teaService.add();
		teaService.delete();
																
		
	}
}</span>

<span style="font-size:18px;">public interface IService {
	public void add();
	public void delete();
}</span>

<span style="font-size:18px;">public class MyInvocationHandler implements InvocationHandler {
	//要代理的对象；
	private Object target;
	
	//通过构造方法赋值
	public MyInvocationHandler(Object obj){
		this.target = obj;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		this.check();
		//调用应该调用的方法；
		Object result = method.invoke(this.target, args);
		this.log();
		//返回方法调用的结果
		return result;
	}
	
	//为代理对象额外添加的操作
	private void check(){
		System.out.println("先期进行权限检查......");
	}
	private void log(){
		System.out.println("后期进行记录日志.....");
	}

}</span>

<span style="font-size:18px;">public class StudentService implements IService{
	public void add(){
		System.out.println("添加一条数据......");
	}
	public void delete(){
		System.out.println("删除一条数据......");
	}
	
}</span>

<span style="font-size:18px;">public class TeacherService implements IService{

	@Override
	public void add() {
		System.out.println("添加一条Teacher信息......");
	}

	@Override
	public void delete() {
		System.out.println("删除一条Teacher信息......");
	}
	
}</span>