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

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.

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 updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);

updatedDefinitions.addAll(this.beanDefinitionNames);

updatedDefinitions.add(beanName);

this.beanDefinitionNames = updatedDefinitions;

if (this.manualSingletonNames.contains(beanName)) {

Set 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

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 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里面的方法！

</head>

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

Java设计模式之外观模式示例详解

Java设计模式之享元模式示例详解