Spring-aantekeningen

Handleidingen
Spring

Spring Annotations stellen ons in staat om afhankelijkheden te configureren en afhankelijkheidsinjectie te implementeren via Java-programma’s.

Spring Annotations

  • Het Spring-framework implementeert en promoot het principe van omgekeerde controle (IOC) of afhankelijkheidsinjectie (DI) en is in feite een IOC-container.
  • Traditioneel stelt Spring een ontwikkelaar in staat om bean-afhankelijkheden te beheren door gebruik te maken van op XML gebaseerde configuratie.
  • Er is een alternatieve manier om beans en hun afhankelijkheden te definiëren. Deze methode is een op Java gebaseerde configuratie.
  • In tegenstelling tot de XML-benadering stelt op Java gebaseerde configuratie je in staat om bean-componenten programmatisch te beheren. Daarom zijn Spring-annotaties geïntroduceerd.

In dit artikel zullen we de meest gebruikte Spring-annotaties verkennen en ook naar enkele voorbeeldprogramma’s kijken.

Lijst van Spring-annotaties

Enkele van de kernframework-annotaties van Spring zijn:

  1. @Configuration: Gebruikt om aan te geven dat een klasse één of meer @Bean-methoden declareert. Deze klassen worden verwerkt door de Spring-container om bean-definities te genereren en serviceverzoeken voor die beans tijdens runtime te verwerken.

  2. @Bean: Geeft aan dat een methode een bean produceert die beheerd moet worden door de Spring-container. Dit is een van de meest gebruikte en belangrijke Spring-annotaties. @Bean-annotatie kan ook worden gebruikt met parameters zoals name, initMethod en destroyMethod.

    • name – stelt je in staat een naam voor de bean op te geven
    • initMethod – stelt je in staat een methode te kiezen die wordt aangeroepen bij het registreren van de context
    • destroyMethod – stelt je in staat een methode te kiezen die wordt aangeroepen bij het afsluiten van de context

    Bijvoorbeeld:

    @Configuration
public class AppConfig {

    @Bean(name = "comp", initMethod = "turnOn", destroyMethod = "turnOff")
    Computer computer(){
        return new Computer();
    }
}

    public class Computer {

    public void turnOn(){
        System.out.println("Besturingssysteem laden");
    }
    public void turnOff(){
        System.out.println("Alle programma's sluiten");
    }
}

  3. @PreDestroy en @PostConstruct zijn alternatieve manieren voor de initMethod en destroyMethod van een bean. Het kan worden gebruikt wanneer de bean-klasse door ons is gedefinieerd. Bijvoorbeeld;

     public class Computer {

    @PostConstruct
    public void turnOn(){
        System.out.println("Besturingssysteem laden");
    }

    @PreDestroy
    public void turnOff(){
        System.out.println("Alle programma's sluiten");
    }
}

  4. @ComponentScan: Configureert richtlijnen voor het scannen van componenten voor gebruik met @Configuration-klassen. Hier kunnen we de basispakketten opgeven om te scannen voor Spring-componenten.

  5. @Component: Geeft aan dat een geannoteerde klasse een “component” is. Dergelijke klassen worden beschouwd als kandidaten voor automatische detectie bij het gebruik van op annotaties gebaseerde configuratie en het scannen van het klassenpad.

  6. @PropertySource: Biedt een eenvoudig declaratief mechanisme om een eigenschappenbron toe te voegen aan de Spring-omgeving. Er is een vergelijkbare annotatie voor het toevoegen van een reeks eigenschappenbronbestanden, namelijk @PropertySources.

  7. @Service: Geeft aan dat een geannoteerde klasse een “Service” is. Deze annotatie dient als een specialisatie van @Component, waardoor implementatieklassen automatisch kunnen worden gedetecteerd via het scannen van het klassenpad.

  8. @Repository: Geeft aan dat een geannoteerde klasse een “Repository” is. Deze annotatie dient als een specialisatie van @Component en is aan te raden voor gebruik met DAO-klassen.

  9. @Autowired: De Spring @Autowired-annotatie wordt gebruikt voor automatische injectie van beans. De Spring @Qualifier-annotatie wordt gebruikt in combinatie met Autowired om verwarring te voorkomen wanneer we twee of meer beans geconfigureerd hebben voor hetzelfde type.

