Spring使用自定义注解对静态变量进行注入

已于 2023-08-28 21:37:11 修改
阅读量380 收藏
点赞数 1
CC 4.0 BY-SA版权
文章标签： java spring spring boot
于 2023-08-28 21:14:25 首次发布
原文链接：https://www.jianshu.com/p/9bad953a75c4

静态注入注解@StaticAutowired,@StaticValue（构建思路抄Spring的然后改）

构建注解@StaticValue

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
@Documented
public @interface StaticValue {
    /**
    * 注入静态属性值
    */
    String value();
}

构建@StaticValue解析类

主要学习了这个方法是如何处理的

import org.sonder.ydzy.annotation.StaticValue;
import org.springframework.context.annotation.ContextAnnotationAutowireCandidateResolver;
import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.core.annotation.AnnotationAttributes;

import java.lang.annotation.Annotation;

public class ExContextAnnotationAutowireCandidateResolver extends ContextAnnotationAutowireCandidateResolver {

    private Class<? extends Annotation> valueAnnotationType = StaticValue.class;

    @Override
    protected Object findValue(Annotation[] annotationsToSearch) {

        // 父类 对 @Value 的 value 值解析出来
        Object value = super.findValue(annotationsToSearch);
        if (value != null) {
            return value;
        }

        //父类解析之后去看这个字段上时候有我们自己的注解，然后拿到这个注解再学习父类那样去解析
        if (annotationsToSearch.length > 0) {
            AnnotationAttributes attr = AnnotatedElementUtils.getMergedAnnotationAttributes(AnnotatedElementUtils.forAnnotations(annotationsToSearch), this.valueAnnotationType);
            if (attr != null) {
                return this.extractValue(attr);
            }
        }
        return null;
    }
}

构建注解@StaticAutowired

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
@Documented
public @interface StaticAutowired{
    /**
    * 是否必须有
    */
    boolean required() default true;
}

构建@StaticAutowired解析类

这块的话主要是对AutowiredAnnotationBeanPostProcessor的一个学习然后好些方法都是从里面拿，主要思路就是从入口方法开始先拿，然后看入口方法里需要啥我们再拿一个，最后再是去修改

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.sonder.ydzy.annotation.StaticAutowired;
import org.sonder.ydzy.annotation.StaticValue;
import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.TypeConverter;
import org.springframework.beans.factory.*;
import org.springframework.beans.factory.annotation.InjectionMetadata;
import org.springframework.beans.factory.config.DependencyDescriptor;
import org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor;
import org.springframework.beans.factory.support.AutowireCandidateResolver;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.support.MergedBeanDefinitionPostProcessor;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.core.Ordered;
import org.springframework.core.PriorityOrdered;
import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.core.annotation.AnnotationAttributes;
import org.springframework.lang.Nullable;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;
import org.springframework.util.ReflectionUtils;
import org.springframework.util.StringUtils;

import java.beans.PropertyDescriptor;
import java.lang.annotation.Annotation;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

@Component
public class StaticAutowiredAnnotationBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {
    protected final Log logger = LogFactory.getLog(this.getClass());

    /**
     * 支持的注解
     */
    private final Set<Class<? extends Annotation>> autowiredAnnotationTypes = new LinkedHashSet<>(4);

    private final String requiredParameterName = "required";

    private final boolean requiredParameterValue = true;

    private final ExContextAnnotationAutowireCandidateResolver
            exContextAnnotationAutowireCandidateResolver = new ExContextAnnotationAutowireCandidateResolver();

    @Nullable
    private DefaultListableBeanFactory beanFactory;

    private final Map<String, InjectionMetadata> injectionMetadataCache = new ConcurrentHashMap(256);

