黑马程序员—— 反射总结

------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.ClassNotFoundExceptionClass 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获取对应的valueprivate 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");//测试：遍历strListfor(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;}@Overridepublic 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{@Overridepublic void add() {System.out.println("添加一条Teacher信息......");}@Overridepublic void delete() {System.out.println("删除一条Teacher信息......");}}</span>