Frühlingskernanmerkungen

Dieser Artikel ist Teil einer Reihe: • Spring Core Annotations (aktueller Artikel) • Spring Web Annotations

• Spring Boot-Anmerkungen

• Anmerkungen zur Frühlingsplanung

• Frühlingsdatenanmerkungen

• Anmerkungen zu Spring Bean

1. Übersicht

Wir können die Funktionen der Spring DI-Engine mithilfe der Anmerkungen in den Paketen org.springframework.beans.factory.annotation und org.springframework.context.annotation nutzen .

Wir nennen diese "Spring Core Annotations" oft und werden sie in diesem Tutorial überprüfen.

2. DI-bezogene Anmerkungen

2.1. @Autowired

Wir können @Autowired verwenden , um eine Abhängigkeit zu markieren, die Spring auflösen und injizieren wird . Wir können diese Annotation mit einem Konstruktor, Setter oder einer Feldinjektion verwenden.

Konstruktorinjektion:

class Car { Engine engine; @Autowired Car(Engine engine) { this.engine = engine; } }

Setter-Injektion:

class Car { Engine engine; @Autowired void setEngine(Engine engine) { this.engine = engine; } }

Feldinjektion:

class Car { @Autowired Engine engine; }

@Autowired hat ein boolesches Argument namens erforderlich mit dem Standardwert true . Es optimiert das Verhalten von Spring, wenn es keine geeignete Bohne zum Verdrahten findet. Wenn true , wird eine Ausnahme ausgelöst, andernfalls wird nichts verkabelt.

Beachten Sie, dass bei Verwendung der Konstruktorinjektion alle Konstruktorargumente obligatorisch sind.

Ab Version 4.3 müssen wir Konstruktoren nicht explizit mit @Autowired versehen, es sei denn, wir deklarieren mindestens zwei Konstruktoren.

Weitere Informationen finden Sie in unseren Artikeln zu @Autowired und Konstruktorinjektion.

2.2. @Bohne

@Bean markiert eine Factory-Methode, die eine Spring Bean instanziiert:

@Bean Engine engine() { return new Engine(); }

Spring ruft diese Methoden auf, wenn eine neue Instanz des Rückgabetyps erforderlich ist.

Die resultierende Bean hat denselben Namen wie die Factory-Methode. Wenn wir wollen , dass es anders nennen, können wir so mit dem tun Namen oder den Wert Argumente dieser Anmerkung (das Argument Wert ist ein Alias für das Argument Name ):

@Bean("engine") Engine getEngine() { return new Engine(); }

Beachten Sie, dass alle mit @Bean kommentierten Methoden in @ Configuration- Klassen vorliegen müssen .

2.3. @Qualifier

Wir verwenden @Qualifier zusammen mit @Autowired , um die Bean-ID oder den Bean-Namen anzugeben , die wir in mehrdeutigen Situationen verwenden möchten.

Die folgenden zwei Beans implementieren beispielsweise dieselbe Schnittstelle:

class Bike implements Vehicle {} class Car implements Vehicle {}

Wenn Spring eine Fahrzeugbohne injizieren muss, werden mehrere übereinstimmende Definitionen angezeigt. In solchen Fällen können wir den Namen einer Bean explizit mithilfe der Annotation @Qualifier angeben .

Konstruktorinjektion verwenden:

@Autowired Biker(@Qualifier("bike") Vehicle vehicle) { this.vehicle = vehicle; }

Setter-Injektion verwenden:

@Autowired void setVehicle(@Qualifier("bike") Vehicle vehicle) { this.vehicle = vehicle; }

Alternative:

@Autowired @Qualifier("bike") void setVehicle(Vehicle vehicle) { this.vehicle = vehicle; }

Feldinjektion verwenden:

@Autowired @Qualifier("bike") Vehicle vehicle;

Für eine detailliertere Beschreibung lesen Sie bitte diesen Artikel.

2.4. @Erforderlich

@ Erforderlich für Setter-Methoden zum Markieren von Abhängigkeiten, die über XML ausgefüllt werden sollen :

@Required void setColor(String color) { this.color = color; }

Andernfalls wird BeanInitializationException ausgelöst.

2.5. @Wert

Wir können @Value verwenden, um Eigenschaftswerte in Beans einzufügen . Es ist kompatibel mit Konstruktor, Setter und Feldinjektion.

Konstruktorinjektion:

Engine(@Value("8") int cylinderCount) { this.cylinderCount = cylinderCount; }

Setter-Injektion:

@Autowired void setCylinderCount(@Value("8") int cylinderCount) { this.cylinderCount = cylinderCount; }

Alternative:

@Value("8") void setCylinderCount(int cylinderCount) { this.cylinderCount = cylinderCount; }

Feldinjektion:

@Value("8") int cylinderCount;

Das Einfügen statischer Werte ist natürlich nicht sinnvoll. Daher können wir Platzhalterzeichenfolgen in @Value verwenden, um Werte zu verdrahten, die in externen Quellen definiert sind , z. B. in .properties- oder .yaml- Dateien.

Nehmen wir die folgende .properties- Datei an:

engine.fuelType=petrol

