Compléments à "Spring par la pratique, 2nde édition"

L'annotation @Inject indique d'injecter une dépendance, de la même manière que l'annotation Spring @Autowired :

package splp.v2.task;

import javax.inject.Inject;

public class MyService {

  @Inject
  private MyDao myDao;
	
  public MyDao getMyDao() {
    return myDao;
  }
	
}

Contrairement à @Autowired, @Inject ne dispose pas d'un attribut required. Elle indique donc systématiquement une dépendance obligatoire. A noter que @Inject est aussi reconnue pour l'injection dans les tests unitaires :

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class Jsr330Test {

  @Inject
  private MyService myService;
  
  @Test public void inject() {
    Assert.assertNotNull(myService.getMyDao());
  }
}			

@Inject étant une annotation standard, elle est donc à préférer à @Autowired.

La JSR-330 introduit l'annotation @javax.inject.Qualifier qui permet d'affiner l'injection automatique, notamment quand il y a des conflits de types. Reprenons l'exemple du livre (page 47). Un service d'alerte peut envoyer des messages de deux façons différentes, selon le type d'abonnement du client :

public class AlerteClientManager {

  @Inject
  private MessageSender senderPourAbonnementGold;
	
  @Inject
  private MessageSender senderPourAbonnementStandard;
  
  (...)
	
}

Il y a deux implémentations de MessageSender : SmsMessageSender (pour les abonnements gold) et EmailMessageSender (pour les abonnements standards). Comme ces deux implémentations sont cachées derrière leur interface pour l'injection automatique, Spring n'est pas capable de savoir lequel injecter dans la bonne propriété. Il existe plusieurs façons de remédier à ce problème et elles sont toutes bâties sur l'utilisation de l'annotation @Qualifier de la JSR-330 (et non pas celle de Spring, qui marche d'une façon différente !).

La première solution consiste à définir notre propre annotation @Sender, qui permettra de qualifier les dépendances :

package splp.v2.jsr330;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import javax.inject.Qualifier;

@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface Sender {
  String value();
}

Remarquez que notre annotation porte elle-même l'annotation @Qualifier. On peut ensuite qualifier les dépendances avec :

package splp.v2.jsr330;

import javax.inject.Inject;

public class AlerteClientManager {

  @Inject
  @Sender("goldMessageSender")
  private MessageSender senderPourAbonnementGold;
	
  @Inject
  @Sender("standardMessageSender")
  private MessageSender senderPourAbonnementStandard;
  
  (...)
	
}

Dans la déclaration XML des MessageSenders, les deux beans doivent porter le nom de leur qualification :

<?xml version="1.0" encoding="UTF-8"?>
<beans>
	
  <bean id="alerteClientManager" class="splp.v2.jsr330.AlerteClientManager" />
	
  <bean id="standardMessageSender" class="splp.v2.jsr330.EmailMessageSender" />
	
  <bean id="goldMessageSender" class="splp.v2.jsr330.SmsMessageSender" />

</beans>

La deuxième solution utilise aussi l'annotation @Sender et est 100% annotation : les beans ne sont plus déclarés dans un fichier XML, on utilise le component scanning pour les instancier et les MessageSenders se voient apposer l'annotation Sender directement sur leur classe. Le fichier de contexte Spring :

<?xml version="1.0" encoding="UTF-8"?>
<beans>
			
  <context:component-scan base-package="splp.v2.jsr330" />
			
</beans>

Et les deux implémentations de MessageSender :

@Sender("standardMessageSender")
@Component
public class EmailMessageSender implements MessageSender {

  (...)
		
}

@Sender("goldMessageSender")
@Component
public class SmsMessageSender implements MessageSender {

  (...)
  
}

La 3ème et dernière solution est aussi 100% annotation et ne repose pas sur des chaînes de caractères pour identifier les dépendances. Elle n'utilise pas l'annotation @Sender mais se base plutôt sur deux annotations, une pour chaque type de MessageSenders :

import javax.inject.Qualifier;

@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface SenderStandard { }
			
			
import javax.inject.Qualifier;

@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface SenderGold { }

Les deux implémentations de MessageSender se voient apposer l'annotation correspondante :

@SenderStandard
@Component
public class EmailMessageSender implements MessageSender {
  (...)
}			

@SenderGold
@Component
public class SmsMessageSender implements MessageSender {
  (...)
}

Enfin, les dépendances sont qualifiées de la même façon sur le service d'alerte :

@Component
public class AlerteClientManager {

  @Inject
  @SenderGold
  private MessageSender senderPourAbonnementGold;
	
  @Inject
  @SenderStandard
  private MessageSender senderPourAbonnementStandard;

  (...)
  
}

Remarquez que cette dernière solution est la plus sûre en termes de typage (on ne se fie pas juste à des chaînes de caractères et cela évite de se tromper à cause de fautes de frappes).

Les méta-données en Java se basent sur deux annotations :

Voici un exemple de configuration Java produisant un service métier et un DAO :

package splp.v2.annotconfig.conf;

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

import splp.v2.annotconfig.app.dao.MyDao;
import splp.v2.annotconfig.app.dao.impl.MyDaoImpl;
import splp.v2.annotconfig.app.service.MyService;
import splp.v2.annotconfig.app.service.impl.MyServiceImpl;

@Configuration
public class BusinessConfiguration {

  @Bean
  public MyService myService() {
    return new MyServiceImpl();
  }
	
  @Bean
  public MyDao myDao() {
    return new MyDaoImpl();
  }
	
}

C'est donc ce code qui va être chargé de créer les beans. Pour faire un parallèle avec une configuration XML, la classe BusinessConfiguration serait le fichier XML et chaque méthode annotée avec @Bean une balise bean.

Spring honore aussi les annotations apposées sur les Beans produits, par exemple pour les méthodes d'initialisation ou encore l'autowiring. Ainsi, le service précédent peut se voir injecter le DAO grâce à l'annotation @Inject :

public class MyServiceImpl implements MyService {

  @Inject
  private MyDao myDao;
	
  (...)
	
}

Voyons maintenant comment exploiter les méta-données Java dans une application autonome puis dans une application Web.

La classe AnnotationConfigApplicationContext permet de créer un contexte Spring à partir d'une configuration Java (c'est-à-dire une ou plusieurs classes annotées avec @Configuration). Voici le démarrage d'un contexte Spring dans un test unitaire avec la configuration Java précédente :

