反射是框架的灵魂。动态代理、很多框架（SoringIOC、AOP等）中都用到了反射。

概述：

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法（包括私有的）；对于任意一个对象，都能够调用它的任意一个方法和属性（包括私有的）；

这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.

1. java.lang.Class

Java 中的java.lang.Class 类是 Java 反射机制的基础，我们想要在运行期间获取一个类的相关信息，就需要使用 Class 类。

JVM 会为每个类都创建一个 Class 对象，在程序运行时， JVM 会首先检查要加载的类对应的 Class 对象是否已经加载。如果没有加载，那么 JVM 会根据类名查找 .class 文件，并将其Class对象载入。

Student 类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {

    private Integer id;

    private String name;

    private Integer age;


    private void eat(String name){
        System.out.println(name + " 吃东西。");
    }


    public int getBirthsDay(Integer age){
        return LocalDateTime.now().getYear() - age;
    }

}

1.1 获取 Class 对象

方式 1

调用对象的 getClass() 方法

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

方式 2

根据类名.class 获取

Class clazz = Student.class();

方式 3

根据Class类静态方法（全路径名）

Class clazz = Class.forName("com.snow.Student");

注意：在运行期间，一个类，只有一个Class对象产生。

三种方式常用第三种，第一种对象都有了还要反射干什么。第二种需要导入类的包，依赖太强，不导包就抛编译错误。一般都用第三种，一个字符串可以传入也可写在配置文件中等多种方法。

1.2 通过反射创建对象

使用反射创建对象有 2 种方式：

使用 Class 对象的 newInstance() 方法，其原理是通过类中定义的无参构造函数来创建对象的。

Student student = clazz.newInstance();

使用 java.lang.redlect.Constructor 类中的newInstance() 方法，这种方式既可以获取无参数的也可以获取有参数的。

//  调用无参
Student student1 = clazz1.getConstructor().newInstance();
System.out.println(student1);

//  调用有参
Student student2 
  = clazz1.getConstructor(Integer.class, String.class, Integer.class)
  .newInstance(10, "snow", 100);
System.out.println(student2);

1.3 通过反射获取类的属性、方法和注解等

除了 newInstance()方法，Class 类还有其他方法，可以在运行期间获得一个类的方法、属性和注解等。

1.3.1 反射获取构造方法

方法	说明

Constructor<?>[] getConstructors()	返回所有构造器对象的数组（只能拿public的）
Constructor<?>[] getDeclaredConstructors()	返回所有构造器对象的数组，存在就能拿到

Constructor getConstructor(Class<?>… parameterTypes)

返回单个构造器对象（只能拿public的）

Constructor getDeclaredConstructor(Class<?>… parameterTypes)

返回单个构造器对象，存在就能拿到

1.3.2 反射通过构造器创建对象

方法	说明
T newInstance(Object… initargs)	根据指定的构造器创建对象（参数为属性赋值）
public void setAccessible(boolean flag)	设置为true,表示取消访问检查，进行暴力反射

1.3.3 反射获取成员方法

方法	说明
Method[] getMethods()	返回所有成员方法对象的数组（只能拿public的）
Method[] getDeclaredMethods()	返回所有成员方法对象的数组，存在就能拿到

Method getMethod(String name, Class<?>… parameterTypes)

返回单个成员方法对象（只能拿public的）

Method getDeclaredMethod(String name, Class<?>… parameterTypes)

返回单个成员方法对象，存在就能拿到（第一个是方法名称，后面的是参数类型）

Method 类中用于触发执行的方法

//  参数1：方法名 参数2：形参类型
Method eat = clazz1.getDeclaredMethod("eat", String.class);
//  设置此方法可访问（只有私有方法才需要加这个）
eat.setAccessible(true);
//  运行方法 参数1：执行该方法的对象 参数2：实际参数
eat.invoke(student1, "snow");

Method getBirthsDay = clazz1.getDeclaredMethod("getBirthsDay", Integer.class);
Integer year = (Integer) getBirthsDay.invoke(student1, 25);
System.out.println(year);

1.3.4 反射获取属性

方法	说明
Field[] getFields()	返回所有成员变量对象的数组（只能拿public的）
Field[] getDeclaredFields()	返回所有成员变量对象的数组，存在就能拿到

Field getField(String name)	返回单个成员变量对象（只能拿public的）
Field getDeclaredField(String name)	返回单个成员变量对象，存在就能拿到

Filed类用于取值，赋值的方法：

方法	说明

void set(Object obj, Object value)	赋值
Object get(Object obj)	获取值。

Field[] declaredFields = clazz1.getDeclaredFields();
System.out.println(Arrays.toString(declaredFields));

2. 工具类操作

import org.springframework.util.ReflectionUtils;

String serviceClass = "orderUserServiceImpl";
String methodName = "getOne";
int id = 1;
//  获取方法
Method method 
     = ReflectionUtils.findMethod(SpringContextUtil.getBean(serviceClass).getClass(), methodName, Integer.class);
//用spring bean获取操作前的参数,此处需要注意：传入的id类型与bean里面的参数类型需要保持一致
//  获取对象
Object obj 
    = ReflectionUtils.invokeMethod(method, SpringContextUtil.getBean(serviceClass), id);

