快捷導(dǎo)航

Spring覆蓋容器中Bean的注解如何實(shí)現(xiàn)@OverrideBean

更新時(shí)間：2025年01月06日 10:38:45 作者：catoop

文章介紹了在項(xiàng)目開(kāi)發(fā)中如何通過(guò)偷梁換柱的方式重寫(xiě)Spring容器中的內(nèi)置Bean,并指出了需要注意的兩點(diǎn)：1. 對(duì)應(yīng)的Bean應(yīng)基于接口注入；2. 如果不是基于接口注入,可以使用同包名同類名的方式重寫(xiě)（可能存在潛在問(wèn)題,不推薦）,文章還強(qiáng)調(diào)了“基于接口編程”的好處

Spring覆蓋容器Bean的注解實(shí)現(xiàn)@OverrideBean

項(xiàng)目開(kāi)發(fā)中，有時(shí)第三方框架會(huì)自動(dòng)注入Bean到Spring容器中，當(dāng)我們有修改對(duì)應(yīng)內(nèi)置Bean實(shí)現(xiàn)的需求時(shí)，可以采用偷梁換柱的方式來(lái)重寫(xiě)內(nèi)置的Bean，使用這種方式需要注意以下兩點(diǎn)：

1、對(duì)應(yīng)的Bean在其他地方使用時(shí)，是基于接口注入的。
2、如果不是基于接口注入的Bean，你可能需要同包名同類名的這種方式重寫(xiě)（可能會(huì)有問(wèn)題，不推薦）。

從以上2點(diǎn)我們還可以得出一個(gè)結(jié)論，那就是“基于接口編程”的好處。

具體實(shí)現(xiàn)參考一下代碼

（代碼片段，僅供參考，根據(jù)實(shí)際使用場(chǎng)景修改后使用）：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 覆蓋Spring容器中的Bean
 *
 * @author shanhy
 * @date 2021/4/25 13:40
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface OverrideBean {

    /**
     * 需要替換的 Bean 的名稱
     *
     * @return
     */
    String value();
    
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.beans.factory.support.GenericBeanDefinition;
import org.springframework.boot.autoconfigure.AutoConfigurationPackages;
import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.type.filter.AnnotationTypeFilter;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Set;

/**
 * 重寫(xiě)B(tài)ean的配置類
 *
 * @author shanhy
 * @date 2021/4/25 13:41
 */
@Configuration
public class OverrideBeanConfiguration implements BeanDefinitionRegistryPostProcessor, BeanFactoryAware {

    private static final Logger log = LoggerFactory.getLogger(OverrideBeanConfiguration.class);

    private BeanFactory beanFactory;

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        log.debug("searching for classes annotated with @OverrideBean");

        // 自定義 Scanner 掃描 classpath 下的指定注解
        ClassPathOverrideBeanAnnotationScanner scanner = new ClassPathOverrideBeanAnnotationScanner(registry);
        try {
            // 獲取包路徑
            List<String> packages = AutoConfigurationPackages.get(this.beanFactory);

            if (log.isDebugEnabled()) {
                for (String p : packages) {
                    log.debug("Using auto-configuration base package: {}", p);
                }
            }

            // 掃描所有加載的包
            scanner.doScan(StringUtils.toStringArray(packages));
        } catch (IllegalStateException ex) {
            log.debug("could not determine auto-configuration package, automatic OverrideBean scanning disabled.", ex);
        }
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory factory) throws BeansException {
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
    }

    private static class ClassPathOverrideBeanAnnotationScanner extends ClassPathBeanDefinitionScanner {

        ClassPathOverrideBeanAnnotationScanner(BeanDefinitionRegistry registry) {
            super(registry, false);
            // 設(shè)置過(guò)濾器。僅掃描 @OverrideBean
            addIncludeFilter(new AnnotationTypeFilter(OverrideBean.class));
        }

        @Override
        public Set<BeanDefinitionHolder> doScan(String... basePackages) {
            List<String> overrideClassNames = new ArrayList<>();
            // 掃描全部 package 下 annotationClass 指定的 Bean
            Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);

            GenericBeanDefinition definition;
            for (BeanDefinitionHolder holder : beanDefinitions) {
                definition = (GenericBeanDefinition) holder.getBeanDefinition();

                // 獲取類名，并創(chuàng)建 Class 對(duì)象
                String className = definition.getBeanClassName();
                Class<?> clazz = classNameToClass(className);

                // 解析注解上的 value
                OverrideBean annotation = Objects.requireNonNull(clazz).getAnnotation(OverrideBean.class);
                if (annotation == null || annotation.value().length() == 0) {
                    continue;
                }

                // 使用當(dāng)前加載的 @OverrideBean 指定的 Bean 替換 value 里指定名稱的 Bean
                if (Objects.requireNonNull(getRegistry()).containsBeanDefinition(annotation.value())) {
                    getRegistry().removeBeanDefinition(annotation.value());
                    getRegistry().registerBeanDefinition(annotation.value(), definition);
                    overrideClassNames.add(clazz.getName());
                }
            }
            log.info("found override beans: " + overrideClassNames);

            return beanDefinitions;
        }

        // 反射通過(guò) class 名稱獲取 Class 對(duì)象
        private Class<?> classNameToClass(String className) {
            try {
                return Class.forName(className);
            } catch (ClassNotFoundException e) {
                log.error("create instance failed.", e);
            }
            return null;
        }
    }

}