TOC

Spring @Primary Annotation

Spring @ Primary Annotation

1. Überblick

In diesem kurzen Tutorial werden wir die Annotation@Primaryvon Spring diskutieren, die mit Version 3.0 des Frameworks eingeführt wurde.

Einfach ausgedrückt,we use @Primary to give higher preference to a bean when there are multiple beans of the same type.

Beschreiben wir das Problem im Detail.

2. Warum werden@Primary benötigt?

In einigen Fällenwe need to register more than one bean of the same type.

In diesem Beispiel haben wirJohnEmployee() undTonyEmployee() Bohnen vom TypEmployee: 

@Configuration
public class Config {

    @Bean
    public Employee JohnEmployee() {
        return new Employee("John");
    }

    @Bean
    public Employee TonyEmployee() {
        return new Employee("Tony");
    }
}

Spring throws NoUniqueBeanDefinitionException if we try to run the application.

Um auf Beans mit demselben Typ zuzugreifen, verwenden wir normalerweise die Annotation@Qualifier(“beanName”).

Wir wenden es am Injektionspunkt zusammen mit@Autowired an. In unserem Fall wählen wir die Beans in der Konfigurationsphase aus, sodass@Qualifier hier nicht angewendet werden können. Wir können mehr über die Annotation von@Qualifiererfahren, indem wir denlink folgen.

Um dieses Problem zu beheben, bietet Spring die Annotation@Primaryan.

3. Verwenden Sie@Primary mit@Bean

Werfen wir einen Blick auf die Konfigurationsklasse: 

@Configuration
public class Config {

    @Bean
    public Employee JohnEmployee() {
        return new Employee("John");
    }

    @Bean
    @Primary
    public Employee TonyEmployee() {
        return new Employee("Tony");
    }
}

Wir markierenTonyEmployee() Bohne mit@Primary. Der Frühling injiziertTonyEmployee() Bohne bevorzugt gegenüberJohnEmployee().

Lassen Sie uns nun den Anwendungskontext starten und dieEmployee-Bohne daraus abrufen: 

AnnotationConfigApplicationContext context
  = new AnnotationConfigApplicationContext(Config.class);

Employee employee = context.getBean(Employee.class);
System.out.println(employee);

Nachdem wir die Anwendung ausgeführt haben: 

Employee{name='Tony'}

From the output, we can see that the TonyEmployee() instance has a preference while autowiring.

4. Verwenden Sie@Primary mit@Component

We can use @Primary directly on the beans. Schauen wir uns das folgende Szenario an: 

public interface Manager {
    String getManagerName();
}

Wir haben eineManager-Schnittstelle und zwei Unterklassen-Beans,DepartmentManager: 

@Component
public class DepartmentManager implements Manager {
    @Override
    public String getManagerName() {
        return "Department manager";
    }
}

Und dieGeneralManager Bohne: 

@Component
@Primary
public class GeneralManager implements Manager {
    @Override
    public String getManagerName() {
        return "General manager";
    }
}

Beide überschreiben diegetManagerName() derManager-Schnittstelle. Beachten Sie auch, dass wir dieGeneralManager bean mit@Primary markieren.

Diesmal@Primary only makes sense when we enable the component scan: 

@Configuration
@ComponentScan(basePackages="org.example.primary")
public class Config {
}

Erstellen wir einen Service, um die Abhängigkeitsinjektion zu verwenden und gleichzeitig die richtige Bean zu finden: 

@Service
public class ManagerService {

    @Autowired
    private Manager manager;

    public Manager getManager() {
        return manager;
    }
}

Hier können beide BohnenDepartmentManager und SandGeneralManagerautomatisch verdrahtet werden.

As we marked GeneralManager bean with @Primary, it will be selected for dependency injection: 

ManagerService service = context.getBean(ManagerService.class);
Manager manager = service.getManager();
System.out.println(manager.getManagerName());

Die Ausgabe ist “General manager”.

5. Fazit

In diesem Artikel haben wir etwas über die Annotation@Primaryvon Spring erfahren. Anhand der Codebeispiele haben wir die Notwendigkeit und die Anwendungsfälle von@Primary. demonstriert

Wie üblich ist der vollständige Code für diesen Artikel inover on GitHub project verfügbar.

Related