解决：Springboot Caused by: org.springframework.context.annotation.ConflictingBeanDefinitionException

谁践踏了优雅 2024-02-20 12:53 11阅读 0赞

解决方案

1. 检查类路径扫描配置

2. 使用@Primary注解

3. 使用@Qualifier注解

4. 使用排除注解

5. 检查依赖冲突

结论

--------------------

### 解决：Springboot Caused by: org.springframework.context.annotation.ConflictingBeanDefinitionException ###

在使用Spring Boot开发项目时，有时候会遇到类似的异常信息：

javaCopy codeCaused by: org.springframework.context.annotation.ConflictingBeanDefinitionException:
    Annotation-specified bean name 'xxxx' for bean class [xxx]
    conflicts with existing, non-compatible bean definition of same name and class [xxx]

这个异常通常是由于Spring容器中存在多个相同名称的Bean定义所导致的。当Spring尝试将这些Bean注入到其他对象中时，会发现存在冲突，从而抛出这个异常。

### 解决方案 ###

#### 1. 检查类路径扫描配置 ####

首先，我们需要检查Spring Boot应用的类路径扫描配置。在Spring Boot中，使用`@SpringBootApplication`注解来标记主应用类。这个注解实际上是`@Configuration`、`@EnableAutoConfiguration`和`@ComponentScan`三个注解的组合。 `@ComponentScan`注解用于扫描指定包及其子包下的组件，如果重复地扫描了同一个包，就有可能导致相同名称的Bean被多次定义，从而引发冲突。因此，我们需要确保`@ComponentScan`注解的扫描范围不会重复。

javaCopy code@SpringBootApplication
    public class Application {
      public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
      }
    }

例如，如果我们在`Application`类上方有额外的`@ComponentScan`注解，而且它的扫描范围包含了与异常信息中冲突的Bean类，就会导致冲突的Bean被重复定义。 所以，我们需要仔细检查主应用类以及其他配置类上的扫描注解，确保它们不会导致重复的扫描。

#### 2. 使用@Primary注解 ####

如果在不同的配置类中定义了相同名称的Bean，并且这些Bean的类型相同或相兼容，就会引发冲突。为了解决这个问题，可以使用`@Primary`注解来明确指定首选的Bean定义。 在引发冲突的那个Bean定义上加上`@Primary`注解，可以告诉Spring容器优先选择这个定义。这样一来，在注入时就不会再出现冲突。 示例：

javaCopy code@Configuration
    public class AppConfig {
      @Bean
      @Primary
      public MyBean myBean() {
        return new MyBean();
      }
    }

#### 3. 使用@Qualifier注解 ####

另一种解决方案是通过使用`@Qualifier`注解来明确指定使用哪个Bean定义。 在需要注入的地方，使用`@Qualifier`注解并指定要使用的Bean的名称。通过这种方式，可以确保注入的是正确的Bean定义。 示例：

javaCopy code@Service
    public class MyService {
      private final MyBean myBean;
      public MyService(@Qualifier("myBean") MyBean myBean) {
        this.myBean = myBean;
      }
    }

#### 4. 使用排除注解 ####

如果冲突的Bean定义是通过某个特定的注解进行的，我们还可以使用`@ComponentScan`的`excludeFilters`属性来排除掉其中一个定义。 在主应用类上的`@ComponentScan`注解中，添加`excludeFilters`属性，并指定要排除的注解。这样一来，冲突的定义就会被排除在外，从而解决冲突。 示例：

javaCopy code@SpringBootApplication(exclude = @Filter(type = FilterType.ANNOTATION, classes = MyExcludeAnnotation.class))
    public class Application {
      public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
      }
    }

#### 5. 检查依赖冲突 ####

最后，我们还需要检查项目的依赖关系，确保没有引入不兼容的依赖版本。 在开发过程中，我们可能会有多个依赖项引入相同的库，但却版本不同。这可能导致不同版本的Bean定义无法兼容，从而引发冲突。 使用合适的依赖管理工具，如Maven或Gradle，可以确保项目中的依赖版本一致，并解决潜在的冲突问题。

### 结论 ###

当遇到Spring Boot中`ConflictingBeanDefinitionException`异常时，我们可以通过检查类路径扫描配置、使用`@Primary`注解或`@Qualifier`注解、使用排除注解以及检查依赖冲突等方法来解决问题。 通过合理配置和解决冲突，我们可以顺利运行Spring Boot应用，并确保正确注入所需的Bean。

