反射第二弹：用注册器动态注册（用自定义的注解标注的）策略，实现策略模式的设计

引言

曾经有人问我，假如有一个业务或者数据处理逻辑，会根据甲方客户繁杂的业务需求，而动态变化，该怎么处理，具体怎么实现？

将所有策略strategy都写出来，然后放入一个hashMap，根据不同的业务需求，调用不同的策略就行了。

再问：那如果我的策略动态多变，再将strategy放入Map的代码，不想写死，不想频繁的修改代码怎么实现？比如我将策略代码写入项目下某个文件夹下面某个文件里，或者直接存入数据库某张表里，策略代码用text类型字段存起来，再调用构建接口，将策略逻辑用类加载器，加载出来，动态的创建为一个个新的strategy对象呢？

读取文件或者text字段，并解析为java代码，编译后，用类加载的方式加载，并且注册进Map，这个稍微复杂，但是我可以实现，只用在代码中添加策略，但是不用修改注册逻辑代码的方式。

设计思路：

所有需要被自动添加的策略类 Strategy 都必须加注解
再做一个扫描注解，属性包含：标明需要被扫描的包路径，@Import 标注一个注册器（实现ImportBeanDefinitionRegistrar），
定义一个注册器，实现ImportBeanDefinitionRegistrar，该注册器可以根据上述注解找到所有被注解标注的类，然后获取到标注的名称，实例化该类，并注册入指定的缓存。

将此注解加注在springboot启动类上面就可以在项目启动的时候，按照指定的包路径去扫描指定注解的类，然后利用反射机制，获取到扫描到的（被标注注解的）类的元空间，有了元空间，不管是获取该类上的注解，注解属性，还是该类的属性，方法都是没问题的。那么就可以获取到被扫描到的策略strategy的名字，再利用反射 clazz.newInstance() 创建出实例，放入缓存，就解决了动态注册策略的目的了。

除了对反射的利用，还需要对spring 容器有一定的理解，才能利用spring容器的environment， resourceLoader ，做出扫描器，使用resourceLoader 扫描该环境下，所有带注解的类；再根据指定的注解，过滤出目标类。

代码实现：

标注注解：@StrategyClass

import io.swagger.v3.oas.annotations.tags.Tag;
import java.lang.annotation.*;

/**
 * @Title: StrategyClass
 * @Description: 用来标记需要被注册的strategy
 * @Author: wenrong
 * @Date: 2024/4/2 10:02
 * @Version:1.0
 */

@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface StrategyClass {


    /**
     * 策略名
     * 为空时，会尝试读取 {@link Tag#name()} 属性
     */
    String strategyName() default "";


}

扫描注解：trategyScan

@DynamicStrategyScan注解标记在springboot启动类上，在springboot启动的时候，就会扫描@StrategyClass 注解的策略类，并开始自动添加到Map 缓存。

import org.springframework.context.annotation.Import;
import java.lang.annotation.*;

/**
 * @Title: DynamicStrategyScan
 * @Description: 用来扫描有动态策略注解的类，并初始化成相应的配置，注册到JVM 缓存
 * @Author: wenrong
 * @Date: 2024/4/2 15:27
 * @Version:1.0
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import(DynamicStrategyRegister.class)
@Documented
public @interface DynamicStrategyScan {

    String[] value() default {};

    String[] basePackages() default {};
}

注册器抽象类：

因为可能不光策略需要被注册，其他的也可能需要被注册，所以这里这里做一下抽象：

import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.util.ClassUtils;
import org.springframework.util.StringUtils;

import java.lang.annotation.Annotation;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * @Title: AnnotationScanAndRegister
 * @Description:
 * @Author: wenrong
 * @Date: 2024/4/2 15:35
 * @Version:1.0
 */
public abstract class AnnotationScanAndRegister implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {

    /**
     * 资源加载器
     */
    protected ResourceLoader resourceLoader;
    /**
     * 环境
     */
    protected Environment environment;

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        ImportBeanDefinitionRegistrar.super.registerBeanDefinitions(importingClassMetadata, registry);
    }

    /**
     * author: wenrong
     * date: 2024/4/2 15:36
     * 获取base packages
     */
    protected static Set<String> getBasePackages(AnnotationMetadata importingClassMetadata, Class<? extends Annotation> clazz) {
        // 获取到扫描注解所有属性
        Map<String, Object> attributes = importingClassMetadata.getAnnotationAttributes(clazz.getCanonicalName());
        Set<String> basePackages = new HashSet<>();
        assert attributes != null;
        // value 属性是否有配置值，如果有则添加
        for (String pkg : (String[]) attributes.get("value")) {
            if (StringUtils.hasText(pkg)) {
                basePackages.add(pkg);
            }
        }

        // basePackages 属性是否有配置值，如果有则添加
        for (String pkg : (String[]) attributes.get("basePackages")) {
            if (StringUtils.hasText(pkg)) {
                basePackages.add(pkg);
            }
        }

        // 如果上面两步都没有获取到basePackages，那么这里就默认使用当前项目启动类所在的包为basePackages
        if (basePackages.isEmpty()) {
            basePackages.add(ClassUtils.getPackageName(importingClassMetadata.getClassName()));
        }

        return basePackages;
    }

    /**
     * 获取name
     */
    protected static String getAttribute(Map<String, Object> attributes, String field) {
        return (String) attributes.get(field);
    }

    /**
     * 创建扫描器
     * 扫描器是在environment下，遇到带注解的类都扫描，只是后面会根据指定注解，做过滤
     */
    protected ClassPathScanningCandidateComponentProvider getScanner() {
        return new ClassPathScanningCandidateComponentProvider(false, environment) {
            @Override
            protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
                boolean isCandidate = false;
                if (beanDefinition.getMetadata().isIndependent()) {
                    if (!beanDefinition.getMetadata().isAnnotation()) {
                        isCandidate = true;
                    }
                }
                return isCandidate;
            }
        };
    }

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }
}

动态策略注册类：

import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.filter.AnnotationTypeFilter;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @Title: DynamicStrategyRegister
 * @Description: 用于系统启动时候，动态策略的初始化注册
 * @Author: wenrong
 * @Date: 2024/4/2 15:25
 * @Version:1.0
 */
@Slf4j
public class DynamicStrategyRegister extends AnnotationScanAndRegister {

    
    public static final Map<String, Strategy> XXXStrategies = new HashMap<>();
    

    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        // 创建scanner
        ClassPathScanningCandidateComponentProvider scanner = getScanner();
        scanner.setResourceLoader(resourceLoader);

        // 设置扫描器scanner扫描的过滤条件
        AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(StrategyClass.class);
        scanner.addIncludeFilter(annotationTypeFilter);

        // 获取指定要扫描的basePackages
        Set<String> basePackages = getBasePackages(metadata, DynamicStrategyScan.class);
        // 遍历每一个basePackages
        for (String basePackage : basePackages) {
            // 通过scanner获取basePackage下的候选类(有标注解的类)
            Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(basePackage);
            // 遍历每一个候选类，如果符合条件就把他们注册到容器
            for (BeanDefinition candidateComponent : candidateComponents) {
                if (candidateComponent instanceof AnnotatedBeanDefinition) {
                    // verify annotated class is an interface
                    AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
                    AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
                    // 获取@StrategyClass注解的属性
                    Map<String, Object> attributes = annotationMetadata.getAnnotationAttributes(StrategyClass.class.getCanonicalName());
                    // 注册配置到缓存
                    registerBean(annotationMetadata, attributes);
                }
            }
        }
    }

    /**
     * 利用factoryBean创建代理对象，并注册到容器
     */
    private void registerBean(AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
        // 获取类
        Class<?> clazz;
        try {
            clazz = Class.forName(annotationMetadata.getClassName());
        } catch (ClassNotFoundException e) {
            log.error(e.getMessage());
            return;
        }
       
        // 解析出@StrategyClass注解的name
        String strategyName = getAttribute(attributes, "strategyName");
        Strategy strategy = (Strategy) clazz.newInstance();
        XXXStrategies.put(strategyName, strategy);
    }

}

