注解怎么给属性赋值

前言

大家都用过Spring的@Value(“xxx”)注解，如果没有debug过源码的同学对这个操作还是一知半解，工作一年了学了反射学了注解，还是不会自己手撸一个注解对属性赋值的操作。今天就用几分钟时间给你讲明白这个如何实现！

理想中代码：

@Compant
public class Bean01 {
  @MyValue("张三") //自定义注解
  String name; 
}

如果学过反射，获取类属性上面的自定义注解对象简直太简单，那怎么拿到“张三”，并给Bean01这个对象的name赋值呢？
在这里我用spring的形式给大家展示一下，完成这个理想赋值的demo~

思路：

1.spring启动，通过ComponentScan扫描注解(标签)加载@Component装饰的所有bean对象
2.通过Spring的BeanFactory增强，拿到Spring中注册的类信息
(BeanFactory会把扫描到的类信息放到BeanDefinitionMap中
BeanFactory会把扫描到的类名称放到BeanDefinitionNames中)
3.获取BeanDefinition中class信息，通过反射技术，获取类的属性，进而判断有没有自定义的注解装饰。
4.使用InvocationHandler，拿到自动义注解的属性值👉(memberValues : name=“张三”)
5.再通过Class使用反射创建对象，并进行类属性赋值
6.把赋值后对象注册到Spring容器中，会添加到Spring的一级缓存
7.进行对象获取的时候(getBean(xxx))，直接会从一级缓存中获取。这样就完成了我们注解赋值的操作~

代码实现

1.加载spring.xml

首先在/resources目录下创建spring.xml，目的是开启对Spring的注解支持

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <context:component-scan base-package="com.*"/>
</beans>

2.创建自定义注解

在这里为了更好的演示，创建两个自定义注解类

@Target(ElementType.FIELD) // 装饰在类的属性上
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyValue {
    String value() default "";//给姓名赋值用
}

@Target(ElementType.FIELD) // 装饰在类的属性上
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyValue2 {
    int age() default 0; //给年龄赋值用
}

3.创建Bean对象

然后我在这里创建两个Bean的对象，使用@Compent进行注入到spring容器，这样在BeanFactory中就可以获取到对象信息(BeanDefinition)

@Component
public class Bean01 {
    @MyValue("张三")
    public String name;

    @MyValue2(age = 11)
    public int age;
}

@Component
public class Bean02 {
    @MyValue("李四")
    public String name;

    @MyValue2(age = 18)
    public int age;
}

4.使用PostProcessor进行扩展(逻辑在第6步)

启动Spring的时候，@Component所装饰的Bean对象如果实现了BeanDefinitionRegistryPostProcessor这个类，会在执行时显示地调用他的两个方法：
postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)
postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
二者虽然都调用，但是区别在于其参数。*这里不过多介绍，可以在其他小伙伴的文章中进行学习

@Component
public class MyPostProcess implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {}
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {}
}

5.添加PostProcessor处理逻辑

