springboot1.X和2.X中如何解决Bean名字相同时覆盖

目录
  • 如何解决Bean名字相同时覆盖
  • 覆盖重写 原有Spring Bean几种方法
    • 方法1 直接在自己工程中建同包同类名的类进行替换
    • 方法3 排除需要替换的jar包中的类
    • 方法4 @Bean 覆盖
    • 方法5 使用BeanDefinitionRegistryPostProcessor

如何解决Bean名字相同时覆盖

在2版本之前的版本,项目中有两个相同名字的bean是可以启动成功的,但是会有覆盖问题

但是在2.X版本的时候会报错:

could not be registered. A bean with that name has already been defined in class path resource

这时候解决办法可以在配置文件中添加:

spring.main.allow-bean-definition-overriding=true
/** 是否允许使用相同名称重新注册不同的bean实现. 默认是允许*/
private boolean allowBeanDefinitionOverriding = true;
 
/**
 * Set whether it should be allowed to override bean definitions by registering
 * a different definition with the same name, automatically replacing the former.
 * If not, an exception will be thrown. This also applies to overriding aliases.
 * <p>Default is "true".【这里明确说明了默认是true】
 * @see #registerBeanDefinition
 */
public boolean isAllowBeanDefinitionOverriding() {
    return this.allowBeanDefinitionOverriding;
}
 
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
        throws BeanDefinitionStoreException {
 
    Assert.hasText(beanName, "Bean name must not be empty");
    Assert.notNull(beanDefinition, "BeanDefinition must not be null");
 
    if (beanDefinition instanceof AbstractBeanDefinition) {
        try {
            ((AbstractBeanDefinition) beanDefinition).validate();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                    "Validation of bean definition failed", ex);
        }
    }
 
    //bean加载到spring的工程中后,会存储在beanDefinitionMap中,key是bean的名称。
    BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    if (existingDefinition != null) {//不为空,说明相同名称的bean已经存在了
        if (!isAllowBeanDefinitionOverriding()) {//如果不允许相同名称的bean存在,则直接抛出异常
            throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
        }
        else if (existingDefinition.getRole() < beanDefinition.getRole()) {
            // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
            if (logger.isInfoEnabled()) {
                logger.info("Overriding user-defined bean definition for bean '" + beanName +
                        "' with a framework-generated bean definition: replacing [" +
                        existingDefinition + "] with [" + beanDefinition + "]");
            }
        }
        else if (!beanDefinition.equals(existingDefinition)) {
            if (logger.isDebugEnabled()) {
                logger.debug("Overriding bean definition for bean '" + beanName +
                        "' with a different definition: replacing [" + existingDefinition +
                        "] with [" + beanDefinition + "]");
            }
        }
        else {
            if (logger.isTraceEnabled()) {
                logger.trace("Overriding bean definition for bean '" + beanName +
                        "' with an equivalent definition: replacing [" + existingDefinition +
                        "] with [" + beanDefinition + "]");
            }
        }
        //可见,上面allowBeanDefinitionOverriding =true时,只是记录了一些日志,然后后来发现的这个bean,会覆盖之前老的bean。
        this.beanDefinitionMap.put(beanName, beanDefinition);
    }
    else {
        if (hasBeanCreationStarted()) {
            // Cannot modify startup-time collection elements anymore (for stable iteration)
            synchronized (this.beanDefinitionMap) {
                this.beanDefinitionMap.put(beanName, beanDefinition);
                List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
                updatedDefinitions.addAll(this.beanDefinitionNames);
                updatedDefinitions.add(beanName);
                this.beanDefinitionNames = updatedDefinitions;
                if (this.manualSingletonNames.contains(beanName)) {
                    Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
                    updatedSingletons.remove(beanName);
                    this.manualSingletonNames = updatedSingletons;
                }
            }
        }
        else {
            // Still in startup registration phase
            this.beanDefinitionMap.put(beanName, beanDefinition);
            this.beanDefinitionNames.add(beanName);
            this.manualSingletonNames.remove(beanName);
        }
        this.frozenBeanDefinitionNames = null;
    }
 
    if (existingDefinition != null || containsSingleton(beanName)) {
        resetBeanDefinition(beanName);
    }
}