前面说了，除了动态注册策略，我还可以用来动态注册操作日志配置，注册配置后，可以操作配置开关，控制哪些接口开启操作日志：

import io.swagger.v3.oas.annotations.Operation;
import jakarta.annotation.PostConstruct;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.filter.AnnotationTypeFilter;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @Title: OperateOrderRegister
 * @Description: 用于系统启动时候，操作配置的初始化注册
 * @Author: wenrong
 * @Date: 2024/4/2 15:25
 * @Version:1.0
 */
@Slf4j
public class OperateLogConfigRegister extends AnnotationScanAndRegister {

    public static final List<LogConfigDTO> CONFIGS = new ArrayList<>();
    
    static final OperateTypeEnum[] OPERATE_TYPES = {OperateTypeEnum.CREATE, OperateTypeEnum.UPDATE, OperateTypeEnum.DELETE, OperateTypeEnum.IMPORT};
    
    @Resource
    private OperateLogConfigApi operateLogConfigApi;

    public static RequestMethod[] getRequestMethod(Method method) {
        // 使用 Spring 的工具类，可以处理 @RequestMapping 别名注解
        RequestMapping requestMapping = AnnotationUtils.getAnnotation(
                method, RequestMapping.class);
        if (requestMapping == null) {
            throw new RuntimeException("方法上没有加请求方式注解");
        }
        return requestMapping.method();
    }

    @PostConstruct
    private void register() {
        List<LogConfigDTO> configDTOS = CONFIGS.stream().filter(logConfigDTO -> {
            if (logConfigDTO.getOperateType() != null) {
                return operateLogConfigApi.validLogConfig(logConfigDTO);
            }
            return false;
        }).collect(Collectors.toList());
        //注册配置到数据库
        operateLogConfigApi.createOperateLogConfigs(configDTOS);
        // 删除已经没有配置日志注解的配置
        List<LogConfigDTO> allOperateLogConfigs = operateLogConfigApi.getAllOperateLogConfigs();
        Set<String> orders = CONFIGS.stream().map(LogConfigDTO::getOrderName).collect(Collectors.toSet());
        List<Long> config2Remove = allOperateLogConfigs.stream().filter(operateConfig ->
                !orders.contains(operateConfig.getOrderName())).map(LogConfigDTO::getId).collect(Collectors.toList());
        if (!config2Remove.isEmpty() && !CONFIGS.isEmpty()) {
            operateLogConfigApi.remove(config2Remove);
        }
    }

    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        // 创建scanner
        ClassPathScanningCandidateComponentProvider scanner = getScanner();
        scanner.setResourceLoader(resourceLoader);

        // 设置扫描器scanner扫描的过滤条件
        AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(OperateLogForClass.class);
        scanner.addIncludeFilter(annotationTypeFilter);

