java反射

一、反射

1.类加载区别

• 正常编码过程为new一个对象，然后调用该对象的某些方法等操作，最后运行代码进行实现

• 当我们想在运行期才能指定具体对象的类型或调用的某个方法、属性时，普通的编码方式将无法实现需求，这时就需要使用到反射

2.JVM类加载流程

• 反射与类息息相关，通过类编译器将编码时的java文件编译为class文件，类加载器将class文件加载到JVM虚拟机进行内存管理（堆、栈、方法区、线程等）

3.class文件包含的内容

• Class文件中，几乎包含了所有类相关的信息，如：类名、包名、属性、方法等等。那么，Class对象其实就是我们获得的某一个类型字节码的引用对象。

4.创建实例对象的步骤

• 都需要三个步骤
  ① 加载Class文件；
  ② 查找入参匹配的构造函数；
  ③ 通过构造函数创建实例对象；

5.创建class对象的方法

• 共有三种方法
  第一种：可以在编码时直接通过类.class的方法进行创建
  第二种：可以通过实例对象.getclass进行获取
  第三种：可以通过运行期类的全路径进行获取

 /**
     * 示例：创建Class对象的3种方式
     */
    @Test
    public void test() throws Throwable{
        /** 方式1：类.class */
        Class personClazz = Person.class;

        /** 方式2：实例.getClass() */
        Person person = new Person();
        Class personClazz1 = person.getClass();

        /** 方式3：Class.forName("类的全路径") */
        Class personClazz2 = Class.forName("com.muse.reflect.Person");

        System.out.println(personClazz == personClazz1);
        System.out.println(personClazz == personClazz2);
    }

6.通过构造函数创建对象

1. 通过class文件获取person对象的字节码
2. 通过class对象创建构造方法对象（区分有参和无参）
3. 通过构造方法创建对象，有参的构造函数需要为对象进行赋值

 /**
     * 示例：通过Class创建实例对象
     *
     * // 无参数
     * <bean id="person" class="com.muse.reflect.Person"/>
     *
     * // 有参数
     * <bean id="person" class="com.muse.reflect.Person">
     *    <constructor-arg index="0" type="java.lang.String" value="muse"/>
     * </bean>
     */
    @Test
    public void test2() throws Throwable {
        /** 首先：获得Person的字节码 */
        Class personClazz = Class.forName("com.muse.reflect.Person");

        /** 其次：通过Class对象，创建构造方法对象 */
        Constructor constructor1 = personClazz.getConstructor(); // 初始化无参构造方法
        Constructor constructor2 = personClazz.getConstructor(String.class, Integer.class, Byte.class, Boolean.class); // 初始化有参构造方法对象

        /** 最后：通过构造方法创建对象 */
        // 调用无参数构造方法创建Person对象
        Person person1 = (Person) constructor1.newInstance();
        person1.setName("muse1");
        System.out.println("person1=" + person1);

        // 调用有参数构造方法创建Person对象
        Person person2 = (Person) constructor2.newInstance("muse2", 10, (byte) 1, true);
        System.out.println("person2=" + person2);
    }

7.通过反射获取私有构造方法（破坏单例模式）

/** 反射通过私有构造方法创建对象，破坏单例模式 */
    @Test
    public void test3() throws Throwable {
        /** 获取class文件 */
        Class singletonPersonClazz = SingletonPerson.class;

        /** 构造方法为public时的创建方法 */
        // Constructor constructor3 = singletonPersonClazz.getConstructor();
        /** 构造方法为private时的创建方法 */
        Constructor constructor3 = singletonPersonClazz.getDeclaredConstructor();

        /** 将访问权限打开（若不打开后续无法实现） */
        constructor3.setAccessible(true);

        /** 测试使用反射破坏单例模式
         * 由于singletonPerson通过反射的获取到了private的私有构造方法重新获取了一个新的对象
         * 所以导致最终的单例对象不唯一，通过比对可以得知
         */
        SingletonPerson singletonPerson = (SingletonPerson) constructor3.newInstance();
        SingletonPerson singletonPerson1 = SingletonPerson.getInstance();
        SingletonPerson singletonPerson2 = SingletonPerson.getInstance();
        System.out.println("singletonPerson==singletonPerson1 is " + (singletonPerson == singletonPerson1));
        System.out.println("singletonPerson==singletonPerson2 is " + (singletonPerson == singletonPerson2));
        System.out.println("singletonPerson1==singletonPerson2 is " + (singletonPerson1 == singletonPerson2));
    }

