Spring 4 – Maven Hello World avec de l’Injection de Dépendance

Nous allons tester le framework Spring via une configuration Maven du projet. Le framework Spring est très vaste, nous allons tester uniquement l’injection de dépendance de Spring.

Vous pouvez télécharger le code sur ce repository. Ce code reste très simple, il est destiné aux personnes qui n’ont jamais manipulées Spring avec Maven. Voici un peu d’explication de ce code.

La dépendance Maven

Voici une partie du fichier pom.xml, fichier de configuration d’un projet Maven.

<properties>
	<spring.version>4.3.7.RELEASE</spring.version>
</properties>

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

 

Le projet dépend uniquement de la bibliothèque spring-context, de version 4.3.7. Spring Context, appelé aussi “Spring IoC containers”,  est le module le plus connu de Spring, permettant de faire de l’injection de dépendance.

Cette dépendance est complètement autonome. Par exemple: elle contient  directement la bibliothèque spring-core, noyau de tous les modules Spring.

Classe de configuration Spring: SpringAppConfiguration

Afin de lancer Spring, il faut le configurer. Nous allons passer par une configuration par annotation. On peut configurer Spring aussi avec un fichier XML, mais c’est déprécié.

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = "fr.jmottez.lessons.spring.spring4.service")
public class SpringAppConfiguration {

}

Une classe de configuration Spring porte l’annotation “@Configuration”.

Pour gérer de manière automatique l’injection de dépendance, il faut préciser à Spring l’ensemble des packages où se trouvent les classes à injecter, via l’annotation “@ComponentScan”. Les classes à injecter doivent se trouver dans l’un des packages définis ou dans leurs packages fils.

Les Classes à injecter

J’ai créé 2 classes : AService et BService.

BService

Commençons par BService.

import org.springframework.stereotype.Component;

@Component
public class BService {

	public void call() {
		System.out.println("Hello World of B Spring Instance !!!");
	}

}

Via l’annotation “@Component”, on précise à Spring que cette classe est injectable. On rajoute une fonction call avec un message dans la console.

AService

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class AService {

	@Autowired
	private BService bService;

	public void callBService() {
		bService.call();
	}

}

AService est aussi un component.

Elle a aussi une propriété de BService de nom “bService”. L’annotation “@Autowired” devant la propriété annonce à Spring qu’il faut injecter l’object.

J’ai la fonction “callBService” qui appelle la fonction “call” de propriété “bService”. La propriété n’a pas d’instance. Si Spring n’injecte pas correctement l’object, on aura une exception “null pointeur” à l’appel de cette fonction.

L’exécution

Il y a plus qu’à tester l’application avec une classe exécutable.

import fr.jmottez.lessons.spring.spring4.service.AService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class RunnerApplication {

	public static void main(String[] args) throws Exception {
		ApplicationContext context = new AnnotationConfigApplicationContext(SpringAppConfiguration.class);

		AService aService = (AService) context.getBean("AService");
		aService.callBService();
	}

}

Afin de lancer Spring, il faut lui donner un contexte. Je crée celui-ci avec comme paramètre, la classe de configuration. On peut récupérer une classe gérer par Spring via la fonction “getBean” et le nom de la classe.

Ainsi je récupère une instance de AService et j’exécute la fonction “callBService”. Je n’ai pas d’exception et je vois bien mon message. Ainsi, je peux dire que l’injection Spring s’est bien passé.

Je vous laisse tester par vous même.

Conclusion

Si vous avez des questions, n’hésitez pas à les poser.

 

2 thoughts on “Spring 4 – Maven Hello World avec de l’Injection de Dépendance”

  1. Pingback: Spring Boot 2 – Mon MicroService complet – La pause Dev'

  2. Pingback: Architecture hexagonale: Prends ton livre et n’fais pas de bruit dans ma bibliothèque !! – La pause Dev'

Leave a Reply

Your email address will not be published. Required fields are marked *