Spring Bean-annotaties

Dit artikel maakt deel uit van een reeks: • Spring Core Annotations

• Spring Web-annotaties

• Spring Boot-annotaties

• Annotaties voor voorjaarsplanning

• Spring Data-annotaties

• Spring Bean-annotaties (huidig ​​artikel)

1. Overzicht

In dit artikel bespreken we de meeste gemeenschappelijke Spring bean-annotaties gebruikt om verschillende soorten bonen te definiëren.

Er zijn verschillende manieren om bonen in een Spring-container te configureren. We kunnen ze declareren met behulp van XML-configuratie. We kunnen bonen aangeven met de @Boon annotatie in een configuratieklasse.

Of we kunnen de klas markeren met een van de annotaties uit de org.springframework.stereotype pakket en laat de rest over aan het scannen van componenten.

2. Component scannen

Spring kan automatisch een pakket scannen op bonen als het scannen van onderdelen is ingeschakeld.

@BuienRadarNL configureert welke pakketten om te scannen op klassen met annotatieconfiguratie. We kunnen de basispakketnamen rechtstreeks specificeren met een van de basePackages of waarde argumenten (waarde is een alias voor basePackages):

@Configuration @ComponentScan (basePackages = "com.baeldung.annotations") klasse VehicleFactoryConfig {}

We kunnen ook verwijzen naar klassen in de basispakketten met de basePackageClasses argument:

@Configuration @ComponentScan (basePackageClasses = VehicleFactoryConfig.class) klasse VehicleFactoryConfig {}

Beide argumenten zijn arrays, zodat we voor elk meerdere pakketten kunnen leveren.

Als er geen argument is opgegeven, wordt er gescand vanuit hetzelfde pakket als de @BuienRadarNL geannoteerde klasse is aanwezig.

@BuienRadarNL maakt gebruik van de Java 8-functie voor herhalende annotaties, wat betekent dat we er meerdere keren een klasse mee kunnen markeren:

@Configuration @ComponentScan (basePackages = "com.baeldung.annotations") @ComponentScan (basePackageClasses = VehicleFactoryConfig.class) klasse VehicleFactoryConfig {}

Als alternatief kunnen we gebruiken @ComponentScans om meerdere te specificeren @BuienRadarNL configuraties:

@Configuration @ComponentScans ({@ComponentScan (basePackages = "com.baeldung.annotations"), @ComponentScan (basePackageClasses = VehicleFactoryConfig.class)}) klasse VehicleFactoryConfig {}

Wanneer met behulp van XML-configuratie, is het configureren van het scannen van componenten net zo eenvoudig:

3. @Component

@Component is een annotatie op klasniveau. Tijdens de componentscan, Spring Framework detecteert automatisch klassen die zijn geannoteerd met @Component.

Bijvoorbeeld:

@Component klasse CarUtility {// ...}

Standaard hebben de bean-instanties van deze klasse dezelfde naam als de klassenaam met een kleine letter. Bovendien kunnen we een andere naam specificeren met behulp van de optionele waarde argument van deze annotatie.

Sinds @Repository, @Onderhoud, @Configuratie, en @Controller zijn allemaal meta-annotaties van @Component, delen ze hetzelfde naamgevingsgedrag van de bonen. Spring pikt ze ook automatisch op tijdens het scannen van componenten.

4. @Repository

DAO- of Repository-klassen vertegenwoordigen meestal de databasetoegangslaag in een toepassing en moeten worden geannoteerd met @Repository:

@Repository klasse VehicleRepository {// ...}

Een voordeel van het gebruik van deze annotatie is dat het heeft automatische vertaling van persistentie-uitzonderingen ingeschakeld. Bij gebruik van een persistentiekader zoals Hibernate, worden native uitzonderingen gegenereerd in klassen die zijn geannoteerd met @Repository wordt automatisch vertaald in subklassen van Spring's DataAccessExeption.

Om vertaling van uitzonderingen mogelijk te maken, we moeten de onze aangeven PersistenceExceptionTranslationPostProcessor Boon:

@Bean openbare PersistenceExceptionTranslationPostProcessor exceptionTranslation () {retourneer nieuwe PersistenceExceptionTranslationPostProcessor (); }

Merk op dat Spring in de meeste gevallen de bovenstaande stap automatisch uitvoert.

Of, via XML-configuratie:

5. @Onderhoud

De zakelijke logica van een applicatie bevindt zich meestal binnen de servicelaag - dus gebruiken we de @Onderhoud annotatie om aan te geven dat een klasse tot die laag behoort:

@Service openbare klasse VehicleService {// ...}

6. @Controller

@Controller is een annotatie op klassenniveau die het Spring Framework vertelt dat deze klasse dient als een controller in Spring MVC:

@Controller openbare klasse VehicleController {// ...}

7. @Configuratie

Configuratie klassen kunnen bevatten bonendefinitiemethoden geannoteerd met @Boon:

@ Configuratieklasse VehicleFactoryConfig {@Bean Engine engine () {retourneer nieuwe Engine (); }}

8. Stereotype annotaties en AOP

Wanneer we stereotype annotaties van Spring gebruiken, is het gemakkelijk om een ​​pointcut te maken die zich richt op alle klassen met een bepaald stereotype.

Stel dat we de uitvoeringstijd van methoden uit de DAO-laag willen meten. We zullen het volgende aspect creëren (met behulp van AspectJ-annotaties) gebruikmakend van @Repository stereotype:

@Aspect @Component openbare klasse PerformanceAspect {@Pointcut ("binnen (@ org.springframework.stereotype.Repository *)") openbare ongeldige repositoryClassMethods () {}; @Around ("repositoryClassMethods ()") openbaar object measureMethodExecutionTime (ProceedingsJoinPoint joinPoint) gooit Throwable {long start = System.nanoTime (); Object returnValue = joinPoint.proceed (); lange einde = System.nanoTime (); String methodName = joinPoint.getSignature (). GetName (); System.out.println ("Uitvoering van" + methodName + "nam" + TimeUnit.NANOSECONDS.toMillis (einde - start) + "ms"); terugkeer returnValue; }}

In dit voorbeeld hebben we een pointcut gemaakt die overeenkomt met alle methoden in klassen die zijn geannoteerd met @Repository. We gebruikten de @In de omgeving van advies om vervolgens die pointcut te targeten en de uitvoeringstijd van de onderschepte methodeaanroepen te bepalen.

Met deze aanpak kunnen we logboekregistratie, prestatiebeheer, audit of ander gedrag aan elke applicatielaag toevoegen.

9. Conclusie

In dit artikel hebben we de stereotype annotaties van Spring onderzocht en geleerd welk type semantiek deze elk vertegenwoordigen.

We hebben ook geleerd hoe we componentscanning kunnen gebruiken om de container te vertellen waar geannoteerde klassen te vinden zijn.

Eindelijk - we hebben gezien hoe deze annotaties leiden tot een strak, gelaagd ontwerp en scheiding tussen de zorgen van een aanvraag. Ze maken de configuratie ook kleiner, omdat we bonen niet langer expliciet handmatig hoeven te definiëren.

Zoals gewoonlijk zijn de voorbeelden beschikbaar op GitHub.

« Eerdere annotaties van voorjaarsgegevens