Spring MVC-annotaties

Enkele van de belangrijke Spring MVC-annotaties zijn:

  1. @Controller
  2. @RequestMapping
  3. @PathVariable
  4. @RequestParam
  5. @ModelAttribute
  6. @RequestBody en @ResponseBody
  7. @RequestHeader en @ResponseHeader

Je kunt meer over hen leren op Spring MVC Tutorial.

Spring Transaction Management Annotations

@Transactional is de Spring declaratieve transactiebeheerannotatie, lees meer op Spring MVC Hibernate.

Spring Security Annotations

@EnableWebSecurity wordt gebruikt met de @Configuration-klasse om de Spring Security-configuratie te definiëren, lees meer op Spring Security Example.

Spring Boot Annotations

  1. @SpringBootApplication
  2. @EnableAutoConfiguration

Lees meer op Spring Boot Example.

Spring Annotations Example

Laten we eens kijken naar een eenvoudig voorbeeld waarin we Spring-annotaties zullen gebruiken in onze applicatie. Onderstaande afbeelding illustreert mijn Spring Annotations Example-project.

Spring Framework-afhankelijkheden

I have created the maven project and added Spring Core Framework dependencies.

<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.journaldev.spring</groupId>
	<artifactId>spring-annotations</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>Spring Annotations</name>

	<properties>
		<spring.framework>4.3.0.RELEASE</spring.framework>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.framework}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.framework}</version>
		</dependency>

	</dependencies>

</project>

Dit zal alle spring core jars voor ons project ophalen.

Componentklassen

Volgende stap is het aanmaken van componentklassen. Hier bootst ik meerdere databasecomponenten na, één voor MySQL en een andere voor Oracle.

package com.journaldev.drivers;

public interface DataBaseDriver {
    public String getInfo();
}

DataBaseDriver is de basis interface die we zullen implementeren.

package com.journaldev.drivers;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

@Component
@PropertySource("classpath:mysqldatabase.properties")
public class MySqlDriver implements DataBaseDriver {

    @Value("${databaseName}")
    private String databaseName;
    @Value("${disableStatementPooling}")
    private String disableStatementPooling;

    public String getInfo() {
        return "[ Driver: mySql" +
                ", databaseName: " + databaseName +
                ", disableStatementPooling: " + disableStatementPooling +
                " ]";
    }
}

Merk op het gebruik van de @Component-annotatie om aan te geven aan het Spring-framework om deze klasse als een Component te behandelen. We gebruiken ook de annotaties @PropertySource en @Value; Spring zal deze tijdens runtime gebruiken om variabele waarden in te voegen en in te stellen vanuit het opgegeven propertybestand. Hieronder staan de eigenschappen gedeclareerd in het mysqldatabase.properties-bestand.

databaseName=school
disableStatementPooling=true

package com.journaldev.drivers;

public class OracleDriver implements DataBaseDriver {

    protected String url;
    protected String user;
    protected String password;
    protected String driver;
    protected Integer port;


    public String getUrl() {
        return url;
    }

    public String getUser() {
        return user;
    }

    public void setUser(String user) {
        this.user = user;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getDriver() {
        return driver;
    }

    public void setDriver(String driver) {
        this.driver = driver;
    }

    public Integer getPort() {
        return port;
    }

    public void setPort(Integer port) {
        this.port = port;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getInfo() {
        return "[ Driver: Oracle" +
                ", url: " + url +
                ", port; " + port +
                ", user: " + user +
                ", password: " + password  +
                ", driver: " + driver +
                " ] ";
    }
}

OracleDriver is een eenvoudige bean; we zullen een serviceklasse gebruiken om eigenschappen naar deze bean in te voegen.

Spring Serviceklasse

package com.journaldev.service;

import com.journaldev.drivers.DataBaseDriver;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    @Qualifier("oracleDriver")
    private DataBaseDriver dataBaseDriver;

    public String getDriverInfo(){
        return dataBaseDriver.getInfo();
    }
}

Hier gebruiken we de @Service-annotatie om aan te geven aan het Spring-framework om dit als een Serviceklasse te behandelen. Vervolgens gebruiken we de annotaties @Autowired en @Qualifier("oracleDriver") om het Spring-framework te vertellen om de bean genaamd oracleDriver in te voegen in de klasse-eigenschap dataBaseDriver. Let op dat we deze Spring-bean nog niet hebben aangemaakt.

Spring Beans

Het laatste stap is het aanmaken van onze Spring-beans en configuratieklassen om alles samen te brengen.

package com.journaldev.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;

import com.journaldev.drivers.DataBaseDriver;
import com.journaldev.drivers.MySqlDriver;
import com.journaldev.drivers.OracleDriver;

@Configuration
@ComponentScan("com.journaldev")
@PropertySource("classpath:oracledatabase.properties")
public class AppConfig {