8.通过反射获取属性及方法

1.属性、方法及构造函数若为private或protected需要使用getDeclared进行获取，但是不能获取继承来的字段
getDeclaredConstructor（获取私有构造方法）
getDeclaredField（获取私有属性）
getDeclaredMethod（ 获取私有方法）
2.若使用getDeclared获取私有内容，需要==setAccessible(true)==将访问权限进行打开

@Test
    public void getFieldOrMethod() throws Throwable {
        /** 首先：获得Person的字节码 */
        Class personClazz = Person.class;

        /** 其次：获得Person对象（由于非静态非private的属性，访问使用 对象.属性方式访问，所以反射必须先获得对象实例）*/
        Person person = (Person) personClazz.getConstructor().newInstance();

        /** 第三：通过Class对象，获得Field对象 */
        Field nameField = personClazz.getField("name"); // 不报错
        //不能使用getField，否则报错：java.lang.NoSuchFieldException: sex
        // Field sexField = personClazz.getField("sex");
        Field sexField = personClazz.getDeclaredField("sex");
        sexField.setAccessible(true); // 必须设置为true

        /** 第四：通过Class对象，获得Method对象 */
        Method method = personClazz.getDeclaredMethod("privateMethod");
        method.setAccessible(true); // 必须设置为true

        /** 输出共有和私有的属性及方法 */
        //public属性
        System.out.println("public属性：name = " + nameField.get(person));
        //private属性
        System.out.println("private属性：sex = " + (Byte) sexField.get(person));
        //private方法
        System.out.println("private方法：privateMethod() = " + method.invoke(person));
    }

9.通过反射复制对象内容

将属性名称相同的参数进行赋值，通过反射对两个对象的属性进行数据的拷贝

 public static void convertor(Object originObj, Object targetObj) throws Throwable {
        /** 1：获得class对象 */
        Class orginClazz = originObj.getClass();
        Class targetClazz = targetObj.getClass();

        /** 2：缓存originObj对象中的Field */
        Map<String, Field> fieldCache = new HashMap<>();
        Field[] orginFields = orginClazz.getDeclaredFields();
        for (Field field : orginFields) fieldCache.put(field.getName(), field);

        /** 3：赋值操作 */
        for (Field targetField : targetClazz.getDeclaredFields()) {
            if (!fieldCache.containsKey(targetField.getName())) continue;

            Field originField = fieldCache.get(targetField.getName());
            originField.setAccessible(true);
            targetField.setAccessible(true);
            targetField.set(targetObj, originField.get(originObj));
        }
    }

10.通过mapstruct进行复制对象内容

只需通过引入mapstruct在接口中进行注解即可使用，可使用注解对两个不同名称的属性进行映射，这样即使两个名称对应不上的属性也可进行赋值

@Mapper
public interface CarMapper {
    CarMapper INSTANCE = Mappers.getMapper(CarMapper.class);

    @Mapping(source = "numberOfSeats", target = "seatCount")
    @Mapping(source = "type", target = "typeDto")
    CarDto carToCarDto(Car car);
}

测试类，直接调用INSTANCE.carToCarDto即可完成对象的赋值

/**
 * MapStruct演示例子
 */
public class MapStructTest {
    public static void main(String[] args) {
        Car car = new Car("Germany", 5, "BMW");
        CarDto carDto = CarMapper.INSTANCE.carToCarDto(car);
        System.out.println("car=" + car);
        System.out.println("carDto=" + carDto);
    }
}