反射
Reflection(反射)是被视为动态语言的关键,反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息,并能直接操作任意对象的内部属性及方法。
加载完类之后,在堆内存的方法区中就产生了一个Class类型的对象(一个类只有一个Class对象),这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子,透过这个镜子看到类的结构,所以,我们形象的称之为:反射。
Java不是动态语言,但Java可以称之为“准动态语言”。即Java有一定的动态性,我们可以利用反射机制、字节码操作获得类似动态语言的特性。Java的动态性让编程的时候更加灵活!
一、反射的动态性
1.解释
所谓动态性就是在运行时代码可以根据某些条件改变自身结构,在编译的时候不确定要new谁,不确定到底要造哪一个类的对象,只有在运行的时候根据选择才确定new的对象。
就比如浏览器访问后台时,用户可能是选择登录,也可能选择注册,在用户选择登录的时候,后台就会根据产生登录类的对象,从而进行登录的一些操作,注册则也是一样的。
2.举例
如下代码来体现反射的动态性,根据0-2的随机数去创建对象,你会发现对于其对象的创建并不是在编译的时候就创建好的,而是在运行的时候创建的。
package com.atguigu.java;
import org.junit.Test;
import java.util.Random;
public class NewInstanceTest {
//体会反射的动态性
@Test
public void test() throws Exception {
for (int i = 0; i < 100; i++) {
//创建随机数,根据得到的随机数去创建对象
int num = new Random().nextInt(3);
String classPath = "";
switch (num){
case 0:
classPath = "java.util.Date";
break;
case 1:
classPath = "java.lang.Object";
break;
case 2:
classPath = "com.atguigu.java.Person";
break;
}
//创建类的对象实例
Object obj = getInstance(classPath);
System.out.println(obj);
}
}
/*
创建一个指定类的对象
classPath:指定类的全类名
*/
public Object getInstance(String classPath) throws Exception{
Class clazz = Class.forName(classPath);
return clazz.newInstance();
}
}
运行结果:
二、理解Class类并获取Class的实例
1.Class类的介绍
在Object类中定义了以下的方法,此方法将被所有子类继承:
● public final Class getClass()
以上的方法返回值的类型是一个Class类,此类是Java反射的源头,实际上所谓反射从程序的运行结果来看也很好理解,即:可以通过对象反射求出类的名称。
对于每个类而言,JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个结构的有关信息(class/interface/enum/annotation/primitive type/void/[])。
从而反推,也就是说可以通过Class可以完整地得到一个类中的所有被加载的结构。
Class类是Reflection的根源,针对任何你想动态加载、运行的类,唯有先获得相应的Class对象。
2.作为举例的Javabean代码
下面为之后作为举例的Javabean代码:
package com.atguigu.java;
public class Person {
private String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person() {
}
private Person(String name){
this.name = name;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public void show(){
System.out.println("我是一个人");
}
private String showNation(String nation){
System.out.println("我的国籍是" + nation);
return nation;
}
private static void showDesc(){
System.out.println("我是一个静态方法");
}
}
3.获取Class类的实例(四种方法)
3.1 通过类的class属性获取
若已知具体的类,通过类的class属性获取,该方法最为安全可靠,程序性能最高
Class clazz1 = Person.class;
3.2 getClass()方法获取Class对象
已知某个类的实例,调用该实例的getClass()方法获取Class对象
Person p1 = new Person();
Class clazz2 = p1.getClass();
3.3 forName()获取Class对象
已知一个类的全类名,且该类在类路径下,可通过Class类的静态方法forName()获取,可能抛出ClassNotFoundException
//类的具体位置
Class clazz3 = Class.forName("com.atguigu.java.Person");
3.4 使用类的加载器:ClassLoader(了解)
ClassLoader classLoader = ReflectionTest.class.getClassLoader();
Class clazz4 = classLoader.loadClass("com.atguigu.java.Person");
4.Class类的地址值
你可能会寻思,用这四种方式所获得的Class对象所对应的是一个对象吗?答案是,是。
System.out.println(clazz1 == clazz2);
System.out.println(clazz1 == clazz3);
System.out.println(clazz1 == clazz4);
将通过四种方式所得到的4种Class类对象进行对比输出之后,发现,全都为 true。也就是说,四种方法所对得到的Class类对象为同一个。
5.关于java.lang.Class类的理解
1.类的加载过程。程序经过javac.exe命令以后,会生成一个或者多个字节码文件(.class结尾),接着我们使用java.exe 命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程成为类的加载。加载到内存中的类,我们就称为运行时类,此时运行时类,就作为Class的一个实例。
2.换句话说,Class的实例就对应着一个运行时类
3.加载到内存中的运行时类,会缓存一定的时间。在此时间之内,我们可以通过不同的方式来获取此运行时类。
三、类的加载与ClassLoader的理解
1.类的加载过程
当程序主动使用某个类时,如果该类还未被加载到内存中,则系统会通过如下三个步骤来对该类进行初始化。
1.1加载
将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区的运行时数据结构,然后生成一个代表这个类的java.lang.Class对象,作为方法区中类数据的访问入口(即引用地址)。所有需要访问和使用类数据只能通过这个Class对象。这个加载的过程需要类加载器参与。
1.2链接
将Java类的二进制代码合并到JVM的运行状态之中的过程。
验证:确保加载的类信息符合JVM规范,例如:以cafe开头,没有安全方面的问题
准备:正式为类变量(static)分配内存并设置类变量默认初始值的阶段,这些内存都将在方法区中进行分配。
解析:虚拟机常量池内的符号引用(常量名)替换为直接引用(地址)的过程。
1.3初始化
1.执行类构造器()方法的过程。类构造器()方法是由编译期自动收集类中
所有类变量的赋值动作和静态代码块中的语句合并产生的。(类构造器是构造类信息的,不是构造该类对象的构造器)。
2.当初始化一个类的时候,如果发现其父类还没有进行初始化,则需要先触发其父类的初始化。
3.虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。
2.举例
3.类加载器
类加载器作用是用来把类(class)装载进内存的。JVM 规范定义了如下类型的类的加载器。
4.类加载器的获取和用类加载器读取配置文件
public class ClassLoaderTest {
@Test
public void test1(){
//对于自定义类,使用系统类加载器进行加载
ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
System.out.println(classLoader);
//调用系统类加载的getParent():获取扩展类加载器
ClassLoader classLoader1 = classLoader.getParent();
System.out.println(classLoader1);
//调用扩展类加载的getParent():无法获取引导类加载器
//引导类加载器主要负责加载java的核心类库,无法加载自定义类的
ClassLoader classLoader2 = classLoader1.getParent();
System.out.println(classLoader2);
ClassLoader classLoader3 = String.class.getClassLoader();
System.out.println(classLoader3);
}
/*
Properties:用来读取配置文件
*/
@Test
public void test2() throws Exception {
Properties pros = new Properties();
//此时的文件默认在当前的module下
//读取配置文件的方式1:
// FileInputStream fis = new FileInputStream("jdbc.properties");
// pros.load(fis);
//读取配置文件方式2:使用ClassLoader
//配置文件默认识别为:当前module的src下
ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
InputStream is = classLoader.getResourceAsStream("jdbc1.properties");
pros.load(is);
String user = pros.getProperty("user");
String password = pros.getProperty("password");
System.out.println("user = " + user + ",password = " + password);
}
}
四、调用运行时类的指定结构
用反射去运行类中指定结构,不同于我们平时new一个对象去用点号调用类中的结构,后者受到了权限标识符的限制,比如私有的结构外部无法调用。
而反射只需要用 setAccessible(true)修改权限,外部就可以调用。
1.获取运行时类中的指定属性
@Test
public void testField() throws Exception {
Class<Person> clazz = Person.class;
//1.创建运行时类的对象
Person person = clazz.newInstance();
//2.getDeclaredField(String fieldName):获取运行时类中指定变量名的属性
Field name = clazz.getDeclaredField("name");
//3.保证当前属性是可访问的
name.setAccessible(true);
//4.获取、设置指定对象的此属性值
name.set(person,"Tom");
String n = (String) name.get(person);
System.out.println(n);
}
2.获取运行时类中的指定方法
@Test
public void testMethod() throws Exception {
Class<Person> clazz = Person.class;
//创建运行时类的对象
Person p = clazz.newInstance();
/*
1.获取指定的某个方法
getDeclaredMethod():参数1:指明获取的方法的名称 参数2:指明获取方法的形参列表
*/
Method showNation = clazz.getDeclaredMethod("showNation", String.class);
//2.保证当前方法可访问
showNation.setAccessible(true);
/*
3.调用方法的invoke():参数1:方法的调用者 参数2:给方法形参赋值的实参
invoke()的返回值即为对应类中调用方法的返回值
*/
String chn = (String) showNation.invoke(p, "CHN");
System.out.println(chn);
System.out.println("*********如何调用静态的方法***********");
//private static void showDesc()
Method showDesc = clazz.getDeclaredMethod("showDesc");
showDesc.setAccessible(true);
//如果调用的运行类中的方法没有返回值,则此invoke()返回null
Object returnVal = showDesc.invoke(Person.class);
System.out.println(returnVal);//null
}
3.获取运行时类中的指定构造器
@Test
public void testConstruction() throws Exception {
Class<Person> clazz = Person.class;
//private Person(String name)
/*
1.获取指定的构造器
getDeclaredConstructor():参数:指明构造器的参数列表
*/
Constructor<Person> constructor = clazz.getDeclaredConstructor(String.class);
//2.保证此构造器时可访问的
constructor.setAccessible(true);
//3.调用此构造器创建运行时类的对象
Person per = constructor.newInstance("Tom");
System.out.println(per);
}
五、疑问
学完反射可能会有的两个疑问
疑问1:
通过直接new的方式或反射的方式都可以调用公共的结构,开发中到底用哪一个?
建议:直接new的方式(代码量少,简单直接)
什么时候用反射的方式:反射的动态性,在编译的时候不确定要new谁,不确定到底要造哪一个类的对象,比如浏览器访问后台时,用户可能是选择登录,也可能选择注册,在用户选择登录的时候,后台就会根据产生登录类的对象,从而进行登录的一些操作,注册则也是一样的
疑问2:
反射机制与面向对象中的封装性是不是矛盾的?如何看待两个技术?
答:不矛盾,封装性更多的是建议你去调用公共的结构,而不要去调用私有的结构,公共的结构更好,起到一个提醒的作用,比如说单例模式已经把对象提供给你了,没有必要去造其他对象,直接拿这个对象,就能完成你项目的需求,如果非要去调用其私有的构造器,和直接使用提供的现成的对象没有什么区别,没有必要。封装性表述的就是建议你去调什么,公共的去调用,私有的就不要去调了。而反射解决的是能不能去调的问题,就比如,交通规则提醒你不要去闯红灯过马路,红灯亮起的时候就提醒你不要过马路了,当然你仍然选择过马路,不过后果得自负。封装性和这红灯一样只是起到一个警示的作用,建议你最好的选择,而反射就像你的意识一样,可以做你想做的事,但不一定是最佳的。所以,不矛盾。