上面贴出来的是spring的代码,而springboot2.X对这个参数又进行了二次封装,springboot中的allowBeanDefinitionOverriding是没有初始化默认值的,我们知道,java中的boolean类型不初始化时是false。

springboot中源代码:

在SpringApplication类中

public class SpringApplication {
    ...
//boolean没初始化,所以默认为false
private boolean allowBeanDefinitionOverriding;
... 
 private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
        context.setEnvironment(environment);
        this.postProcessApplicationContext(context);
        this.applyInitializers(context);
        listeners.contextPrepared(context);
        if (this.logStartupInfo) {
            this.logStartupInfo(context.getParent() == null);
            this.logStartupProfileInfo(context);
        }
 
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
        if (printedBanner != null) {
            beanFactory.registerSingleton("springBootBanner", printedBanner);
        }
       //将false值传过去
        if (beanFactory instanceof DefaultListableBeanFactory) {
            ((DefaultListableBeanFactory)beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
        }
 
        if (this.lazyInitialization) {
            context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
        }
 
        Set<Object> sources = this.getAllSources();
        Assert.notEmpty(sources, "Sources must not be empty");
        this.load(context, sources.toArray(new Object[0]));
        listeners.contextLoaded(context);
    }

而在1.5.8版本中,SpringApplication中,没有allowBeanDefinitionOverriding属性,因此在prepareContext方法中也就没有对allowBeanDefinitionOverriding进行赋值为false,所以在springboot1.5.8版本中默认就是支持名称相同的bean的覆盖。

覆盖重写 原有Spring Bean几种方法

什么情况下要覆写原有的Spring Bean ? 例如引入的第三方jar包中的某个类有些问题,然有没有源码提供或者嫌编译源码太费事,这个时间可以考虑覆写原有的类。

方法1 直接在自己工程中建同包同类名的类进行替换

方式简单粗暴,可以直接覆盖掉jar包中的类,spring项目会优先加载自定义的类。

下面是覆盖 flowable框架中的一个类 FlowableCookieFilter,主要是想修改它里面的redirectToLogin方法的业务逻辑。包路径为 org.flowable.ui.common.filter, 直接工程里面新建一样路径一样类名FlowableCookieFilter即可。

方法2 采用@Primary注解

该方法适用于接口实现类,自己创建一个原jar包接口的实现类,然后类上加上@Primary注解,spring则默认加载该类实例化出的Bean。

下面的例子: 一个接口 RemoteIdmService,原先jar包中只有一个实现类 RemoteIdmServiceImpl,现在自己工程里面创建一个 CustomRemoteIdmServiceImpl 继承RemoteIdmService接口,然后发现所有调用RemoteIdmService接口里面的方法实际调用走的是CustomRemoteIdmServiceImpl 里面的方法。

方法3 排除需要替换的jar包中的类

使用 @ComponentScan 里面的 excludeFilters 功能排除调用要替换的类,然后自己写个类继承替换的类即可。

下面的例子是替换掉 jar包中的PersistentTokenServiceImpl类

@SpringBootApplication
@ComponentScan(excludeFilters = {@ComponentScan.Filter(type =
FilterType.ASSIGNABLE_TYPE, classes = {PersistentTokenServiceImpl.class})})
public class Application {
    public static void main(String[] args) {
        new SpringApplication(Test.class).run(args);
    }
}
@Service
public class MyPersistentTokenServiceImpl extends PersistentTokenServiceImpl{
    @Override
    public Token saveAndFlush(Token token) {
        // 覆写该方法的业务逻辑
        tokenCache.put(token.getId(), token);
        idmIdentityService.saveToken(token);
        return token;
    }
    @Override
    public void delete(Token token) {
        // 覆写该方法的业务逻辑
        tokenCache.invalidate(token.getId());
        idmIdentityService.deleteToken(token.getId());
    }
    @Override
    public Token getPersistentToken(String tokenId) {
        // 覆写该方法的业务逻辑
        return getPersistentToken(tokenId, false);
    }
}

方法4 @Bean 覆盖

该场景针对,框架jar包中有@ConditionalOnMissingBean注解,这种注解是说明如果你也创建了一个一样的Bean则框架就不自己再次创建这个bean了,这样你可以覆写自己的bean。原jar包中的配置类:

直接继承要覆盖的类,自己重写里面方法,使用@Component注入到spring中去

方法5 使用BeanDefinitionRegistryPostProcessor

关于 BeanDefinitionRegistryPostProcessor 、 BeanFactoryPostProcessor可以参考这篇文章:

BeanDefinitionRegistryPostProcessor 说白了就是可以在初始化Bean之前修改Bean的属性,甚至替换原先准备要实例化的bean。

实战演示:

假设jar包中有一个类 MyTestService,正常情况下它会被spring自动扫描到注入IOC容器中去。

package com.middol.mytest.config.beantest.register.jar;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
/**
 * @author guzt
 */
@Service("myTestService")
public class MyTestService {
    private String name1;
    private String name2;
    private String name3;
    public MyTestService() {
        this.name1 = "";
        this.name2 = "";
        this.name3 = "";
    }
    public MyTestService(String name1, String name2, String name3) {
        this.name1 = name1;
        this.name2 = name2;
        this.name3 = name3;
    }
    @PostConstruct
    public void init() {
        System.out.println("MyTestService init");
    }
    @PreDestroy
    public void destory() {
        System.out.println("MyTestService destroy");
    }
    public void show() {
        System.out.println("------------------------");
        System.out.println("我是jar中通过注解@Service主动加入Spring的IOC里面的");
        System.out.println("------------------------");
    }
    public String getName1() {
        return name1;
    }
    public void setName1(String name1) {
        this.name1 = name1;
    }
    public String getName2() {
        return name2;
    }
    public void setName2(String name2) {
        this.name2 = name2;
    }
    public String getName3() {
        return name3;
    }
    public void setName3(String name3) {
        this.name3 = name3;
    }
}

自己工程中继承该类,并且覆写里面的show中的方法

package com.middol.mytest.config.beantest.register;
import com.middol.mytest.config.beantest.register.jar.MyTestService;
/**
 * @author guzt
 */
public class MyTestServiceIpml extends MyTestService {
    public MyTestServiceIpml() {
    }
    public MyTestServiceIpml(String name1, String name2, String name3) {
        super(name1, name2, name3);
    }
    @Override
    public void show() {
        System.out.println("------------------------");
        System.out.println("我是被BeanDefinitionRegistry手动注册到Spring的IOC里面的");
        System.out.println("------------------------");
    }
}

然后 实现 BeanDefinitionRegistryPostProcessor 接口,修改原来bean定义,主要查看postProcessBeanDefinitionRegistry方法的实现,先清空原bean定义,注册我们自己的bean定义来达到替换的目的。

package com.middol.mytest.config.beantest.register;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RestController;
import java.util.Map;
/**
 * @author amdin
 */
@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
    private Logger logger = LoggerFactory.getLogger(this.getClass());
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        logger.info("bean 定义查看和修改...");
        String beanName = "myTestService";
        // 先移除原来的bean定义
        beanDefinitionRegistry.removeBeanDefinition(beanName);
        // 注册我们自己的bean定义
        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.rootBeanDefinition(MyTestServiceIpml.class);
        // 如果有构造函数参数, 有几个构造函数的参数就设置几个  没有就不用设置
        beanDefinitionBuilder.addConstructorArgValue("构造参数1");
        beanDefinitionBuilder.addConstructorArgValue("构造参数2");
        beanDefinitionBuilder.addConstructorArgValue("构造参数3");
        // 设置 init方法 没有就不用设置
        beanDefinitionBuilder.setInitMethodName("init");
        // 设置 destory方法 没有就不用设置
        beanDefinitionBuilder.setDestroyMethodName("destory");
        // 将Bean 的定义注册到Spring环境
        beanDefinitionRegistry.registerBeanDefinition("myTestService", beanDefinitionBuilder.getBeanDefinition());
    }
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        // bean的名字为key, bean的实例为value
        Map<String, Object> beanMap = configurableListableBeanFactory.getBeansWithAnnotation(RestController.class);
        logger.info("所有 RestController 的bean {}", beanMap);
    }
}

