Why can I create another bean if a @Primary bean exists?

instantiating multiple beans of the same class with spring annotations
spring autowire multiple beans of same type
spring multiple beans of same class
cannot find bean with qualifier
bean definition illegally overridden by existing bean definition
spring override bean in test
spring override component bean
spring boot multiple beans with same name

I don't understand what problem @Primary resolves.

The documentation says:

[@Primary] Indicates that a bean should be given preference when multiple candidates are qualified to autowire a single-valued dependency. If exactly one 'primary' bean exists among the candidates, it will be the autowired value.

Example code:

class Configuration {
   MyType bean1() {
       return new MyType(1);

   MyType bean2() {
       return new MyType(2);


I have 2 beans, bean1 and bean2, both with the type MyType. bean1 has a @Primary annotation, so when I autowire an object of type MyType to some constructor, bean1 will be chosen.

Why is it useful to have two beans of the same type if the primary bean will always be chosen? When and how could I use bean2 which isn't annotated as primary? The example shows that bean2 is redundant and unused.

You can still always qualify which bean you actually want, meaning the primary one will not always be chosen.

class MyComponent
    public MyComponent(@Qualifier("bean2") MyType foo) { /*...*/ } 

@Primary just tells Spring which bean to give precedence to if there are two or more possible candidates. You can always be explicit.

Also, another constructor might take a list of all MyTypes. In which case, both beans would be autowired.

class AnotherComponent
    public AnotherComponent(List<MyType> allFoos) { /*...*/ } 

Spring Couldn't autowired,there is more than one bean of `` type , How do you inject one bean into another in spring? The solution to above problems is to use @Primary annotation. @Primary. This Indicates that a particular bean should be given preference when multiple beans are candidates to be autowired to a single-valued dependency. If exactly one 'primary' bean exists among the candidates, it will be the autowired value.

Say you have multiple instances of beans which have some differences among them. In many cases (say > 90% for example) you will need one of them, and you will rarely use the other ones. In this case it makes sense to annotate as @Primary the most used one and in this way it will be directly injected by the framework when no further specification is provided. In the other case you will specify the exact bean to use using the @Qualifier annotation.

An example can be initializing beans of RestTemplate, say you will define a global one which will have generic settings and will be used accross all application, and another one with some specific retry policy for a small set of use-cases.

Defining the same Spring bean twice with same name, How do you override a bean in a spring boot? Fully-qualified bean references with @Autowired. In addition to being able to reference any particular bean definition as seen above, one @Configuration class may reference the instance of any other @Configuration class using @Autowired. This works because the @Configuration classes themselves are instantiated and managed as individual Spring beans.

So why could I have two beans of the same type if primary bean will be injected?

Actually the primary bean will be only injected if you didn't specify which one of your beans you want to inject, and @Primary is used to specify which bean will be injected when the type is not specified.

And to answer your question, having two beans of the same type is a common way of giving different implementations, there are many cases when we want to use two beans of the same bean, the most common situation is when we want to specify two data sources for the same application.

And to specify which one of our beans we want to go with, we use the @Resource annotation like this:

MyType bean;

For futher details you can check the discussed differences between @Resource and @Autowired.

How to inject inner bean in spring?, Only if this condition is satisfied will the bean be added to the application context. In the same way we might create other modules for cross-cutting concerns like security or Exist") class OnMissingClassModule { }. Annotating a class with the @Configuration annotation indicates that the class will be used by JavaConfig as a source of bean definitions. An application may make use of just one @Configuration-annotated class, or many. @Configuration can be considered the equivalent of XML's <beans/> element.

One of possible usages of @Primary you can override your Bean in tests by set @Primary there. Still your secondary Bean is used when you run an application.

The BeanDefinitionOverrideException in Spring Boot, If exactly one 'primary' bean exists among the candidates, it will be the autowired value. This annotation is semantically equivalent to the <bean> element's  But, as the properties file is configured with the value A only testBeanA will return the bean instance while the other two methods will return NoSuchBeanDefinitionException. If the property value is changed to B then, in that case, bean B will get initialized likewise in the case of C.

Conditional Beans with Spring Boot, What is crucial is that its configuration contained second bean of type ObjectMapper. primary=false; factoryBeanName=processExecutorConfig; We checked if we did not make a typo in qualifier name, but all seemed fine. The method name will determine the name of the created bean or a name/names can be passed into the @Bean annotation. If done via the annotation, simply add the name of the bean or use an array to

Primary (Spring Framework 5.2.7.RELEASE API), Normally when we create a bean we define it by an interface with the bean being a to another you will need to find all of its uses (which could exist in a lot of  Spring Boot with Spring Data makes it easy to access a database through so called Repositories. But what if you want to access multiple databases maybe even with different Database Management…

When two beans collide, We'll also explain how it's different from the @Primary annotation If more than one bean of the same type is available in the container, possible candidates exist for Spring to inject as bean collaborators in a given instance:. Accessing multiple databases in enterprise applications can be a challenge. With Spring it is easy enough to define a common data source, but once we introduce multiple data sources things get tricky.