一、反射
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);
}
}