        // 获取指定要扫描的basePackages
        Set<String> basePackages = getBasePackages(metadata, OperateLogApiScan.class);
        // 遍历每一个basePackages
        for (String basePackage : basePackages) {
            // 通过scanner获取basePackage下的候选类(有标注解的类)
            Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(basePackage);
            // 遍历每一个候选类，如果符合条件就把他们注册到容器
            for (BeanDefinition candidateComponent : candidateComponents) {
                if (candidateComponent instanceof AnnotatedBeanDefinition) {
                    // verify annotated class is an interface
                    AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
                    AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
                    // 获取@OperateLogForClass注解的属性
                    Map<String, Object> attributes = annotationMetadata.getAnnotationAttributes(OperateLogForClass.class.getCanonicalName());
                    // 注册配置到缓存
                    registerBean(annotationMetadata, attributes);
                }
            }
        }
    }

    /**
     * 利用factoryBean创建代理对象，并注册到容器
     */
    private void registerBean(AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
        // 获取类
        Class<?> clazz;
        try {
            clazz = Class.forName(annotationMetadata.getClassName());
        } catch (ClassNotFoundException e) {
            log.error(e.getMessage());
            return;
        }
        // 解析出@OperateLogForClass注解的module
        String module = getAttribute(attributes, "module");
        // 解析出@OperateLogForClass注解的name
        String orderName = getAttribute(attributes, "orderName");
        Method[] declaredMethods = clazz.getDeclaredMethods();
        this.mapMethod(declaredMethods, module, orderName);
    }

    private void mapMethod(Method[] methods, String module, String orderName) {

        for (Method method : methods) {
            try {
                if (!Modifier.isPublic(method.getModifiers())) {
                    continue;
                }
                LogConfigDTO logConfigDTO = new LogConfigDTO();
                logConfigDTO.setModule(module);
                logConfigDTO.setOrderName(orderName);
                logConfigDTO.setConfig(true);
                String name = method.getAnnotation(Operation.class).summary();
                logConfigDTO.setName(name);
                // 设置操作类型
                // setOperateTypeByMethodName(method, logConfigDTO);
                setOperateType(method, logConfigDTO);
                if (logConfigDTO.getOperateType() != null) {
                    OperateLogConfigRegister.CONFIGS.add(logConfigDTO);
                }
            } catch (Exception e) {
                log.error("【操作类型匹配异常:】", e);
            }
        }

    }

    /**
     * @description: 设置操作类型, 虽然可以通过方法名匹配，不依赖注解，
     * 但是要依赖代码编写时候的方法名称的严格格式，如果方法名跳出增删改，
     * 则需要通过 {@link OperateType#type()}自定义方法操作类型
     * 适配非controller层的方法
     * @params: @param
     * @return: null
     * @author: wenrong
     * @time: 2024/4/3 14:11
     */
    private void setOperateTypeByMethodName(Method method, LogConfigDTO logConfigDTO) {
        List<OperateTypeEnum> operateTypes = Arrays.stream(OPERATE_TYPES).filter(operateType ->
                method.getName().startsWith(operateType.getName())
        ).collect(Collectors.toList());
        if (!operateTypes.isEmpty()) {
            logConfigDTO.setOperateType(operateTypes.get(0).getDescription());
        } else if (method.getName().startsWith(OperateTypeEnum.GET.getName())
                || method.getName().startsWith(OperateTypeEnum.EXPORT.getName())) {
            logConfigDTO.setOperateType(null);
        } else if (StringUtils.hasText(method.getAnnotation(OperateType.class).type())) {
            logConfigDTO.setOperateType(method.getAnnotation(OperateType.class).type());
        }

    }

    /**
     * @description: 使用 {@link RequestMapping#method()} 匹配操作类型，不容易出错
     * 但是仅限于controller的 RESTFul风格接口
     * @params: @param
     * @return: null
     * @author: wenrong
     * @time: 2024/4/3 14:28
     */
    private void setOperateType(Method method, LogConfigDTO logConfigDTO) {
        cn.iocoder.yudao.framework.operatelog.core.annotations.OperateLog operateLog = method.getAnnotation(cn.iocoder.yudao.framework.operatelog.core.annotations.OperateLog.class);
        if (operateLog != null && !operateLog.enable()) {
            return;
        }
        RequestMethod requestMethod = RequestMethodFilter.filterRequestMethod(getRequestMethod(method));
        if (requestMethod == null) {
            logConfigDTO.setOperateType(null);
            return;
        }
        OperateTypeEnum operateTypeEnum = OperateTypeConvertor.convertOperateType(requestMethod);
        OperateType operateType = method.getAnnotation(OperateType.class);

        if (operateTypeEnum == null && operateType == null) {
            logConfigDTO.setOperateType(null);
        } else {
            if (operateTypeEnum == null) {
                if (StringUtils.hasText(method.getAnnotation(OperateType.class).type())) {
                    logConfigDTO.setOperateType(method.getAnnotation(OperateType.class).type());
                } else {
                    logConfigDTO.setOperateType(OperateTypeEnum.OTHER.getDescription());
                }
            } else {
                logConfigDTO.setOperateType(operateTypeEnum.getDescription());
            }
        }
    }


}

