java反射

一般情况下，我们使用某个类时必定知道它是什么类，是用来做什么的。于是我们直接对这个类进行实例化，之后使用这个类对象进行操作。

Student student = new student();
student.setage(18)

上面是常见的进行类对象的初始化方式，但我要是一开始并不知道我要初始化的类对象是什么，那该怎么处理呢？

Class clz = Class.forName("com.entity.Student");
Method method = clz.getMethod("setAge", int.class);
Constructor constructor = clz.getConstructor();
Object object = constructor.newInstance();
method.invoke(object, 18);

上面两段代码的执行结果，其实是完全一样的。但是其思路完全不一样，第一段代码在未运行时就已经确定了要运行的类（Student），而第二段代码则是在运行时通过字符串值才得知要运行的类（com.entity.Student）。

所以说什么是反射？

反射就是在运行时才知道要操作的类是什么，并且可以在运行时获取类的完整构造，并调用对应的方法。

一般情况下我们使用反射新建一个对象的步骤包括：

1.获取类的 Class 对象实例：

Class clz = Class.forName("com.entity.Student");

2.根据 Class 对象实例获取 Constructor 对象：

Constructor studentConstructor = clz.getConstructor();

3.使用 Constructor 对象的 newInstance 方法新建反射类对象：

Object studentObj = studentConstructor.newInstance();

如果要调用某一个方法，则需要经过下面的步骤：

1.获取方法的 Method 对象:

Method setAgeMethod = clz.getMethod("setAge", int.class);

2.利用 invoke 方法调用方法:

setAge.invoke(studentObj, 18);

反射常用API----获取反射中的Class对象

1.使用 Class.forName(路径) 静态方法。当你知道该类的全路径名时，你可以使用该方法获取 Class 类对象。

Class clz = Class.forName("com.entity.Student");

2.使用 类名.class 方法。
这种方法只适合在编译前就知道操作的 Class。(那我为啥不直接初始化？)

Class clz = Student.class;

3.使用类对象的 类.getClass() 方法。

Student student = new student();
Class clz = student.getClass()

反射常用API----通过反射创建类对象

1.通过 Class 对象的 newInstance() 方法。

Class clz = Student.class;
Student student = (Student)clz.newInstance();

2.通过 Constructor 对象的 newInstance() 方法。

Class clz = Student.class;
Constructor constructor = clz.getConstructor();
Student student = (Student)constructor.newInstance();

通过 Constructor 对象创建类对象可以选择特定构造方法，而通过 Class 对象则只能使用默认的无参数构造方法。

Class clz = Student.class;
Constructor constructor = clz.getConstructor(String.class, int.class);
//直接给初始化对象属性赋值
Student student = (Apple)constructor.newInstance("张三", 15);

反射常用API----通过反射获取类属性、方法、构造器

1.Class 对象的 getFields() 方法可以获取 Class 类的属性，但无法获取私有属性。

Class clz = Student.class;
Field[] fields = clz.getFields();
for (Field field : fields) {
    System.out.println(field.getName());
}


//输出结果
age

2.使用 Class 对象的 getDeclaredFields() 方法则可以获取包括私有属性在内的所有属性。

Class clz = Student.class;
Field[] fields = clz.getDeclaredFields();
for (Field field : fields) {
    System.out.println(field.getName());
}

//输出结果
name
age

与获取类属性一样，当我们去获取类方法、类构造器时，如果要获取私有方法或私有构造器，则必须使用有 declared 关键字的方法。

Class clz = Student.class;
Method method = clz.getMethod("setAge", int.class);
Method Declaredmethod = clz.getDeclaredMethod("setName", string.class);

实例

我们经常使用的 Spring 中的相关 Bean 的配置就是利用反射去加载对应的类。但是我们要讲的实例不是这个。

Spring 中有一种重要的概念叫做AOP，是在不改原有代码的前提下对其进行增强。而 公共字段自动填充 也是个比较常见的场景。比如上面的例子，假如我们不仅有老师类，又有学生类，它们都有公共字段 姓名、年龄，此时就要用反射的思想实现功能；或者，有的系统需要记录数据创建时间和上一次修改时间，此时也可以用反射的方式确定类的方法。

代码实例：

/**
 * 自定义注解，用于标识某个方法需要进行功能字段自动填充处理
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AutoFill {
    //数据库操作类型：UPDATE INSERT
    OperationType value();
}

@Aspect
@Component
@Slf4j
public class AutoFillAspect {

    /**
     * 切入点
     */
    @Pointcut("execution(* com.sky.mapper.*.*(..)) && @annotation(com.sky.annotation.AutoFill)")
    public void autoFillPointCut(){}

    /**
     * 前置通知，在通知中进行公共字段的赋值
     */
    @Before("autoFillPointCut()")
    public void autoFill(JoinPoint joinPoint){
        log.info("开始进行公共字段自动填充...");

        //获取到当前被拦截的方法上的数据库操作类型
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();//方法签名对象
        AutoFill autoFill = signature.getMethod().getAnnotation(AutoFill.class);//获得方法上的注解对象
        OperationType operationType = autoFill.value();//获得数据库操作类型

        //获取到当前被拦截的方法的参数--实体对象
        Object[] args = joinPoint.getArgs();
        if(args == null || args.length == 0){
            return;
        }
		
		//获取实体类对象
        Object entity = args[0];

        //准备赋值的数据
        LocalDateTime now = LocalDateTime.now();
        Long currentId = BaseContext.getCurrentId();

        //根据当前不同的操作类型，为对应的属性通过反射来赋值
        if(operationType == OperationType.INSERT){
            //为4个公共字段赋值
            try {
            	//利用反射调用方法
                Method setCreateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_CREATE_TIME, LocalDateTime.class);
                Method setCreateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_CREATE_USER, Long.class);
                Method setUpdateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class);
                Method setUpdateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_USER, Long.class);

                //通过调用方法为对象属性赋值
                setCreateTime.invoke(entity,now);
                setCreateUser.invoke(entity,currentId);
                setUpdateTime.invoke(entity,now);
                setUpdateUser.invoke(entity,currentId);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }else if(operationType == OperationType.UPDATE){
            //为2个公共字段赋值
            try {
                //利用反射调用方法
                Method setUpdateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class);
                Method setUpdateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_USER, Long.class);

                //通过调用方法为对象属性赋值
                setUpdateTime.invoke(entity,now);
                setUpdateUser.invoke(entity,currentId);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

@AutoFill(value = OperationType.INSERT)
void insert(Category category);

@AutoFill(value = OperationType.UPDATE)
void update(Category category);