    public StaticAutowiredAnnotationBeanPostProcessor() {
        this.autowiredAnnotationTypes.add(StaticAutowired.class);
        this.autowiredAnnotationTypes.add(StaticValue.class);
    }

    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
        AutowireCandidateResolver autowireCandidateResolver = beanFactory.getAutowireCandidateResolver();
        // 为了 解析 @StaticValue 必须使用 自定义的 ExContextAnnotationAutowireCandidateResolver
        boolean isExContextAnnotationAutowireCandidateResolver = autowireCandidateResolver instanceof ExContextAnnotationAutowireCandidateResolver;
        try {
            if (!isExContextAnnotationAutowireCandidateResolver) {
                beanFactory.setAutowireCandidateResolver(exContextAnnotationAutowireCandidateResolver);
            }
            metadata.inject(bean, beanName, pvs);
        } catch (BeanCreationException ex) {
            throw ex;
        } catch (Throwable ex) {
            throw new BeanCreationException(beanName, "Injection of static autowired dependencies failed", ex);
        } finally {
            // 设置回原来的
            if (!isExContextAnnotationAutowireCandidateResolver) {
                beanFactory.setAutowireCandidateResolver(autowireCandidateResolver);
            }
        }
        return pvs;
    }

    private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
        String cacheKey = StringUtils.hasLength(beanName) ? beanName : clazz.getName();
        InjectionMetadata metadata = (InjectionMetadata) this.injectionMetadataCache.get(cacheKey);
        if (InjectionMetadata.needsRefresh(metadata, clazz)) {
            synchronized (this.injectionMetadataCache) {
                metadata = (InjectionMetadata) this.injectionMetadataCache.get(cacheKey);
                if (InjectionMetadata.needsRefresh(metadata, clazz)) {
                    if (metadata != null) {
                        metadata.clear(pvs);
                    }
                    metadata = this.buildAutowiringMetadata(clazz);
                    this.injectionMetadataCache.put(cacheKey, metadata);
                }
            }
        }
        return metadata;
    }

    private InjectionMetadata buildAutowiringMetadata(Class<?> clazz) {
        List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
        Class<?> targetClass = clazz;
        do {
            List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
            ReflectionUtils.doWithLocalFields(targetClass, (field) -> {
                AnnotationAttributes ann = this.findAutowiredAnnotation(field);
                // 这里改动
                if (ann != null) {
                    if (Modifier.isStatic(field.getModifiers())) {
                        if (logger.isInfoEnabled()) {
                            logger.info("StaticAutowired annotation is supported on static fields: " + field);
                        }
                    }
                    // 这里也有改动让其用我们自己的去处理
                    boolean required = this.determineRequiredStatus(ann);
                    currElements.add(new StaticAutowiredAnnotationBeanPostProcessor.AutowiredFieldElement(field, required));
                }
            });
            elements.addAll(0, currElements);
            targetClass = targetClass.getSuperclass();
        } while (targetClass != null && targetClass != Object.class);
        return new InjectionMetadata(clazz, elements);
    }

    protected boolean determineRequiredStatus(AnnotationAttributes ann) {
        return !ann.containsKey(this.requiredParameterName) || this.requiredParameterValue == ann.getBoolean(this.requiredParameterName);
    }

    @Nullable
    private AnnotationAttributes findAutowiredAnnotation(AccessibleObject ao) {
        if (ao.getAnnotations().length > 0) {
            for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) {
                AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(ao, type);
                if (attributes != null) {
                    return attributes;
                }
            }
        }
        return null;
    }

    @Nullable
    private Object resolvedCachedArgument(@Nullable String beanName, @Nullable Object cachedArgument) {
        if (cachedArgument instanceof DependencyDescriptor descriptor) {
            Assert.state(this.beanFactory != null, "No BeanFactory available");
            return this.beanFactory.resolveDependency(descriptor, beanName, null, null);
        } else {
            return cachedArgument;
        }
    }

    private void registerDependentBeans(@Nullable String beanName, Set<String> autowiredBeanNames) {
        if (beanName != null) {
            for (String autowiredBeanName : autowiredBeanNames) {
                if (this.beanFactory != null && this.beanFactory.containsBean(autowiredBeanName)) {
                    this.beanFactory.registerDependentBean(autowiredBeanName, beanName);
                }
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("Autowiring by type from bean name '" + beanName + "' to bean named '" + autowiredBeanName + "'");
                }
            }
        }
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        if (!(beanFactory instanceof DefaultListableBeanFactory)) {
            throw new IllegalArgumentException("StaticAutowiredAnnotationBeanPostProcessor requires a DefaultListableBeanFactory: " + beanFactory);
        } else {
            this.beanFactory = (DefaultListableBeanFactory) beanFactory;
        }
    }

    @Override
    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
        InjectionMetadata metadata = this.findAutowiringMetadata(beanName, beanType, null);
        metadata.checkConfigMembers(beanDefinition);
    }

    @Override
    public int getOrder() {
        return Ordered.LOWEST_PRECEDENCE - 2;
    }

    private static class ShortcutDependencyDescriptor extends DependencyDescriptor {
        
        private final String shortcut;
        
        private final Class<?> requiredType;
        
        public ShortcutDependencyDescriptor(DependencyDescriptor original, String shortcut, Class<?> requiredType) {
            super(original);
            this.shortcut = shortcut;
            this.requiredType = requiredType;
        }

        @Override
        public Object resolveShortcut(BeanFactory beanFactory) {
            return beanFactory.getBean(this.shortcut, this.requiredType);
        }

    }

    private class AutowiredFieldElement extends InjectionMetadata.InjectedElement {
        private final boolean required;
        
        private volatile boolean cached = false;
        
        @Nullable
        private volatile Object cachedFieldValue;
        
        public AutowiredFieldElement(Field field, boolean required) {
            super(field, (PropertyDescriptor) null);
            this.required = required;
        }

        @Override
        protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
            Field field = (Field) this.member;
            // 把数组改成了的那个元素
            Object value;
            if (this.cached) {
                value = resolvedCachedArgument(beanName, this.cachedFieldValue);
            } else {
                DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
                desc.setContainingClass(bean.getClass());
                Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
                Assert.state(beanFactory != null, "No BeanFactory available");
                TypeConverter typeConverter = beanFactory.getTypeConverter();
                try {
                    value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
                } catch (BeansException var12) {
                    throw new UnsatisfiedDependencyException((String) null, beanName, new InjectionPoint(field), var12);
                }

                synchronized (this) {
                    if (!this.cached) {
                        if (value == null && !this.required) {
                            this.cachedFieldValue = null;
                        } else {
                            this.cachedFieldValue = desc;
                            registerDependentBeans(beanName, autowiredBeanNames);
                            if (autowiredBeanNames.size() == 1) {
                                String autowiredBeanName = (String) autowiredBeanNames.iterator().next();
                                if (beanFactory.containsBean(autowiredBeanName) && beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
                                    this.cachedFieldValue = new StaticAutowiredAnnotationBeanPostProcessor.ShortcutDependencyDescriptor(desc, autowiredBeanName, field.getType());
                                }
                            }
                        }
                        this.cached = true;
                    }
                }
            }

            if (value != null) {
                ReflectionUtils.makeAccessible(field);
                field.set(bean, value);
            }
        }
    }
}