假设有一个简单的订单管理系统，包含订单服务和支付服务。订单服务中有一个`OrderService`类，支付服务中有一个`PaymentService`类。这两个类分别会定义一个名为`commonService`的Bean。 在订单服务的配置类中，我们定义了一个`commonService`的Bean：

javaCopy code@Configuration
    public class OrderServiceConfig {
        @Bean
        public CommonService commonService() {
            return new CommonService();
        }
    }

在支付服务的配置类中，我们也定义了一个同名的`commonService`的Bean：

javaCopy code@Configuration
    public class PaymentServiceConfig {
        @Bean
        public CommonService commonService() {
            return new CommonService();
        }
    }

在这种情况下，由于存在相同名称的Bean定义，当我们在其他类中尝试注入`commonService`时，就会抛出`ConflictingBeanDefinitionException`异常。 为了解决这个问题，我们可以使用`@Primary`注解来指定主要的Bean定义。我们在订单服务的配置类中，给`commonService`的Bean方法添加`@Primary`注解：

javaCopy code@Configuration
    public class OrderServiceConfig {
        @Bean
        @Primary
        public CommonService commonService() {
            return new CommonService();
        }
    }

这样一来，在其他类中注入`commonService`时，就会使用订单服务中的Bean定义，避免了冲突。 另一种解决方法是使用`@Qualifier`注解来明确指定使用哪个Bean定义。在注入`commonService`的地方，我们使用`@Qualifier`注解并指定要使用的Bean的名称，如下所示：

javaCopy code@Service
    public class OrderService {
        private final CommonService commonService;
        public OrderService(@Qualifier("orderServiceCommonService") CommonService commonService) {
            this.commonService = commonService;
        }
    }

在订单服务的配置类中，我们给`commonService`的Bean方法添加了一个自定义的`@Qualifier`注解：

javaCopy code@Configuration
    public class OrderServiceConfig {
        @Bean
        @OrderServiceCommonService
        public CommonService commonService() {
            return new CommonService();
        }
    }

这样一来，通过自定义的`@Qualifier`注解，我们可以明确指定使用订单服务中的Bean定义。 以上是两种解决方案的示例代码，根据实际的应用场景和具体的代码结构，你可以选择合适的方案来解决`ConflictingBeanDefinitionException`异常。

在Spring框架中，Bean的注入是一种由框架自动管理的依赖注入方式，通过注入其他对象，可以方便地实现对象之间的解耦，提高代码的可维护性和可测试性。Spring提供了多种方式来实现Bean的注入，包括构造器注入、Setter方法注入和字段注入等。

1.  构造器注入： 构造器注入是最常见的一种注入方式，通过构造函数将依赖的对象作为参数传入。Spring容器会自动识别参数类型，并将相应的Bean注入到构造函数中。示例代码如下：

javaCopy codepublic class UserService {
        private UserRepository userRepository;
      
        public UserService(UserRepository userRepository) {
            this.userRepository = userRepository;
        }
        
        //...
    }

1.  Setter方法注入： Setter方法注入是通过提供Setter方法将依赖的对象注入。Spring容器会自动调用相应的Setter方法完成注入。示例代码如下：

javaCopy codepublic class OrderService {
        private ProductService productService;
        public void setProductService(ProductService productService) {
            this.productService = productService;
        }
        
        //...
    }

1.  字段注入： 字段注入是将依赖的对象直接注入到类的字段中。Spring容器会通过反射机制将Bean实例直接注入到被注解的字段中。示例代码如下：

javaCopy codepublic class PaymentService {
        @Autowired
        private PaymentGateway paymentGateway;
        
        //...
    }

除了上述的注入方式，还可以使用@Resource注解或@Qualifier注解来指定具体要注入的Bean。@Resource注解可以根据字段名或名称来指定注入的Bean，而@Qualifier注解可以结合@Autowire或@Resource注解使用来指定注入的Bean的名称。 无论使用哪种注入方式，Spring容器都会根据配置文件或注解中的元数据信息，自动进行Bean的查找和注入。这样就可以实现对象之间的自动关联，并且不需要显式地在代码中创建和管理对象之间的依赖关系。这大大简化了代码的编写和维护工作。