写一个 业务类BusinessTestService测试一下,期望结果:所有用到 MyTestService的地方实际调用的变成了MyTestServiceIpml里面的方法。

package com.middol.mytest.config.beantest.register;
import com.middol.mytest.config.beantest.register.jar.MyTestService;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
/**
 * @author guzt
 */
@Service
public class BusinessTestService {
    @Resource
    private MyTestService myTestService;
    @PostConstruct
    public void init() {
        System.out.println(myTestService.getName1());
        System.out.println(myTestService.getName2());
        System.out.println(myTestService.getName3());
        // 看看到底是哪一个Bean
        myTestService.show();
    }
}

控制台打印如下:

可以发现,和我们期望的结果的一样:所有用到 MyTestService的地方实际调用的变成了MyTestServiceIpml里面的方法 !

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • Java的Spring框架中bean的继承与内部bean的注入

    bean的定义继承 bean定义可以包含很多的配置信息,包括构造函数的参数,属性值,比如初始化方法,静态工厂方法名等容器的具体信息. 子bean定义从父定义继承配置数据.子的定义可以覆盖一些值,或者根据需要添加其他. Spring bean定义继承无关,与Java类的继承,但继承的概念是一样的.你可以定义一个父bean定义为模板和其他孩子bean可以从父bean继承所需的配置. 当使用基于XML的配置元数据,指明一个子bean定义使用所在的当前属性指定的父bean作为这个属性的值. 例如: 让我

  • 基于spring同名bean覆盖问题的解决

    目录 spring同名bean覆盖问题 分为两种情况处理 案例如下 spring 子类覆盖父类中注入的bean 抽象基类 另外一个抽象基类 controller spring同名bean覆盖问题 默认情况下,spring在处理同一个ApplicationContext中名称相同的bean时 分为两种情况处理 1.如果两个bean是在同一个配置文件中,那么spring会报错. 2.如果两个bean是在不同的配置文件中,默认情况下,spring会覆盖先前的bean. 在配置文件很多时,如果在启动时,

  • 详解Spring中bean的几种注入方式

    首先,要学习Spring中的Bean的注入方式,就要先了解什么是依赖注入.依赖注入是指:让调用类对某一接口的实现类的实现类的依赖关系由第三方注入,以此来消除调用类对某一接口实现类的依赖. Spring容器中支持的依赖注入方式主要有属性注入.构造函数注入.工厂方法注入.接下来将为大家详细介绍这三种依赖注入的方式以及它们的具体配置方法. 1.属性注入 属性注入即通过setXXX( )方法注入bean的属性值或依赖对象.由于属性注入方式具有可选择性和灵活性高的特点,因此它也是实际开发中最常用的注入方式

  • springboot1.X和2.X中如何解决Bean名字相同时覆盖

    目录 如何解决Bean名字相同时覆盖 覆盖重写 原有Spring Bean几种方法 方法1 直接在自己工程中建同包同类名的类进行替换 方法3 排除需要替换的jar包中的类 方法4 @Bean 覆盖 方法5 使用BeanDefinitionRegistryPostProcessor 如何解决Bean名字相同时覆盖 在2版本之前的版本,项目中有两个相同名字的bean是可以启动成功的,但是会有覆盖问题 但是在2.X版本的时候会报错: could not be registered. A bean wi

  • Android开发中如何解决Fragment +Viewpager滑动页面重复加载的问题

    前言 之前在做一个Viewpager上面加载多个Fragment时总会实例化已经创建好的Fragmnet对象类似 viewPager.setAdapter(new FragmentPagerAdapter(getSupportFragmentManager()) { @Override public Fragment getItem(int position) { switch(position){ case 0: fragments=new Fragmnet01(); break; case

  • 解决bootstrap中使用modal加载kindeditor时弹出层文本框不能输入的问题

    废话不多说了直接给大家贴代码了,具体代码如下所示: $('#myModal').on('shown', function() { $(document).off('focusin.modal'); }); //显示modal $('#myModal').modal('show'); //show完毕前执行 $('#myModal').on('shown', function () { //加上下面这句!解决了~ $(document).off('focusin.modal'); // 打开Dia

  • SqlServer中如何解决session阻塞问题

    简介 对于数据库运维人员来说创建session或者查询时产生问题是常规情况,下面介绍一种很有效且不借助第三方工具的方式来解决类似问题. 最近开始接触运维工作,所以自己总结一些方案便于不懂数据库的同事解决一些不太紧要的数据库问题.类似方法很多理论也很多,我就不做深究,就是简单写一个方案,便于菜鸟使用的. 阻塞理解 在Sql Server 中当一个数据库会话中的事务正锁定一个或多个其他会话事务想要读取或修改的资源时,会产生阻塞(Blocking).通常短时间的阻塞没有问题,且是较忙的应用程序所需要的

  • Android 中解决Viewpage调用notifyDataSetChanged()时界面无刷新的问题

    Android 中解决Viewpage调用notifyDataSetChanged()时界面无刷新的问题 问题描述 相信很多做过Viewpager的人肯定遇到过这个问题,这个是bug还是Android就是如此设计的,我们不做讨论.总之,它确实影响我们功能的实现了. 可能不少同学选择为Viewpager重新设置一遍适配器adapter,达到刷新的目的.但是这种方法在大多数情况下,是有问题的. 解决办法 以我们可以尝试着修改适配器的写法,覆盖getItemPosition()方法,当调用notify

  • Android中利用NetworkInfo判断网络状态时出现空指针(NullPointerException)问题的解决方法

    在Android中,很多人会用如下的方法判断当前网络是否可用: /** * 获取当前网络状态(是否可用) */ public static boolean isNetworkAvailable() { boolean isAalable = false; ConnectivityManager connManager = (ConnectivityManager) BaseApplication.getApplication().getSystemService(Context.CONNECTI

  • Android 系统相机拍照后相片无法在相册中显示解决办法

    Android 系统相机拍照后相片无法在相册中显示解决办法 目前自己使用发送广播实现了效果 public void photo() { Intent openCameraIntent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE); startActivityForResult(openCameraIntent, TAKE_PICTURE); } 解决方法: protected void onActivityResul

  • vue中axios解决跨域问题和拦截器的使用方法

    vue中axios不支持vue.use()方式声明使用. 所以有两种方法可以解决这点: 第一种: 在main.js中引入axios,然后将其设置为vue原型链上的属性,这样在组件中就可以直接 this.axios使用了 import axios from 'axios'; Vue.prototype.axios=axios; components: this.axios({ url:"a.xxx", method:'post', data:{ id:3, name:'jack' } }

  • 详解如何从宿主机拖动复制文件到虚拟机VM中的解决方法

    1.首先要确保自己的虚拟机安装了vmware tools  ①点击虚拟机的 虚拟机(M)->重现安装VMware Tools(T) ②此时系统会弹出装载虚拟CD驱动器 点击打开文件 ③打开文件后可将 文件夹里的文件全部复制到自己的某个文件夹中,例如放在桌面 ④Ctrl+ALT+t打开终端, 输入命令:cd Desktop tar -xvf VMwareTools-10.0.0-2977863.tar.gz(注意:这里的文件名是你自己桌面上那个.gz文件 的名称,根据自己对应的版本来哦) 这时候你

  • Layui之table中的radio在切换分页时无法记住选中状态的解决方法

    情景描述 Layui数据表格中用到了表单元素radio,在当前页面选中radio状态,并同步更新到保存表格中所有的数据的数组中(获取表格中的所有数据并保存到数组中),再点击分页组件中的下一页.上一页.跳转按钮进行切换另外一个页面,然后在切换回之前的页面,会发现在以前页面上radio状态全部恢复默认了,我们当然是希望能保存住前一页radio的选中状态. 我写项目遇到的一个的情况:在第一页选中的radio的状态,点击下一页按钮切换到第二页,然后再点击上一页切换会第一页,第一页中的radio状态就恢复

随机推荐