在学习Java的路上,相信你必定使用过各类各样的框架。所谓的框架就是一个半成品软件,已经对基础的代码进行了封装并提供相应的API。在框架的基础上进行软件开发,能够简化编码。学习使用框架并不须要了解反射,可是若是想要本身写一个框架,那么就须要对反射机制有很深刻的了解。java
在程序运行状态中,对于任意一个类或对象,都可以获取到这个类的全部属性和方法(包括私有属性和方法),这种动态获取信息以及动态调用对象方法的功能就称为反射机制。简单来说,经过反射,类对咱们是彻底透明的,想要获取任何东西均可以。web
在学习反射之前,咱们先来了解一下Java代码在计算机中所经历的三个阶段:数组
public class getClass { public static void main(String[] args) throws Exception { //方式一:Class.forName("全类名"); Class class1 = Class.forName("zzuli.edu.cn.Person"); //Person自定义实体类 System.out.println("class1 = " + class1); //方式二:类名.class Class class2 = Person.class; System.out.println("class2 = " + class2); //方式三:对象.getClass(); Person person = new Person(); Class class3 = person.getClass(); System.out.println("class3 = " + class3); //比较三个对象 System.out.println(class1 == class2); //true System.out.println(class1 == class3); //true } }
运行结果:
经过上述比较三个对象的结果能够得出一个结论:同一个字节码文件(*.class)在一次程序运行过程当中,只会被加载一次,不管经过哪种方式获取的Class对象都是同一个。安全
这里只写出一些经常使用的,具体能够参看jdk的帮助文档。框架
Field[] getFields() //获取全部public修饰的成员变量 Field getField(String name) //获取指定名称的public修饰的成员变量 Field[] getDeclaredFields() //获取全部的成员变量,不考虑修饰符 Field getDeclaredField(String name) //获取指定的成员变量,不考虑修饰符
Constructor<?>[] getConstructors() //获取全部public修饰的构造函数 Constructor<T> getConstructor(类<?>... parameterTypes) //获取指定的public修饰的构造函数 Constructor<?>[] getDeclaredConstructors() //获取全部的构造函数,不考虑修饰符 Constructor<T> getDeclaredConstructor(类<?>... parameterTypes) //获取指定的构造函数,不考虑修饰符
Method[] getMethods() //获取全部public修饰的成员方法 Method getMethod(String name, 类<?>... parameterTypes) //获取指定名称的public修饰的成员方法 Method[] getDeclaredMethods() //获取全部的成员方法,不考虑修饰符 Method getDeclaredMethod(String name, 类<?>... parameterTypes) //获取指定名称的成员方法,不考虑修饰符
String getName()
import lombok.Getter; import lombok.Setter; import lombok.ToString; @Setter @Getter @ToString public class Person { public String a; //最大范围public protected String b; //受保护类型 String c; //默认的访问权限 private String d; //私有类型 }
/** * 获取成员变量 * * Field[] getFields() * * Field getField(String name) * @throws Exception */ public class reflectDemo1{ public static void main(String[] args) throws Exception { //获取Person的Class对象 Class personClass = Person.class; //一、Field[] getFields()获取全部public修饰的成员变量 Field[] fields = personClass.getFields(); for(Field field : fields){ System.out.println(field); } System.out.println("============================="); //2.Field getField(String name) 获取指定名称的public修饰的成员变量 Field a = personClass.getField("a"); //获取成员变量a的值 [也只能获取公有的,获取私有的或者不存在的字符会抛出异常] Person p = new Person(); Object value = a.get(p); System.out.println("value = " + value);//由于在Person类中a没有赋值,因此为null //设置成员变量a的属性值 a.set(p,"张三"); System.out.println(p); } }
运行结果:
svg
/** * Field[] getDeclaredFields() * Field getDeclaredField(String name) * @throws Exception */ public class reflectDemo2 { public static void main(String[] args) throws Exception { //获取Person的Class对象 Class personClass = Person.class; //Field[] getDeclaredFields():获取全部的成员变量,不考虑修饰符 Field[] declaredFields = personClass.getDeclaredFields(); for(Field filed : declaredFields){ System.out.println(filed); } System.out.println("==================================="); //Field getDeclaredField(String name) //获取指定的成员变量,不考虑修饰符 Field d = personClass.getDeclaredField("d"); //private String d; Person p = new Person(); //Object value1 = d.get(p); //若是直接获取会抛出异常,由于对于私有变量虽然能会获取到,但不能直接set和get,必须忽略访问权限修饰符的安全检查后才能够 //System.out.println("value1 = " + value1); //忽略访问权限修饰符的安全检查,又称为暴力反射 d.setAccessible(true); Object value2 = d.get(p); System.out.println("value2 = " + value2); } }
运行结果
注意:若是没有忽略访问修饰符直接访问会抛出以下所示的异常
函数
建立对象:T newInstance(Object… initargs)
注意:若是使用空参数构造方法建立对象,操做能够简化:直接使用Class对象的newInstance方法。学习
import lombok.Getter; import lombok.Setter; import lombok.ToString; @Setter @Getter @ToString public class Person { private String name; private Integer age; //无参构造函数 public Person() { } //单个参数的构造函数,且为私有构造方法 private Person(String name){ } //有参构造函数 public Person(String name, Integer age) { this.name = name; this.age = age; } }
/** * 获取构造方法 * Constructor<?>[] getConstructors() * Constructor<T> getConstructor(类<?>... parameterTypes) */ public class reflectDemo3 { public static void main(String[] args) throws Exception { //获取Person的Class对象 Class personClass = Person.class; //Constructor<?>[] getConstructors() //获取全部public修饰的构造函数 Constructor[] constructors = personClass.getConstructors(); for(Constructor constructor : constructors){ System.out.println(constructor); } System.out.println("=========================================="); //获取无参构造函数 注意:Person类中必需要有无参的构造函数,否则抛出异常 Constructor constructor1 = personClass.getConstructor(); System.out.println("constructor1 = " + constructor1); //使用获取到的无参构造函数建立对象 Object person1 = constructor1.newInstance(); System.out.println("person1 = " + person1); System.out.println("=========================================="); //获取有参的构造函数 //public Person(String name, Integer age) 参数类型顺序要与构造函数内一致,且参数类型为字节码文件类型 Constructor constructor2 = personClass.getConstructor(String.class,Integer.class); System.out.println("constructor2 = " + constructor2); //使用获取到的有参构造函数建立对象 Object person2 = constructor2.newInstance("zhangsan", 22); //获取的是有参的构造方法,就必需要指定参数 System.out.println(person2); System.out.println("========================================="); //对于通常的无参构造函数,咱们都不会先获取无参构造器以后在进行初始化,而是直接调用Class类内的newInstance()方法 Object person3 = personClass.newInstance(); System.out.println("person3 = " + person3); } }
运行结果:
总结:若是使用无参构造方法建立对象,操做能够进行简化:直接使用Class对象的newInstance方法建立便可。测试
对于多出个Declared关键词的两个方法,与不带这个词的两个方法的对比,与以前3.2叙述的同样,getDeclaredConstructor方法能够获取到任何访问权限的构造器,而getConstructor方法只能获取public修饰的构造器,具体再也不测试。此外在构造器的对象内也有setAccessible(true)方法,把它设置成true就能够操做了。this
import lombok.Getter; import lombok.Setter; import lombok.ToString; @Setter @Getter @ToString public class Person { private String name; private Integer age; //无参构造函数 public Person() { } //有参构造函数 public Person(String name, Integer age) { this.name = name; this.age = age; } //无参方法 public void eat(){ System.out.println("eat..."); } //重载有参方法 public void eat(String food){ System.out.println("eat..."+food); } }
/** * 获取成员方法 * * Method[] getMethods() * * Method getMethod(String name, 类<?>... parameterTypes) */ public class reflectDemo4 { public static void main(String[] args) throws Exception { //获取Person的Class对象 Class personClass = Person.class; //获取指定名称的方法 Method eat_method1 = personClass.getMethod("eat"); //执行方法 Person person = new Person(); Object rtValue = eat_method1.invoke(person);//若是方法有返回值类型能够获取到,没有就为null //由于eat方法没有返回值,故输出null System.out.println("rtValue = " + rtValue); System.out.println("--------------------------------------------"); //获取有参的函数,有两个参数:第一个参数为方法名,第二个参数是获取方法的参数类型的字节码文件 Method eat_method2 = personClass.getMethod("eat", String.class); //执行方法 eat_method2.invoke(person,"苹果"); System.out.println("============================================"); //获取方法列表 Method[] methods = personClass.getMethods(); for(Method method : methods){ //注意:获取到的方法不只仅是Person类内本身的方法 System.out.println(method); //继承Object中的方法也会被获取到(固然前提是public修饰的) } } }
运行结果
咱们能够看出Person内的public方法都被打印出来了,此外Object中的public方法也都被打印出来了。
同以前的叙述同样,带有Declared关键字的方法这两个方法,能够获取到任意修饰符的方法。一样也提供了setAccessible(true)方法进行暴力反射。
综上所述:在反射面前没有公有私有,均可以经过暴力反射解决。
getName()方法获取的类名是全类名(带有路径)
public class getNameDemo { public static void main(String[] args) throws Exception { //获取Person的Class对象 Class personClass = Person.class; //获取全类名 String className = personClass.getName(); System.out.println(className); } }
运行结果
写一个"框架",在不改变该类的任何代码的前提下,能够帮咱们建立任意类的对象,而且执行其中的任意方法。
(1)配置文件
(2)反射机制
(1)将须要建立的对象的全类名和须要执行的方法定义在配置文件中
(2)在程序中加载读取配置文件
(3)使用反射技术把类文件加载进内存
(4)建立对象
(5)执行方法
(1)Person类
public class Person { //无参方法 public void eat(){ System.out.println("eat..."); } }
(2)Student类
public class Student { //无参方法 public void study(){ System.out.println("I am a Student"); } }
className = zzuli.edu.cn.Person methodName = eat
/** * 前提:不能改变该类的任何代码。能够建立任意类的对象,能够执行任意方法 * 即:拒绝硬编码 */ public class ReflectTest { public static void main(String[] args) throws Exception { //1.加载配置文件 //1.1建立Properties对象 Properties pro = new Properties(); //1.2加载配置文件 //1.2.1获取class目录下的配置文件(使用类加载器) ClassLoader classLoader = ReflectTest.class.getClassLoader(); InputStream inputStream = classLoader.getResourceAsStream("pro.properties"); pro.load(inputStream); //2.获取配置文件中定义的数据 String className = pro.getProperty("className"); String methodName = pro.getProperty("methodName"); //3.加载该类进内存 Class cls = Class.forName(className); //4.建立对象 Object obj = cls.newInstance(); //5.获取方法对象 Method method = cls.getMethod(methodName); //6.执行方法 method.invoke(obj); } }
//将配置文件内的信息修改成Student类及类内的study方法 className = zzuli.edu.cn.Student methodName = study
运行结果
优势:对于框架来讲,已经对基础的代码进行了封装并提供相应的API。在框架的基础上进行软件开发,能够简化编码。但若是咱们使用传统的new形式来实例化,那么当类更改时咱们就要修改Java代码,这是很繁琐的。修改Java代码之后咱们还要进行从新编译、测试、发布等一系列的操做。而若是咱们仅仅只是修改配置文件,而不须要修改Java代码就简单的多。此外使用反射还能达到解耦的效果,若是咱们使用的是new这种形式进行对象的实例化。此时若是在项目的某一个小模块中咱们的一个实例类丢失了,那么在编译期间就会报错,会致使整个项目没法启动。而对于反射建立对象Class.forName(“全类名”)这种形式,咱们在编译期须要的仅仅只是一个字符串(全类名),在编译期不会报错,这样其余的模块就能够正常的运行,而不会由于一个模块的问题致使整个项目崩溃。
若是你认真看完了这篇文章,反射就应该掌握的差很少了,在接下来的几篇文章中,我会使用反射来实现热加载、反编译,而且使用反射来简单封装一个Spring框架和MyBatis框架。若是想要对反射机制有更深刻的了解,能够看后续的文章。