引言
new 和反射 都可以创建对象,那么为什么要?什么区别?
那么在什么时候会用反射,那么就要思考反射的特性:动态性(也就是在编译的时候,确定不下来要用哪一个对象)
反射的定义
在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;
对于任意一个对象,都能够调用它的任意一个方法和属性;
这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
反射的原理
要想理解反射的原理,首先要明白正常的类加载的过程
正常的加载和反射
new: 静态编译,在编译期就将模块编译进来,执行该字节码文件,所有的模块都被加载;
反射:动态编译,编译期没有加载,等到模块被调用时才加载;
而 反编译:.class —> .java
Class 类对象获取方式
- Class 类是用来描述类的
比如说有一个Person类,一个Order类,一个Book类,这些都是不同的类,现在需要一个类,用来描述类,这就是Class,它应该有类名,属性,方法,构造器等。 - Class 对象只能由系统建立对象,一个类(而不是一个对象)在 JVM 中只会有一个Class实例
既然已经知道了,对于任意一个类来说,都有一个唯一的Class 类实例,这个对象里面包含了对应类的名称
、方法、属性、构造器等类的信息,那么如何可以获取到一个类的class 对象
获取class对象的三种方式
通过new对象实现反射机制 获取class类对象
通过类名.Class 获取class 类对象
通过全限定名获取 包名+类名获取
//通过new对象实现反射机制 获取class类对象
Person person = new Person();
Class<?> clazz = person.getClass();
//通过类名获取class 类对象
Class<?> clazz2 = Person.class;
//通过全限定名获取 包名+类名获取
Class<?> clazz3 = Class.forName("Person");
观察反射以及class 类
构造一个Person类
import java.util.Date;
public class Person {
private String username;
private int age;
private Date birthDay;
public String nick;
public String sex;
public Person(String username){
this.username = username;
}
public Person(){
}
public Person(String username, int age){
this.username = username;
this.age = age;
}
public String getNick() {
return nick;
}
public void setNick(String nick) {
this.nick = nick;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Date getBirthDay() {
return birthDay;
}
public void setBirthDay(Date birthDay) {
this.birthDay = birthDay;
}
private void sayHello(){
System.out.println("person sayHello ---");
}
public void workIng(){
System.out.println("person work ing ---");
}
@Override
public String toString() {
return "Person{" +
"username='" + username + '\'' +
", age=" + age +
", birthDay=" + birthDay +
", nick='" + nick + '\'' +
'}';
}
}
通过反射获取的class对象来调用对应的class 方法
- getFields():获得类的public类型的属性
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class reflect {
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
Person person = new Person();
Class<?> clazz = person.getClass();
//获取类的名字
System.out.println(clazz.getName());
//获取类的所有属性 不论是否是public 修饰
Field[] declaredFields = clazz.getDeclaredFields();
//获取类中的public属性
Field[] fields = clazz.getFields();
System.out.println("=============");
//获取类的所有方法
Method[] declaredMethods = clazz.getDeclaredMethods();
//获取类的public方法
Method[] methods = clazz.getMethods();
//获取指定名字的方法,指定的名字的方法可能会抛出NoSuchMethodException
Method method = clazz.getMethod("setUsername", String.class);
//获取类的 所有public 构造器
Constructor<?>[] constructors = clazz.getConstructors();
//获取类的特定构造器 需要定义构造器的参数列表
Class[] cl = {String.class};
Constructor<?> constructor1 = clazz.getConstructor(cl);
//通过class 类的构造方法创建一个类对象 默认是Object类型的
Person personNew = (Person) clazz.newInstance();
//也可以同时使用构造器的方式
Person person2 =(Person) constructors[0].newInstance("pine",1);
}
}
class 常用的一些方法
getName():获得类的完整名字。
getFields():获得类的public类型的属性。
getDeclaredFields():获得类的所有属性。包括private 声明的和继承类
getMethods():获得类的public类型的方法。
getDeclaredMethods():获得类的所有方法。包括private 声明的和继承类
getMethod(String name, Class[]
parameterTypes):获得类的特定方法,name参数指定方法的名字,parameterTypes 参数指定方法的参数类型。getConstructors():获得类的public类型的构造方法。
getConstructor(Class[] parameterTypes):获得类的特定构造方法,parameterTypes
参数指定构造方法的参数类型。newInstance():通过类的构造方法创建这个类的一个对象。
反射的优缺点
- 优点: 运行期类型的判断,动态加载类,提高代码灵活度。
- 缺点: 性能瓶颈:反射相当于一系列解释操作,通知 JVM 要做的事情,性能比直接的java代码要慢很多。
反射的场景使用
反射是框架设计的灵魂。
例如模块化的开发,通过反射去调用对应的字节码;
动态代理设计模式也采用了反射机制,还有我们日常使用的 Spring/Hibernate 等框架也大量使用到了反射机制。
-
Spring 动态代理
举例:
①我们在使用JDBC连接数据库时使用Class.forName()通过反射加载数据库的驱动程序;②Spring框架也用到很多反射机制,最经典的就是xml的配置模式。
Spring 通过 XML 配置模式装载 Bean 的过程:
1) 将程序内所有 XML 或 Properties 配置文件加载入内存中;
2)Java类里面解析xml或properties里面的内容,得到对应实体类的字节码字符串以及相关的属性信息;
3)使用反射机制,根据这个字符串获得某个类的Class实例; 4)动态配置实例的属性 -
还有例如前后端的交互的时候,服务器跑起来,代码运行起来。
前端如果去请求访问login 的时候才创建对象,请求访问rigister,才去造对应的对象。这就用到了反射。