@Component
public class MyPostProcess implements BeanDefinitionRegistryPostProcessor {
    // 用来存放获取到存在注解配置的Bean对象
    private Map<Class, Object> beanClassAndObjectMap;
    // 解析完带有自定义注解的bean class
    private Set<Class> hasMyAnnotationObjects;
    // 用来存放当前操作的class对象
    private Class currentClass;

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        // 拿到BeanDefinition集合并对其初始化准备操作
        initBeanClassAndObjectMap(registry, registry.getBeanDefinitionNames());
        // 开始对包含自定义注解的属性进行赋值
        executeSetField();
    }

    // 此方法任务是从Spring的Feactory中，拿到所有的class信息，并通过反射进行实例化 存入到map集合中
    private void initBeanClassAndObjectMap(BeanDefinitionRegistry registry, String[] beanDefinitionNames) {
        // 初始化存在注解的BeanDefinition
        beanClassAndObjectMap = new HashMap<>(beanDefinitionNames.length);
        // 初始化用来可解析的Class容器
        hasMyAnnotationObjects = new HashSet<>(beanDefinitionNames.length);

        // 根据beanDefinitionNames进行获取BeanDefinition
        for (String beanDefinitionName : beanDefinitionNames) {
            // 这个BeanDefinition包含了某个Bean对象的class信息
            BeanDefinition beanDefinition = registry.getBeanDefinition(beanDefinitionName);
            
            // 如果这个Bean的定义信息是被注解修饰过的
            if (beanDefinition instanceof ScannedGenericBeanDefinition) {
                try {
                    //根据BeanDefinition的getBeanClassName方法获取class信息并且存入map容器
                    Class<?> beanClass = Class.forName(registry.getBeanDefinition(beanDefinitionName).getBeanClassName());
                    beanClassAndObjectMap.put(beanClass, beanClass.newInstance());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
                    e.printStackTrace();
                }
            }

        }
    }

    /* 遍历存放Class和实例化完的对象，并进行获取属性注解的处理操作 */
    private void executeSetField() {
        beanClassAndObjectMap.keySet().forEach(this::doSetHasAnnotationsFiled);
    }

    /* 开始对包含自定义注解的属性进行赋值 */
    private void doSetHasAnnotationsFiled(Class beanClass) {
        this.currentClass = beanClass;

        try {
            //通过反射技术，获取对象的所有属性对象
            Field[] fields = beanClass.getFields();
            
            for (Field field : fields) {
                // 获取每个属性上所有被装饰的注解
                Annotation[] annotations = field.getAnnotations();

				// 遍历这些注解对象，用来判断是否有我自定义的注解
                for (Annotation annotation : annotations) {
                    // 执行注解MyValue处理
                    doMyValueHandler(field, annotation);
                    // 执行注解MyValue2处理
                    doMyValue2Handler(field, annotation);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /* 处理@MyValue注解 */
    private void doMyValueHandler(Field field, Annotation annotation) throws Exception {
        if (annotation.annotationType() == MyValue.class) {
            doHandler(annotation, "value", field);
        }
    }

    /* 处理@MyValue2注解 */
    private void doMyValue2Handler(Field field, Annotation annotation) throws Exception {
        if (annotation.annotationType() == MyValue2.class) {
            doHandler(annotation, "size", field);
        }
    }

    // 真正的解析注解属性内容地方
    // 获取注解属性值并对对象的属性进行赋值操作
    private void doHandler(Annotation annotation, String value, Field field) throws Exception {
        // 通过注解获取执行处理对象类
        InvocationHandler invocationHandler = Proxy.getInvocationHandler(annotation);
        // 获取注解的属性信息列表(Map形式)
        Field memberValues = invocationHandler.getClass().getDeclaredField("memberValues");
        // 设置属性访问权限
        memberValues.setAccessible(true);
        // 通过属性信息列表获取我的注解属性值信息
        Map map = (Map) memberValues.get(invocationHandler);
        // 给对象的属性进行动态赋值操作 (关键点)
        field.set(this.beanClassAndObjectMap.get(currentClass), map.get(value));
        // 梳理完注解赋值后的bean对象后，存到set集合中，后期用于把对象存到beanFactory的缓存中
        // 后期getBean()方法获取到的就是我们自定义填充完属性的对象
        hasMyAnnotationObjects.add(currentClass);
    }

    /* 遍历填充完的对象属性，注册到BeanFactory中 */
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        this.hasMyAnnotationObjects.forEach(dataClass -> {
            beanFactory.registerSingleton(pareBeanName(dataClass), beanClassAndObjectMap.get(dataClass));
        });
    }

    /* 首字母小写 */
    private String pareBeanName(Class dataClass) {
        return dataClass.getSimpleName().toLowerCase().charAt(0)
                + dataClass.getSimpleName().substring(1);
    }
}

6.启动Spring

这个时候就只剩下启动类了：

public static void main(String[] args) {
        ClassPathXmlApplicationContext app =
                new ClassPathXmlApplicationContext("spring.xml");

7.执行效果

可以查看到在BeanFactory中定义的BeanDefinition信息



通过代理类对注解进行参数解析



可以查看到通过注解赋值成功后的对象



执行结果

总结：

本文使用Spring其中一个扩展点BeanDefinitionFactoryPostProcessor接口，和注解的技术进行结合。再通过反射的机制查看哪些类的哪些属性是我们需要去处理的。处理后对象放到统一的容器内，后期再注册到spring的工厂中。整体思路就是这样，如有不理解地方请大家指出 一起进步~