	@Autowired
        Environment environment;
	
	@Bean
	DataBaseDriver oracleDriver() {
        OracleDriver oracleDriver = new OracleDriver();
	oracleDriver.setDriver(environment.getProperty("db.driver"));
        oracleDriver.setUrl(environment.getProperty("db.url"));
        oracleDriver.setPort(Integer.parseInt(environment.getProperty("db.port")));
        oracleDriver.setUser(environment.getProperty("db.user"));
        oracleDriver.setPassword(environment.getProperty("db.password"));

        return oracleDriver;

	}

	@Bean
	DataBaseDriver mysqlDriver() {
		return new MySqlDriver();
	}
}

Merk op de bean-definitie voor oracleDriver. In deze methode lezen we eigenschappen uit het oracledatabase.properties-bestand die worden ingesteld op de environment-variabele door het Spring-framework. Hier zijn de eigenschappen gedefinieerd in het oracledatabase.properties-bestand.

db.url=localhost
db.port=4444
db.user=vasiliy
db.password=yilisav
db.driver=driver_name

Ons voorbeeldproject voor lente-annotaties is klaar om te testen. Als samenvatting hebben we de volgende stappen uitgevoerd:

  1. Maak een Maven-project aan en voeg de vereiste lente-afhankelijkheden toe.
  2. Maak componentklassen aan en injecteer eigenschappen vanuit een bronbestand in de variabele ervan.
  3. Als we een component van een derde partij hebben, kunnen we de Service-klasse gebruiken om afhankelijkheden erin te injecteren. Net zoals we hebben gedaan voor OracleDriver via de UserService-klasse.
  4. Tenslotte hebben we een Configuratieklasse aangemaakt om lente beans te definiëren en de basispakket in te stellen om te scannen naar lente-componentklassen en deze te configureren.

Lente-annotaties Voorbeeld Testen

Hier is onze hoofdklasse om ons voorbeeldproject voor lente-annotaties te testen.

package com.journaldev;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;

import com.journaldev.config.AppConfig;
import com.journaldev.drivers.DataBaseDriver;
import com.journaldev.service.UserService;

public class Main {
	public static void main(String[] args) {
	AbstractApplicationContext appContext = new AnnotationConfigApplicationContext(AppConfig.class);

	DataBaseDriver oracle = appContext.getBean("oracleDriver", DataBaseDriver.class);
	DataBaseDriver mysql = appContext.getBean("mysqlDriver", DataBaseDriver.class);
		
        System.out.println("Oracle driver info:");
        System.out.println(oracle.getInfo());
        
        System.out.println("MySQL driver info:");
        System.out.println(mysql.getInfo());

        System.out.println("UserService Information");
	UserService userService = appContext.getBean(UserService.class);
	System.out.println(userService.getDriverInfo());

	appContext.close();
	}
}

De onderstaande afbeelding toont de geproduceerde uitvoer. Merk op dat we geen logging-framework hebben geconfigureerd, dus alle logging van het lente-framework wordt afgedrukt op de console in rode kleur. Dat is alles voor een korte introductie van lente-annotaties. Hier heb ik de meeste belangrijke annotaties vermeld, maar er zijn er nog veel meer voor specifieke taken. U kunt mijn voorbeeldproject voor lente-annotaties downloaden van onderstaande link.

Download Voorbeeldproject voor Lenteannotaties

Referentie: API-documentatie

Source:
https://www.digitalocean.com/community/tutorials/spring-annotations