黑马程序员——反射

------- android培训、java培训、iOS培训、.Net培训期待与您交流！ ----------

类的加载

当程序要使用某个类时如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。

类初始化时机

创建类的实例

访问类的静态变量，或者为静态变量赋值

调用类的静态方法

使用反射方式来强制创建某个类或接口对应的java.lang.Class对象

初始化某个类的子类

直接使用java.exe命令来运行某个主类

类加载器

负责将.class文件加载到内存中，并为之生成对应的Class对象

虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行

类加载器的组成

Bootstrap ClassLoader根类加载器、Extension ClassLoader扩展类加载器、System ClassLoader系统类加载器

反射

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

要想解剖一个类，必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法，所以先要获取到每一个字节码文件对应的Class类型的对象

就是通过class文件对象，去使用该文件中的成员变量、构造方法、成员方法

要想这样使用，首先必须得到class文件对象，其实也就是得到Class类的对象

Class类：

成员变量 Field

构造方法 Constructor

成员方法 Method

获取class文件对象的方式：

一、Object类的getClass()方法

Person p1=new Person();

Class c1=p1.getClass();

二、数据类型的静态属性class

Class c2=Person.class;

三、Class类中的静态方法 ：public static Class forName(String className)

Class c3=Class.forName("Person");

注：要写类名的全路径（带包名的）

开发时用第三种，因为第三种是一个字符串，而不是一个具体的类名，这样我们就可以把这样的字符串配置到配置文件中

以下都以Person类为例：

class Person{private String name;int age;public String address; public Person(){}Person(String name,int age){this.name=name;this.age=age;}public Person(String name,int age,String address){this.name=name;this.age=age;this.address=address;}public void show(){System.out.println("show");}public void method(String s){System.out.println("method"+s);}public String getString(String s,int i){return s+"---"+i;}private void function(){System.out.println("function");}public String toString(){return "Person [name="+name+",age="+age+",address="+address+"]";}}

通过反射获取构造方法并使用

public Constructor[] getConstructors():获取所有公共构造方法

public Constructor[] getDeclaredConstructors():所有构造方法

public Constructor getConstructor(Class... parameterTypes):获取单个构造方法

...表示可传参数也可不传

参数表示的是：你要获取的构造方法的构造参数个数及数据类型的class字节码文件对象

public T newInstance(Object... initargs)

使用此Constructor对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例

public Constructor getConstructor(Class... parameterTypes):获取带参构造方法对象

暴力访问

con.setAccessible(true);//值为true则指示反射的对象在使用时应该取消JAVA语言访问检查

 