总结

从解析的入口方法开始，从AutowiredAnnotationBeanPostProcessor缺啥拿啥
buildAutowiringMetadata中去掉了对静态属性的直接退出

Elio Potter
关注
自定义注解注入属性值（基于反射和静态变量）
举头三尺有神明
02-17 4261
如何通过Spring配置类处理注解 定义注解 定义一个Spring配置类 在配置类中使用Java反射注入静态属性 定义注解 定义一个注解“Name”，Name注解可以接收一个String类型的属性，并且可以使用在类或者属性上 @Target({ElementType.TYPE, ElementType.FIELD}) @Retention(RetentionPolicy.RUNTIME) @D...
Spring不能注入Static变量的原因及Spring注入静态变量
09-02
主要介绍了Spring不能注入Static变量的原因及Spring注入静态变量,需要的朋友可以参考下
Spring Boot中静态方法与@Component的区别
最新发布
BillKu的博客
07-03 980
特性静态方法@Component类调用方式类名.方法名()通过 Bean 实例调用方法依赖注入不支持（无法@Autowired支持Spring 特性支持不支持（如 AOP、事务）支持状态管理无状态（不操作实例变量）有状态（可操作成员变量）使用场景工具类（如业务组件（如情况是否合理说明静态方法无状态、不访问实例成员✅ 合理作为工具方法补充静态方法操作静态常量✅ 合理适合全局配置静态方法访问@Autowired实例成员❌ 不合理编译错误静态方法依赖其他Spring Bean。
静态方法中调用Spring注入过程解析
08-25
主要介绍了静态方法中调用Spring注入过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
spring注入静态变量
热门推荐
qq_37209293的博客
06-30 24万+
前言 平时开发当中，需要封装工具类，工具类中的方法大多是静态的方法，而静态方法只能调用静态成员变量。静态变量并不属于对象的属性，而是属于类的属性，而Spring则是基于对象的属性进行依赖注入的。所以用注解注入静态变量是不可行的，会一直报NullPointerException 例如 ：直接注入静态的redisTemplate是不行的 @Autowired private static RedisT...
Spring静态变量注入
Dream
02-03 5918
Spring 中静态变量，不能按照普通变量一样，进行注入和获取，需要特殊进行配置。   下面举一个采购网前台的例子。 l       为静态变量设置静态方法。   Java 类定义   ApplicationProperties .java   public class ApplicationProperties {
Spring静态注入
raquelle的记忆宫殿
08-16 789
原文链接：http://blog.csdn.net/chen1403876161/article/details/53644024 spring静态注入的三种方式： (说明：MongoFileOperationUtil是自己封装的一个Mongodb文件读写工具类，里面需要依赖AdvancedDatastore对象实例，dsForRW用来获取Mongodb数据源)
Spring Boot使用Value注解给静态变量赋值的方法
08-27
Spring Boot 使用 Value 注解给静态变量赋值的方法 在 Spring Boot 框架中，我们经常需要将配置文件中的值注入到静态变量中，但是默认情况下，Spring Boot 不支持将值注入到静态变量中。这是因为静态变量是属于类的...
spring boot静态变量注入配置文件详解
08-27
要解决静态变量注入问题，我们可以使用 Spring 的 set 注入方法，通过非静态的 setter 方法注入静态变量。例如，我们可以将 KafkaConfig 类修改为： ```java @Component(value = "KafkaConfig") @...
static静态变量使用@Value注入方式.md
09-26
### static静态变量使用@Value注入方式 #### 一、引言 在Java开发中，特别是基于Spring框架的应用程序中，开发者经常会遇到需要为类中的成员变量注入外部配置值的情况。Spring框架提供了多种注入机制，其中`@Value...
SpringBoot中静态变量注入方案,一网打尽
麦叔
12-15 2372
前言 Hi,大家好,我是麦洛,昨天同事来找我。说自己想使用@Value注解来注入值,但是发现注入不进去,想让我帮忙看看。研究了一番,最后发现是@Value注解无法注入静态变量。下面我们一起来回顾一下本次的bug。 普通变量 首先我们来看看。如何给普通变量注入值？ 例如，application-dev.yml 配置文件有如下配置： 给普通变量赋值时，直接在变量声明之上添加@Value()注解即可，如下所示： 这个大家应该很熟悉了,这里就不再赘述。 静态变量 我们来看看昨天的问题,我们想给项目中的文件上传封
spring实现静态注入
鬼烧java
11-24 210
    在平时的编程过程中，spring的普通类的注入很容易就通过set或者constructer两种方式注入成功，但是有时候一个类用到某种控件中去（比如velocity的工具类中）就需要注入一个dao，但是如果是普通类，是注入不了了，这个时候把dao设置成静态能解决，但是spring注入静态常规写法做不到的，下面介绍一种spring的静态变量注入方式：   先是java文件，    有个静...
spring 对静态变量进行注解
xiaobingtao的专栏
12-11 3694
要对静态变量进行注入 @Resource private static ITecharchService techarchService;//注入为空,spring注解注入不支持静态变量注入 查资料找到可以这样注入 @Component //必须是组件，才可以用@PostConstruct public class DDUtils{ @Resource private ITechar
Spring注入静态变量
weixin_33911824的博客
08-06 404
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring开发-- Spring注入静态变量
下雨天__的专栏
03-15 1561
今天碰到一个问题，我的一个工具类提供了几种静态方法，静态方法需要另外一个类的实例提供处理，因此就写出了这样的代码： 1 Class Util{ 2 private static XXX xxx; 3 xxx = BeanUtil.getBean("xxx"); 4 public static void method1(){ 5 xxx.func1();
Spring注入静态成员变量
qq1192360489的博客
07-15 1259
首先,Spring不支持依赖注入static静态变量 在springframework里,我们不能@Autowired一个静态变量,使之成为一个spring bean,例如下面这样： 我们会发现报了空指针异常 打印一下 发现对象也并没有成功注入. Spring如何给静态变量注入值: 1. set方法上添加@Autowired注解，类定义上添加@Component注解 set方法上添加@Autowired注解，类定义上添加@Component注解 需要注意的是： @Component publ
springboot如何对静态变量注入
02-26
### 如何在 Spring Boot 中对静态变量进行依赖注入 #### 使用 `@PostConstruct` 初始化静态字段 通过定义一个初始化方法并标注为 `@PostConstruct`，可以在对象实例化之后立即执行该方法。此方法可用于设置静态字段...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值