AOP类：

这里需要自己去实现，如果需要源码，后给我发消息，留言。

注意：

如果只做专业人员运维日志，保存接口所属功能模块，菜单，接口名称，uri、客户端IP，传参就可以了，但是如果是给用户看的，则需要定义一个上下文类，里面利用ThreadLocal存入两个字符串变量，修改前，修改后，至于新增，修改前为空，删除，修改后为空。（虽然操作肯定不止修改，有新增和删除，看似修改前和修改后的方式并不适合所有操作类型，但这是将技术实现设计向业务功能实现设计妥协的体现，因为不得不对业务代码有侵入。）

需要注意的是，上述出现过两次AnnotationMetadata 元空间，一次是registerBeanDefinitions(AnnotationMetadata metadata, ...)一次是AnnotationMetadata annotationMetadata = beanDefinition.getMetadata(); 这两次虽然都是元空间对象，但是前面的元空间是当前整个容器的元空间，类信息都在里面，包括接口和注解的，所以利用元空间、注解的类名，获取类的属性空间，importingClassMetadata.getAnnotationAttributes(clazz.getCanonicalName()); 后者的元空间则是扫描的到类的元空间，可以获取该类上的注解，注解的属性等。

总结：

Java的反射机制允许程序在运行时检查和操作类、方法和字段。通过反射，你可以在运行时获取类的信息（如类名、字段、方法等），并且可以动态地创建对象、调用方法和访问/修改字段。

以下是Java反射机制的一些重要概念和用法：

class类: Java中的每个类都有一个与之关联的Class对象，它包含了该类的完整信息。你可以使用以下方式获取Class对象：

Class<?> clazz = MyClass.class; // 通过类名 
Class<?> clazz = obj.getClass(); // 通过对象实例 
Class<?> clazz = Class.forName("com.example.MyClass"); // 通过类的完全限定名

获取类的信息: 一旦有了Class对象，你就可以获取关于类的信息，如类名、字段、方法等。

String className = clazz.getName(); 
Field[] fields = clazz.getDeclaredFields(); 
Method[] methods = clazz.getDeclaredMethods();

创建对象: 可以通过反射来动态创建对象实例。

MyClass obj = (MyClass) clazz.newInstance();

访问和修改字段: 可以通过反射来获取和修改对象的字段值。

Field field = clazz.getDeclaredField("fieldName"); 
field.setAccessible(true); // 如果字段是私有的，需要设置可访问性 
Object value = field.get(obj); // 获取字段值 
field.set(obj, newValue); // 设置字段值

调用方法: 可以通过反射来调用类的方法。

Method method = clazz.getDeclaredMethod("methodName", parameterTypes); 
method.setAccessible(true); // 如果方法是私有的，需要设置可访问性 
Object result = method.invoke(obj, args); // 调用方法

动态代理: 可以使用反射来创建动态代理对象。

MyInterface proxy = (MyInterface) Proxy
.newProxyInstance( MyInterface.class.getClassLoader(), new Class[] { MyInterface.class }, new MyInvocationHandler());

虽然反射提供了很大的灵活性，但也需要谨慎使用，因为它会降低代码的可读性和性能，而且可能会在编译时捕获不到的错误。