自学笔记（二） -- 反射 Reflection

反射

前言： 作为Java学习的过程中最绕不开的就是反射了。反射的机制丰富了Java的语言的全面性，但是反射也是我认为Java中最难学的部分。当前Java生态中主流框架的实现都是非常依赖反射的，所以学会反射非常重要。

什么是反射？
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。

类加载完之后，在堆内存的方法区就产生一个Class类型的对象（一个类就对应一个Class对象），这个对象包含这个类的完整的结构信息。通过这个对象可以获取这个类的所有方法，方法参数，返回值等很多信息。

反射调用
实例化对象–>getClass()方法–>得到完整“包类”名称

正常调用
引入需要的“包类”名称–>通过new实例化–>取得实例化对象

反射的基本使用

 public class TestReflection {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取反射对象
        Class c1 = Class.forName("com.liu.pojo.User");
        System.out.println(c1);

			//判断同一个类获取多个Class是否获取的是一个对象，通过hashCode比较
			//一个类在内存中只有一个class对象
			//一个类被加载后，类的整个结构都会被封装在class中
        Class c2 = Class.forName("com.liu.pojo.User");
        Class c3 = Class.forName("com.liu.pojo.User");
        Class c4 = Class.forName("com.liu.pojo.User");
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
        System.out.println(c4.hashCode());
    }
}

结果：

三种获取Class的方法

//通过类名获得
Class clazz = User.class;
//通过对象获得
Class clazz = person.getClas();
//通过路径获得
Class clazz = Class.forName("demo.Person");
//基本内置类型的包装类
Class clazz = Integer.TYPE;
//获得父类类型
Class superClazz = clazz.getSuperclass();

反射的一些方法

//获取系统类的加载器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();

//获取系统类加载器的父类加载器 --> 扩展类加载器
ClassLoader parent = systemClassLoader.getParent();

//获取扩展类加载器的父类加载器 --> 跟加载器（C/C++）
ClassLoader parent1 = parent.getParent();

//获取当前类的加载器-->系统类的加载器
ClassLoader parent2 = Class.forName("包路径").getClassLoader();

//JDK内置类的加载器-->根加载器加载
ClassLoader parent3 = Class.forName("java.lang.object").getClassLoader();

//获取系统类加载器可以加载的路径
System.getProperty("java.class.path");

反射获取类的信息

Class c1 = Class.forName("com.liu.pojo.User");

//获取类的名字
c1.getName();
c1.getSimpleName();

//获取类的属性
Field[] publicFields = c1.getFields();//public权限
Field[] fields = c1.getDeclaredFields();//所有
Field name = c1.getDeclaredField("name");//所有

//获取类的方法
Method[] publicMethods = c1.getMethods();//获得本类及其父类的方法
Method[] methods = c1.getDeclaredMethods();
Method getName = c1.getMethod("getName", null);

//获得指定的构造器
Constructor[] declaredConstructors = c1.getDeclaredConstructors();
Constructor[] constructors = c1.getConstructors();

反射创建对象

Class c1 = Class.forName("com.liu.pojo.User");

//构造一个对象
User user = (User) c1.newInstance();//本质调用类的无参构造器

//通过构造器创建对象
Constructor constructor= c1.getDeclaredConstructor();
User user2 = (User) constructor.newInstance(001, "name", 18);

通过反射调用方法及属性

Class c1 = Class.forName("com.liu.pojo.User");

//构造一个对象
User user = (User) c1.newInstance();//本质调用类的无参构造器
//反射调用方法
Method setName = c1.getDeclaredMethod("setName", String.class);
setName.invoke(user, "小刘");

//反射调用属性  不能直接操作私有属性需要关掉安全检测
Field name = c1.getDeclaredField("name");
name.setAccessible(true);//设置权限true-允许
name.set(user, "小小刘");

当程序多次使用反射时建议将 setAccessible() 设为true

反射的操作泛型用来获取反射获取的方法的参数及返回值

Class c1 = Class.forName("com.liu.pojo.User");

Method method = c1.getDeclaredMethod("method", String.class);

//返回方法的参数类型
Type[] genericParameterTypes = method.getGenericParameterTypes();
for (Type genericParameterType : genericParameterTypes) {
    //如果这个参数属于参数化类型 map等
    if (genericParameterType instanceof ParameterizedType) {
        //获取真实参数
        Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
    }
}

//返回方法的返回值类型
Type genericReturnType = method.getGenericReturnType();

通过反射操作注解

public class TestAnnotationOfReflection {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class<?> c1 = Class.forName("com.liu.main.User");

        //获取全部注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

        TableUser annotation = c1.getAnnotation(TableUser.class);
        String value = annotation.value();
        System.out.println(value);

        //获得类指定的注解
        Field field = c1.getDeclaredField("name");
        FieldUser annotationOfField = field.getAnnotation(FieldUser.class);
        String s = annotationOfField.columnName();
        String type = annotationOfField.type();
        int length = annotationOfField.length();
    }
}

@TableUser("db_user")
class User {

    @FieldUser(columnName = "db_name", type = "varchar", length = 10)
    String name;
    @FieldUser(columnName = "db_age", type = "int", length = 10)
    int age;

    public User() {
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableUser {
    String value();
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldUser {
    String columnName();

    String type();

    int length();
}

---

参考链接
B站-西部开源