package splp.v2.annotconfig;
(...)
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class AnnotConfigTest {

  @Test public void createAnnotContextWithClass() {
    ApplicationContext ctx = new AnnotationConfigApplicationContext(BusinessConfiguration.class);		
    MyServiceImpl service = ctx.getBean(MyServiceImpl.class);
    Assert.assertNotNull(service.getMyDao());
  }
}

L'AnnotationConfigApplicationContext est aussi capable de scanner des répertoires pour trouver les classes annotées avec @Configuration :

package splp.v2.annotconfig;
(...)
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class AnnotConfigTest {
  @Test public void createAnnotContextWithComponentScanning() {
    ApplicationContext ctx = new AnnotationConfigApplicationContext("splp.v2.annotconfig.conf");
		
    MyServiceImpl service = ctx.getBean(MyServiceImpl.class);
    Assert.assertNotNull(service.getMyDao());
  }
}

La classe AnnotationConfigWebApplicationContext permet de créer un contexte Spring pour le Web soit pour l'application Web (via le ContextLoaderListener), soit pour une Servlet Spring. Il faut pour cela préciser quelques paramètres supplémentaires dans le web.xml : la classe du contexte et les configurations Java à utiliser. Voyons pour le contexte Spring d'une application Web :

<web-app (...)>
     
  <context-param>
    <param-name>contextClass</param-name>
    <param-value>
    org.springframework.web.context.support.AnnotationConfigWebApplicationContext
    </param-value>
  </context-param>
    
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>splp.v2.annotconfig.conf.BusinessConfiguration</param-value>
  </context-param>
    
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  (...)   
</web-app>

Il est aussi possible de préciser des packages qui seront parcourus pour trouver des classes annotées avec @Configuration :

<web-app (...)>
     
  (...)
    
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>splp.v2.annotconfig.conf</param-value>
  </context-param>
  
  (...)   
</web-app>

La configuration Java permet aussi de gérer les portées ("scope"). Reprenons l'exemple du livre (page 67), qui consiste à injecter un bean de portée session (contenant les informations utilisateur) dans un singleton. Voici la configuration XML :

<bean id="businessService" class="splp.sample.BusinessServiceImpl">
  <property name="infoUtilisateur" ref="infoUtilisateur" />
</bean>
    
<bean id="infoUtilisateur" class="splp.sample.InfoUtilisateurImpl" scope="session">
  <aop:scoped-proxy proxy-target-class="false"/>
</bean>

Il est possible de faire l'équivalent en configuration Java en ajoutant une annotation @Scope sur la méthode @Bean correspondant à la création de l'objet InfoUtilisateur :

package splp.v2.chap03.scope.javaconfig;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
import org.springframework.context.annotation.ScopedProxyMode;

import splp.sample.BusinessService;
import splp.sample.BusinessServiceImpl;
import splp.sample.InfoUtilisateur;
import splp.sample.InfoUtilisateurImpl;

@Configuration
public class BusinessConfiguration {
	
  @Bean @Scope(value="session",proxyMode=ScopedProxyMode.INTERFACES)
  public InfoUtilisateur infoUtilisateur() {
    return new InfoUtilisateurImpl();
  }
	
  @Bean
  public BusinessService businessService() {
    BusinessServiceImpl service = new BusinessServiceImpl();
    service.setInfoUtilisateur(infoUtilisateur());
    return service;
  }
	
}