反射机制（Reflection）
1.静态与动态语言
静态语言：运行时结构不可变的语言，如Java、C、C++。
动态语言：运行时可以改变其结构的语言，如C#、JavaScript、PHP、Python等。
Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用
反射机制获得类似动态语言的特性。Java的动态性让编程的时候更加灵活！
2.什么是反射
在java中，一个类加载完之后，在堆内存的方法区中就产生了一个Class类型的对象（并且一个类只有一个Class对象），这个对象包含了类的完整的结构信息，就像是一面镜子，透过这个镜子看到类的结构的过程，称之为反射。
Reflflection（反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflflection API取
得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
获取一个类的Class对象:
Class c = Class.forName("java.lang.String")
3.获取Class对象的几种方式
//获取class对象的方式
public class DemoTest2 {
public static void main(String[] args) throws ClassNotFoundException {
Person person = new Student();
System.out.println(person.name);
//方式一：通过实例化对象的getClass()方法
Class c1 = person.getClass();
//方法二：通过Class.forName()+文件路径 方法
Class c2 = Class.forName("reflect.Student");
//方法三：直接通过 类.class方法
Class c3 = Student.class;
//Person、Student、Teacher虽然有继承关系，class类不受继承关系影响，一个类对应一个class
//方法四：基本内置类型的包装类都有一个Type属性
Class c4 = Integer.TYPE;
Class c5 = Double.TYPE;
//方法五：通过子类的class获取父类的class
Class c6 = c1.getSuperclass();
System.out.println(c1.hashCode());
System.out.println(c2.hashCode());
System.out.println(c3.hashCode());
System.out.println(c4);
System.out.println(c5);
System.out.println(c6);
}
}
class Person{
public String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
}
class Student extends Person{
public Student() {
this.name = "学生";
}
}
class Teacher extends Person{
public Teacher() {
this.name = "老师";
}
}
4.java内存分析
类的加载过程：
加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象
链接：
- 验证：确保加载的类信息符合JVM规范，没有安全方面的问题
- 准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
- 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。
初始化：
- 执行类构造器
()方法的过程。类构造器 ()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器） - 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
- 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。
/**
* 内存分析
*/
public class DemoTest3 {
public static void main(String[] args) {
A a = new A();
System.out.println(A.m);
}
}
class A{
static {
System.out.println("A类的静态代码块");
m=300;
}
public static int m=100;
public A() {
System.out.println("A类的无参构造器");
}
}
结果：
A类的静态代码块
A类的无参构造器
100
上面代码执行过程分析，首先，在方法区中有DemoTest3类和A类的数据（包括静态变量、方法，常量池等），在执行类加载操作时，在堆中产生两个对象的
Class对象,在链接阶段m被初始化为0，随后在执行main方法时进行初始化操作，执行clinit方法，依次执行输出"A类的静态代码块"，赋值m=300,m=100，输出
"A类的无参构造器"。
5.什么时候会发生类初始化？
类的主动引用一定会发生类的初始化：
- 当虚拟机启动，先初始化main方法所在的类
- new一个类的对象
- 调用类的静态成员（除了fifinal常量）和静态方法
- 使用java.lang.reflect包的方法对类进行反射调用
- 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类
类的被动调用不会发生类的初始化：
- 当访问一个静态域时，只有真正声明这个域的类才会被初始化。
- 通过数组定义类引用，不会触发此类的初始化
- 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）
/**
* 类的主动引用和被动引用
*/
public class DemoTest4 {
static {
System.out.println("main类静态代码块加载");
}
public static void main(String[] args) throws ClassNotFoundException {
//类的主动引用（一定会发生类的初始化）
//new对象时会发生主动引用
Son son = new Son();
//结果：main类静态代码块加载
//父类的静态代码块被加载
//子类的静态代码块被加载
//父类被加载
//子类被加载
//在进行new操作时，首先Main方法所在类的静态代码块在链接阶段先执行，其次父类、子类的静态代码块，在类初始化时，先初始化父类，再初始化子类
//调用反射时也会发生主动引用
Class son = Class.forName("reflect.Son");
//结果：main类静态代码块加载
//父类的静态代码块被加载
//子类的静态代码块被加载
//通过反射的方式，获取Son类的Class对象，此处说会主动引用，但是结果输出的都是链接阶段的静态代码块中的内容，并没有构造器的输出语句
//类的被动引用（不会发生类的初始化）
//子类访问父类的静态变量,子类不会被加载，静态代码块也不会执行
System.out.println(Son.m);
//结果：main类静态代码块加载
//父类的静态代码块被加载
//10
//访问类中的静态常量时，不会初始化类
System.out.println(Son.n);
//结果：main类静态代码块加载
//10
}
}
class Son extends Father{
static {
System.out.println("子类的静态代码块被加载");
}
public static final int n=10;
public Son() {
System.out.println("子类被加载");
}
}
class Father{
static {
System.out.println("父类的静态代码块被加载");
}
public static int m=10;
public Father() {
System.out.println("父类被加载");
}
}
6.通过反射的Class对象获取类结构
public class DemoTest2 {
public static void main(String[] args) throws ClassNotFoundException,NoSuchFieldException {
Class c1 = Class.forName("com.lzl.reflection.User");
//获取类名+包名 （如果通过对象实例获取的Class对象）
System.out.println(c1.getName());
//只获取类名
System.out.println(c1.getSimpleName());
//获取类中的公开属性
Field[] fields = c1.getFields();
for (int i = 0; i < fields.length; i++) {
System.out.println(fields[i]);
}
//获取类中的所有属性
Field[] declaredFields = c1.getDeclaredFields();
for (int i = 0; i < declaredFields.length; i++) {
System.out.println(declaredFields[i]);
}
//获取类中指定的属性(无法获取私有的属性)
Field address = c1.getField("address");
System.out.println(address);
//获取类中指定的属性(私有、公开的属性都可以)
Field name = c1.getDeclaredField("name");
System.out.println(name);
//获取类中的方法（包括父类的不包括私有的）
Method[] methods = c1.getMethods();
for (int i = 0; i < methods.length; i++) {
System.out.println(methods[i]);
}
//获取类中的方法（包括私有的，但是不包括父类的）
Method[] declaredMethods = c1.getDeclaredMethods();
for (int i = 0; i < declaredMethods.length; i++) {
//System.out.println(declaredMethods[i]);
}
//也可以通过指定方法名称+参数类型，获取某一个方法，方式基本同上
//获取类中的构造器(同样此方法不包含私有的构造器，也可以通过指定参数类型获取指定的构造器)
Constructor[] constructors = c1.getConstructors();
for (int i = 0; i < constructors.length; i++) {
System.out.println(constructors[i]);
}
}
}
public class User {
/**
* 姓名
*/
private String name;
/**
* 年龄
*/
private int age;
public String address;
public User() {
}
private User(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
7. 反射的方式去实例化对象
public class DemoTest3 {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
Class c1 = Class.forName("com.lzl.reflection.User");
//此方法默认调用类的无参构造器去实例化对象
User user= (User) c1.newInstance();
//System.out.println(user);
//先获取构造器，后实例化对象(指定获取有参构造器)
Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, String.class);
User user2= (User) constructor.newInstance("lzl",12,"hahah");
//System.out.println(user2);
//通过反射去操作类中的方法
User user3 = (User) c1.newInstance();
Method setName = c1.getDeclaredMethod("setName", String.class);
//通过invoke方法和反射获取的某个方法去设置对象的值，格式invoke(实例对象，要赋的值)
setName.invoke(user3,"lzl");
// System.out.println(user3);
//通过反射去操作类中的属性
User user4 = (User) c1.newInstance();
Field name = c1.getDeclaredField("name");
//对于私有的属性而言，无法直接对其进行赋值，需要先关闭代码检查的，才能赋值成功;公开的属性，没有此限制
name.setAccessible(true);
name.set(user4,"1111");
System.out.println(user4);
}
}
8.setAccessible
-
Method和Field、Constructor对象都有setAccessible()方法。
-
setAccessible作用是启动和禁用访问安全检查的开关。
-
参数值为true则指示反射的对象在使用时应该取消Java语言访问检查。
-
提高反射的效率。如果代码中必须用反射，而该句代码需要频繁的被调用，那么请设置为true。使得原本无法访问的私有成员也可以访问
-
参数值为false则指示反射的对象应该实施Java语言访问检查
9 .获取方法的参数类型和返回值类型
package reflect;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
public class DemoTest06 {
public void test01(Map<String,User> map, List<String> list){
}
public Map<String,Object> test02(){
return null;
}
public static void main(String[] args) throws NoSuchMethodException {
Method method = DemoTest06.class.getMethod("test01", Map.class, List.class);
//获取方法的参数泛型
Type[] genericParameterTypes = method.getGenericParameterTypes();
//遍历查看方法的参数泛型
for (Type genericParameterType : genericParameterTypes) {
//System.out.println(genericParameterType);
//获取真实的参数类型
//判断获取到的泛型是否为参数化类型，如果是，强转为参数化类型，输出查看
if(genericParameterType instanceof ParameterizedType){
Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
//System.out.println(actualTypeArgument);
}
}
}
//获取方法的返回值泛型
method = DemoTest06.class.getMethod("test02",null);
Type genericReturnType = method.getGenericReturnType();
System.out.println(genericReturnType);
if(genericReturnType instanceof ParameterizedType){
Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(actualTypeArgument);
}
}
}
}
10.通过反射的方式去获取类中的注解
package reflect;
import java.lang.annotation.*;
import java.lang.reflect.Field;
/**
* 通过反射去获取类中的注解信息
*/
public class DemoTest07 {
public static void main(String[] args) throws NoSuchFieldException {
//获取student2中的注解
//类注解 获得类的所有注解
Annotation[] annotations = Student2.class.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
//获取指定名称的注解
// Student2.class.getAnnotation(TableStu.class);
//参数注解
Field[] fields = Student2.class.getDeclaredFields();
for (Field field : fields) {
Annotation[] annotations1 = field.getAnnotations();
for (Annotation annotation : annotations1) {
System.out.println(annotation);
}
}
//获取参数的指定注解
Field field = Student2.class.getDeclaredField("id");
FieldStu annotation = field.getAnnotation(FieldStu.class);
System.out.println(annotation.columnName());
System.out.println(annotation.type());
System.out.println(annotation.length());
}
}
@TableStu("db_stu")
class Student2{
@FieldStu(columnName = "db_id",type = "int",length = 10)
private int id;
@FieldStu(columnName = "db_age",type = "int",length = 10)
private int age;
@FieldStu(columnName = "db_name",type = "varchar",length = 10)
private String name;
public Student2() {
}
public Student2(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
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 "Student2{" +
"id=" + id +
", age=" + age +
", name='" + name + '\'' +
'}';
}
}
//类注解
//作用在类上
@Target(ElementType.TYPE)
//注解的生命周期 运行时
@Retention(RetentionPolicy.RUNTIME)
@interface TableStu{
String value();
}
//参数注解
//作用在参数上
@Target(ElementType.FIELD)
//注解的生命周期 运行时
@Retention(RetentionPolicy.RUNTIME)
@interface FieldStu{
String columnName();
String type();
int length();
}