import java.lang.reflect.Constructor;class ReflectDemo {public static void main(String[] args) throws Exception{//获取字节码文件对象Class c=Class.forName("Person");//Constructor[] cons=c.getConstructors();//Constructor[] cons=c.getDeclaredConstructors();//for(Constructor con : cons)//{//System.out.println(con);//}Constructor con=c.getConstructor();//返回的是构造方法对象Object obj=con.newInstance();System.out.println(obj);//底层调用toString方法}}

/*需求：<strong>通过反射去获取该构造方法并使用</strong>：public Person(String name,int age,String address)*/import java.lang.reflect.Constructor;class  ReflectDemo{public static void main(String[] args) throws Exception{//获取字节码文件对象Class c=Class.forName("Person");Constructor con=c.getConstructor(String.class,int.class,String.class);Object obj=con.newInstance("张三",29,"北京");System.out.println(obj);}}

/*需求：<strong>通过反射获取私有构造方法并使用</strong>：private Person(String name){}*/import java.lang.reflect.Constructor;class  ReflectDemo{public static void main(String[] args) throws Exception{//获取字节码文件对象Class c=Class.forName("Person");//获取私有构造方法对象//会报异常：NoSuchMethodException  没有这个方法异常//原因是一开始我们使用的方法只能获取公共的//Constructor con=c.getConstructor(String.class);//用该私有构造方法创建对象//也会报异常：IllegalAccessException 非法的访问异常Constructor con=c.getDeclaredConstructor(String.class);//暴力访问con.setAccessible(true);//通过私有构造方法对象创建对象Object obj=con.newInstance("张三");System.out.println(obj);}}

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

获取所有成员：getFields 、getDeclaredFields

获取单个成员：getField 、getDeclaredField

修改成员变量的值：set(Object obj,Object value)

将指定对象变量上此Field对象表示的字段设置为指定的新值

 

import java.lang.reflect.Constructor;import java.lang.reflect.Field;class ReflectDemo {public static void main(String[] args) throws Exception{//获取字节码文件对象Class c=Class.forName("Person");//获取公共成员变量//Field[] fields=c.getFields();//获取所有成员变量//Field[] fields=c.getDeclaredFields();//for(Field field : fields)//{//System.out.println(field);//}//通过无参构造方法创建对象Constructor con=c.getConstructor();Object obj=con.newInstance();System.out.println(obj);//获取单个的成员变量：获取address并对其赋值Field addressField=c.getField("address");//public void set(Object obj,Object value);//将指定对象变量上此Field对象表示的字段设置为指定的新值addressField.set(obj,"北京");//给obj对象的addressField字段设置值为“北京”System.out.println(obj);//获取name（私有）并对其赋值Field nameField=c.getDeclaredField("name");nameField.setAccessible(true);//暴力访问nameField.set(obj,"张三");System.out.println(obj);//获取age并对其赋值（不管私不私有，这样写都能访问）Field ageField=c.getDeclaredField("age");ageField.setAccessible(true);//暴力访问ageField.set(obj,27);System.out.println(obj);}}

通过反射获取成员方法并使用

获取所有方法：getMethods 、getDeclaredMethods

获取单个方法：getMethod 、getDeclaredMethod

暴力访问：method.setAccessible(true);

 

import java.lang.reflect.Method;import java.lang.reflect.Constructor;class  ReflectDemo{public static void main(String[] args) throws Exception{//获取字节码文件对象Class c=Class.forName("Person");/*//获取公共成员方法  <strong>特殊之处</strong>：获取自己的包括父亲的公共方法//Method[] methods=c.getMethods();//获取所有成员方法 <strong> 特殊之处</strong>：这里只获取自己的所有方法，不包括父亲的Method[] methods=c.getDeclaredMethods();for(Method method :methods){System.out.println(method);}*///通过无参构造方法创建对象Constructor con=c.getConstructor();Object obj=con.newInstance();//获取单个方法并使用：public void show()//public Method getMethod(String name,class... parameterTypes)//第一个参数表示的是方法名，第二个参数表示的是方法的参数的class类型Method m1=c.getMethod("show");//public Object invoke(Object obj,Object...args)//返回值是Object接收，第一个参数表示对象是谁，第二个参数表示调用该方法的实际参数m1.invoke(obj);//调用obj对象的m1方法（Person对象的show方法）}}

 

import java.lang.reflect.Method;import java.lang.reflect.Constructor;class ReflectDemo {public static void main(String[] args) throws Exception{//获取字节码文件对象Class c=Class.forName("Person");//通过无参构造方法创建对象Constructor con=c.getConstructor();Object obj=con.newInstance();//需求：获取方法：public void method(String s)//public Method getMethod(String name,class... parameterTypes)//第一个参数表示的是方法名，第二个参数表示的是方法的参数的class类型Method m1=c.getMethod("method",String.class);//public Object invoke(Object obj,Object...args)//返回值是Object接收，第一个参数表示对象是谁，第二个参数表示调用该方法的实际参数m1.invoke(obj,"hello");//需求：获取方法：public String getString(String s,int i)Method m2=c.getMethod("getString",String.class,int.class);Object objString=m2.invoke(obj,"hello",100);System.out.println(objString);}}

动态代理

代理：本来应该自己做的事情，却请了别人来做，被请的人就是代理对象

动态代理：在程序运行过程中产生的这个对象，动态代理其实就是通过反射来生成一个代理

在JAVA中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理，更强大的代理cglib

Proxy类中的方法创建动态代理类对象

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

最终会调用InvocationHandler的方法

InocationHandler

Object invoke(Object proxy,Method method,Object[] args)

 

import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;class MyInvocationHandler implements InvocationHandler{private Object target;//目标对象 MyInvocationHandler(Object target){this.target=target;}public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{System.out.println("权限校验");Object result=method.invoke(target,args);System.out.println("日志记录");return result;//返回的是代理对象}}

import java.lang.reflect.Proxy;class Test {public static void main(String[] args) {//我们要创建一个动态代理对象//Proxy类中有一个方法可以创建动态代理对象//public static Object newProxyInstance(ClassLoader loader,Class[] interfaces,//InvocationHandler h)//返回值Object返回的其实就是动态代理对象//我准备对ud对象做一个代理对象MyInvocationHandler handler=new MyInvocationHandler(ud);//想让谁当代理对象就传谁UserDao proxy=(UserDao)Proxy.newProxyInstance(ud.getClass().getClassLoader(),ud.getClass().getInterfaces(),handler);proxy.add();proxy.delete();proxy.update();proxy.find();System.out.println("---------");StudentDao sd=new StudentDaoImpl();MyInvocationHandler handler2=new MyInvocationHandler(sd);//想让谁当代理对象就传谁StudentDao proxy2=(StudentDao)Proxy.newProxyInstance(sd.getClass().getClassLoader(),sd.getClass().getInterfaces(),handler2);proxy2.login();proxy2.regist();}}