反射（Reflection）
1、什么是反射
反射是一种非常强大的机制。反射跟注解配合，就天衣无缝了。
动态语言和静态语言
**动态语言：**是一类在运行时可以改变其结构的语言．例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。动态语言主要有JavaScript、python、c#等。
**静态语言：**与动态语言相对应，运行时不能改变的语言称为静态语言。静态语言主要有C、C++、Java。
Java不是动态语言，但是它可以被称为”准动态语言“，Java具有一定的动态性，通过反射机制可以获得类似于动态语言的特性。反射让编程变得更加灵活。
Reflection（反射）是 Java 被视为动态语言的关键，反射机制允许程序在执行期借助于 Reflection API 取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
2、反射的基础——Class对象
加载完类之后，HotSpot虚拟机中，在堆内存的方法区中就产生了一个 InstanceKlass对象用来存储类的所有信息，该对象必定不能被开发者通过任何方式获取。与此同时，堆中会产生一个Class类型的对象（一个类只有一个 Class 对象，这个对象就包含了InstanceKlass对象中的元数据），我们可以通过这个对象看到类的结构。
一个类加载完在堆中生成对应的Class对象，类的实例对象是通过Class对象创建的，通过类的实例对象可以获取到Class对象（getClass()方法），从而得到类的元数据，这被形象地称为”反射“。
所以可以说，反射就是通过获取Class对象，并操作Class对象达到各种目的。
可以通过多种方式获得Class对象。
//第一种方法，通过Class类的静态方法通过全限定名获取某个类的Class对象
Class c=Class.forName("java.lang.String");
//第二种方法，通过实例化对象的getClass方法获取它的Class对象
String s1=new String("haha");
Class c=s1.getClass();
//第三种方法，已知一个类的全类名，可以通过全类名获得它的Class对象
Class c=Person.class;
//第四种方法，通过类加载器，由类的全限定名加载某个类并获得Class对象
Class类有很多方法：
3、反射获得类信息
反射第一个用途就是获得类的各种信息了。
通过Class对象，可以获得运行时类的完整结构：Field（字段），Method（方法），Constructor（构造器），SuperClass（父类），Annotation（注解）。
package main.test;
class User{
private String id;
public void printMessage(){
System.out.println(this.id);
}
}
public class Test {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class c = Class.forName("main.test.User");
//获得类名
System.out.println(c.getName());
//获得类的字段 打印信息:[] 只能找到public的属性
System.out.println(Arrays.toString(c.getFields()));
//获得类的字段 打印信息：[private java.lang.String main.test.User.id] 所有属性都能得到
System.out.println(Arrays.toString(c.getDeclaredFields()));
//获得特定属性名 打印信息：private java.lang.String main.test.User.id
System.out.println(c.getDeclaredField("id"));
//获得类的方法 打印信息：[public void main.test.User.printMessage()]
System.out.println(Arrays.toString(c.getDeclaredMethods()));
//此外，还可以获得类中的构造器、注解，都是一样的套路，非常简单
}
}
4、反射操作方法和字段
第二个用途，Class对象可以获得类的一个实例化对象，也可以通过Class对象调用方法和设置字段值。
package main.test;
public class Test {
public static void main(String[] args) throws Exception {
Class c = Class.forName("main.test.User");
//=======================================================
//通过newInstance()获得实例化对象，该方法本质上是调用了User的无参构造方法，如果方法没有无参构造，会报错，所以这个方法已经过时(被@Deprecated)了
User user = (User)c.newInstance();
//打印信息：User{id='null'}
System.out.println(user);
//可以通过先获得构造器，再用指定构造器构造一个对象，这样就不会出错了
User o1 = (User)c.getDeclaredConstructor(String.class).newInstance("传参");
User o2 = (User)c.getDeclaredConstructor().newInstance();
//打印信息：User{id='传参'}
System.out.println(o1);
//打印信息：User{id='null'}
System.out.println(o2);
//=======================================================
//通过Class对象获得方法，再进行激活
User user1 = (User)c.getDeclaredConstructor(String.class).newInstance("张三");
//第一次打印user1对象中的信息：张三
System.out.println(user1.getId());
//为何这里第二个参数要传入String.class？因为同一个方法名可以重载不同类型的参数，所以必须把参数类型标清楚
Method setId = c.getDeclaredMethod("setId", String.class);
//激活方法，传参要传入User对象，表明激活的是哪一个对象中的方法
setId.invoke(user1,"李四");
//第二次打印user1对象中的信息：李四
System.out.println(user1.getId());
//=======================================================
//通过Class对象获得字段，再设置字段的值
User user2 = (User)c.getDeclaredConstructor(String.class).newInstance("张三");
//第一次打印user1对象中的信息：张三
System.out.println(user2.getId());
Field id = c.getDeclaredField("id");
//直接调用id.set(user2,"李四")会报错，因为id这个字段是私有的，所以需要先把id的权限放开
id.setAccessible(true);
id.set(user2,"李四");
//第二次打印user1对象中的信息：李四
System.out.println(user2.getId());
//这个看起来有点儿多此一举，但是之后就知道它的用处了~~~
}
}
class User{
private String id;
public User() {
}
public User(String id) {
this.id = id;
}
public void printMessage(){
System.out.println(this.id);
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
@Override
public String toString() {
return "User{" +
"id='" + id + '\'' +
'}';
}
}
通过反射获得对象的速度非常非常慢。
public static void main(String[] args) throws Exception {
int num=100000000;
Class c = Class.forName("main.test.User");
long begin1 = System.currentTimeMillis();
for (int i = 0; i <num ; i++) {
User o1 = (User)c.getDeclaredConstructor(String.class).newInstance("传参");
}
//花费时间：4179
System.out.println(System.currentTimeMillis() - begin1);
long begin2 = System.currentTimeMillis();
for (int i = 0; i < num; i++) {
User o1 = new User("传参");
}
//花费时间：0
System.out.println(System.currentTimeMillis() - begin2);
//通过反射实例化对象速度慢了超级多倍哦，想清楚再使用
}
Class对象中的Field、Method、Constructor中都有setAccessible这个方法，可以突破private的限制。setAccessible设置为true可以关闭Java对public、private的检测，是可以提高反射的效率的。如果发现反射的效率实在是不尽人意，可以尝试关闭语法检测，大概可以减少3-5倍的运行时间。
5、反射操作泛型
反射操作泛型，这个听起来有点儿奇怪。Java的泛型在编译器中实现，类型检查和类型推断由编译器执行，然后生成普通的非泛型的字节码，虚拟机完全不感知泛型的存在。编译器使用泛型类型信息保证类型安全，然后在生成字节码之前将其清除 。因此，字节码文件中不存在泛型信息。换而言之，Class对象中按理来说是不存在泛型的信息的。
为了通过反射操作这些类型， Java新增了ParameterizedType、GenericArrayType、TypeVariable 和 WildcardType 几种类型来代表不能被归一到 Class 类中的类型但是又和原始类型齐名的类型。
-
ParameterizedType 表示一种参数化类型比如 Collection
-
GenericArrayType 表示一种元素类型是参数化类型或者类型变量的数组类型
-
TypeVariable 是各种类型变量的公共父接口
-
WildcardType 代表一种通配符类型表达式
6、反射操作注解
实现一个小功能：实体-表关系映射。
通过Java的实体和实体中的字段，可以判断出该实体对应MySQL中的哪张表，以及表中有哪些字段。
package main.test;
import java.lang.annotation.*;
import java.lang.reflect.Field;
import java.util.Arrays;
public class Test {
public static void main(String[] args) throws Exception {
Class c = Class.forName("main.test.Student");
//通过反射获得类的注解
Annotation[] cAnnotations = c.getAnnotations();
//打印信息：[@main.test.TableMapping("db_student")]
System.out.println(Arrays.toString(cAnnotations));
//获得注解的value的值
TableMapping annotation = (TableMapping) cAnnotations[0];
//打印信息：db_student
System.out.println(annotation.value());
//同理，获得类中字段的注解的参数值
Field[] fields = c.getDeclaredFields();
FieldMapping[] fieldAnnotations = new FieldMapping[fields.length];
for (int i = 0; i < fields.length; i++) {
//已知类型，不需要强转
fieldAnnotations[i] = fields[i].getAnnotation(FieldMapping.class);
}
//打印信息： db_id,int,256
// db_age,int,3
// db_name,varchar,256
for (FieldMapping fieldAnnotation : fieldAnnotations) {
System.out.print(fieldAnnotation.columnName() + ",");
System.out.print(fieldAnnotation.type() + ",");
System.out.println(fieldAnnotation.length());
}
}
}
/**
* @author xcy
* 自定义一个类名的注解
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableMapping {
String value();
}
/**
* @author xcy
* 自定义一个属性的注解
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldMapping {
//列名
String columnName();
//类型
String type();
//长度
int length();
}
@TableMapping("db_student")
class Student {
@FieldMapping(columnName = "db_id", type = "int", length = 256)
private int id;
@FieldMapping(columnName = "db_age", type = "int", length = 3)
private int age;
@FieldMapping(columnName = "db_name", type = "varchar", length = 256)
private String name;
public Student(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
public Student() {
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", age=" + age +
", name='" + name + '\'' +
'}';
}
}
不同的注解就像是不同颜色的标签，注解的参数就像是标签中可以记录的内容。使用一个注解作用于类/字段/方法，就是为类/字段/方法添加了额外的补充信息，这些信息可以通过反射获取到。补充信息被获取到，就可以对这些信息进行处理、操作，从而让被注解的类/字段/方法有了额外的功能，而且这些功能不容易被感知。
Spring、Springboot、mybatis-plus等框架正是因为引用了大量注解，才让开发者能够用简单的几行代码实现复杂的逻辑操作。
413
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