We can inject the value of engine.fuelType with the following:

@Value("${engine.fuelType}") String fuelType;

We can use @Value even with SpEL. More advanced examples can be found in our article about @Value.

2.6. @DependsOn

We can use this annotation to make Spring initialize other beans before the annotated one. Usually, this behavior is automatic, based on the explicit dependencies between beans.

We only need this annotation when the dependencies are implicit, for example, JDBC driver loading or static variable initialization.

We can use @DependsOn on the dependent class specifying the names of the dependency beans. The annotation's value argument needs an array containing the dependency bean names:

@DependsOn("engine") class Car implements Vehicle {}

Alternatively, if we define a bean with the @Bean annotation, the factory method should be annotated with @DependsOn:

@Bean @DependsOn("fuel") Engine engine() { return new Engine(); }

2.7. @Lazy

We use @Lazy when we want to initialize our bean lazily. By default, Spring creates all singleton beans eagerly at the startup/bootstrapping of the application context.

However, there are cases when we need to create a bean when we request it, not at application startup.

This annotation behaves differently depending on where we exactly place it. We can put it on:

  • a @Bean annotated bean factory method, to delay the method call (hence the bean creation)
  • a @Configuration class and all contained @Bean methods will be affected
  • a @Component class, which is not a @Configuration class, this bean will be initialized lazily
  • an @Autowired constructor, setter, or field, to load the dependency itself lazily (via proxy)

This annotation has an argument named value with the default value of true. It is useful to override the default behavior.

For example, marking beans to be eagerly loaded when the global setting is lazy, or configure specific @Bean methods to eager loading in a @Configuration class marked with @Lazy:

@Configuration @Lazy class VehicleFactoryConfig { @Bean @Lazy(false) Engine engine() { return new Engine(); } }

For further reading, please visit this article.

2.8. @Lookup

A method annotated with @Lookup tells Spring to return an instance of the method’s return type when we invoke it.

Detailed information about the annotation can be found in this article.

2.9. @Primary

Sometimes we need to define multiple beans of the same type. In these cases, the injection will be unsuccessful because Spring has no clue which bean we need.

We already saw an option to deal with this scenario: marking all the wiring points with @Qualifier and specify the name of the required bean.

However, most of the time we need a specific bean and rarely the others. We can use @Primary to simplify this case: if we mark the most frequently used bean with @Primary it will be chosen on unqualified injection points:

@Component @Primary class Car implements Vehicle {} @Component class Bike implements Vehicle {} @Component class Driver { @Autowired Vehicle vehicle; } @Component class Biker { @Autowired @Qualifier("bike") Vehicle vehicle; }

In the previous example Car is the primary vehicle. Therefore, in the Driver class, Spring injects a Car bean. Of course, in the Biker bean, the value of the field vehicle will be a Bike object because it's qualified.

2.10. @Scope

We use @Scope to define the scope of a @Component class or a @Bean definition. It can be either singleton, prototype, request, session, globalSession or some custom scope.

For example:

@Component @Scope("prototype") class Engine {}

3. Context Configuration Annotations

We can configure the application context with the annotations described in this section.

3.1. @Profile

If we want Spring to use a @Component class or a @Bean method only when a specific profile is active, we can mark it with @Profile. We can configure the name of the profile with the value argument of the annotation:

@Component @Profile("sportDay") class Bike implements Vehicle {}

You can read more about profiles in this article.

3.2. @Import

We can use specific @Configuration classes without component scanning with this annotation. We can provide those classes with @Import‘s value argument:

@Import(VehiclePartSupplier.class) class VehicleFactoryConfig {}

3.3. @ImportResource

We can import XML configurations with this annotation. We can specify the XML file locations with the locations argument, or with its alias, the value argument:

@Configuration @ImportResource("classpath:/annotations.xml") class VehicleFactoryConfig {}

3.4. @PropertySource

With this annotation, we can define property files for application settings:

@Configuration @PropertySource("classpath:/annotations.properties") class VehicleFactoryConfig {}

@PropertySource nutzt die Funktion zum Wiederholen von Anmerkungen in Java 8, sodass wir eine Klasse mehrmals damit markieren können:

@Configuration @PropertySource("classpath:/annotations.properties") @PropertySource("classpath:/vehicle-factory.properties") class VehicleFactoryConfig {}

3.5. @PropertySources

Mit dieser Anmerkung können Sie mehrere @ PropertySource- Konfigurationen angeben :

@Configuration @PropertySources({ @PropertySource("classpath:/annotations.properties"), @PropertySource("classpath:/vehicle-factory.properties") }) class VehicleFactoryConfig {}

Beachten Sie, dass wir seit Java 8 dasselbe mit der oben beschriebenen Funktion zum Wiederholen von Anmerkungen erreichen können.

4. Fazit

In diesem Artikel haben wir einen Überblick über die häufigsten Anmerkungen zum Spring Core erhalten. Wir haben gesehen, wie Sie die Bean-Verkabelung und den Anwendungskontext konfigurieren und Klassen für das Scannen von Komponenten markieren.

Wie üblich sind die Beispiele auf GitHub verfügbar.

Weiter » Spring Web Annotations