借助到的 SpringContextUtil 工具类：

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class SpringContextUtil implements ApplicationContextAware {

    private static ApplicationContext  applicationContext;

    /**
     * 实现ApplicationContextAware接口的回调方法，设置上下文环境
     */
    public void setApplicationContext(ApplicationContext applicationContext){
        SpringContextUtil.applicationContext = applicationContext;
    }

    public static ApplicationContext getApplicationContext(){
        return applicationContext;
    }

    /**
     * 获取对象
     * @return  Object 一个以所给名字注册的bean的实例 (service注解方式，自动生成以首字母小写的类名为bean name)
     */
    public static Object getBean(String name) throws BeansException {
        return applicationContext.getBean(name);
    }
}

3. 反射是如何破坏单例模式的

反射可以在运行期间获取并调用一个类的任何方法（包括私有方法）。所以使用反射可以破坏单例模式的。

SO : 如何避免单例对象被反射破坏：

只需要改造构造函数，使其在反射调用时识别对象是不是被创建即可：

private Student(){
    if(student != null){
        throw new RuntimeException(".....");
    }
}

4. 反射结合注解实现操作日志

自定义注解：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SnowLog {
  //  操作类型
    public String operateType();
    //  操作模块
    public String operateTarget();
    //  操作对象id
    public String operateTargetIdExpression();

}

切面类

import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

import com.google.common.base.CaseFormat;

@Aspect
@Component
@Slf4j
public class SnowLogAspect {


    //  环绕通知
    @Around("@annotation(com.baga.web.controller.log.SnowLog)")
    public Object log(ProceedingJoinPoint point) throws Exception{
        Method method = ((MethodSignature) point.getSignature()).getMethod();
        SnowLog snowLog = method.getAnnotation(SnowLog.class);

        Object response = null;

        try {
            //  执行目标方法
            response = point.proceed();
        } catch (Throwable throwable) {
            throw new Exception(throwable);
        }

        if(StringUtils.isBlank(snowLog.operateTargetIdExpression())){
            return null;
        }

        SpelExpressionParser parser = new SpelExpressionParser();
        Expression expression = parser.parseExpression(snowLog.operateTargetIdExpression());

        EvaluationContext context = new StandardEvaluationContext();

        //  获取参数值
        Object[] args = point.getArgs();

        //  获取运行时参数名称
        LocalVariableTableParameterNameDiscoverer discoverer = new LocalVariableTableParameterNameDiscoverer();
        String[] parameterNames = discoverer.getParameterNames(method);

        //  将参数绑定到 context 中
        if(parameterNames != null){
            for (int i = 0; i < parameterNames.length; i++) {
                context.setVariable(parameterNames[i], args[i]);
            }
        }

        //  将方法的 resp 当做变量放到 context 中，变量名称为该类名转换为小写字母
        //  开头的驼峰形式
        if(response != null){
            context.setVariable(
                    CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL,
                            response.getClass().getSimpleName()), response);
        }

        //  解析表达式，获取结果
        String operateTargetId = String.valueOf(expression.getValue(context));

        //  执行日志记录
        handleSnowLog(snowLog.operateType(), snowLog.operateTarget(), operateTargetId);
        return response;
    }


    private void handleSnowLog(String operateType, String operateTarget, String operateTargetId){
        log.info("operateType : {}, operateTarget : {}, operateTargetId : {}", operateType, operateTarget, operateTargetId);
    }

}

业务-添加

@PostMapping("/addStudyReview")
@SnowLog(operateTarget = "温故知新", operateType = "添加", operateTargetIdExpression = "#baseResult.data.id")
public BaseResult addStudyReview(@Validated(Default.class) @RequestBody StudyReviewAddModel addModel){
  StudyReview studyReview = studyReviewService.addStudyReview(addModel);
  return BaseResult.success(studyReview);
}

业务-修改

@PutMapping("/updateStudyReview")
@SnowLog(operateTarget = "温故知新", operateType = "修改", 
         operateTargetIdExpression = "#updateModel.id")
public BaseResult updateStudyReview(@Validated(Default.class) @RequestBody StudyReviewUpdateModel updateModel){
    studyReviewService.updateStudyReview(updateModel);
    return BaseResult.success();
}

业务-删除

@DeleteMapping("/end/{id}")
@SnowLog(operateTarget = "温故知新", operateType = "终结", 
         operateTargetIdExpression = "#id")
public BaseResult end(@PathVariable("id") Integer id){
StudyReview studyReview = studyReviewService.getById(id);
    if(studyReview == null || "1".equals(studyReview.getIsClose())){
        return BaseResult.success();
    }
    studyReview.setIsClose("1");
    studyReviewService.updateById(studyReview);
    return BaseResult.success();
}

业务

@PostMapping("/test")
@SnowLog(operateTarget = "温故知新", operateType = "测试", 
         operateTargetIdExpression = "#id")
public BaseResult test(Integer id, Integer age, String name){
  return BaseResult.success();
}

Java 反射

1. java.lang.Class

1.1 获取 Class 对象

1.2 通过反射创建对象

1.3 通过反射获取类的属性、方法和注解等

1.3.1 反射获取构造方法

1.3.2 反射通过构造器创建对象

1.3.3 反射获取成员方法

1.3.4 反射获取属性

2. 工具类操作

3. 反射是如何破坏单例模式的

4. 反射结合注解实现操作日志

热门文章

最新文章

相关课程

相关电子书

相关实验场景