Peut-on écrire une application Java Web sans Spring? Comment gérer l’injection de dépendances? Comment gérer la sécurité?

Introduction

Quand on réalise un projet Java webapp, le premier réflexe est d’ajouter (après Maven) Spring. Mais est-ce possible de faire sans?

Pourquoi faire sans?

Pourquoi se passer d’un framework complet utilisé partout? C’est une bonne question. D’abord parce que Spring est devenu très lourd à configurer, tellement que l’équipe a sorti Spring Boot pour pallier à cela (et on se retrouve avec des applis encore plus lourdes). Ensuite parce qu’on utilise pas tout Spring mais principalement une petite partie avec l’injection de dépendances et la sécurité. Alors se demander si on peut trouver plus léger pour ces deux besoins me paraît être une question raisonnable.

Quelles alternatives?

Je dois avouer qu’en cherchant des alternatives, je suis (vite) tombé sur les produits Apache. Si on ajoute que j’utilise déjà les librairies Apache Commons, PdfBox et le serveur Web Tomcat (et aussi TomEE, que je préfère) j’ai vite décidé de faire un projet full Apache (au moins côté back-end) ! Du coup, je n’ai pas cherché ailleurs et je n’ai pas d’alternatives hors Apache à proposer ici.

Stack Apache

Pour construire mon projet, je vais donc utiliser les composants suivants:

Guide de survie, chapitre 1: ajouter l’injection de dépendances

Dans pom.xml, il faut ajouter quelques dépendances, comme ceci:

    
 1<properties>
 2        <deltaspike.version>1.9.4</deltaspike.version>
 3</properties>
 4
 5<dependencyManagement>
 6        <dependencies>
 7            <dependency>
 8                <groupId>org.apache.deltaspike.distribution</groupId>
 9                <artifactId>distributions-bom</artifactId>
10                <version>${deltaspike.version}</version>
11                <type>pom</type>
12                <scope>import</scope>
13            </dependency>
14        </dependencies>
15</dependencyManagement>
16
17<dependencies>
18        <dependency>
19            <groupId>org.apache.deltaspike.core</groupId>
20            <artifactId>deltaspike-core-api</artifactId>
21            <scope>compile</scope>
22        </dependency>
23        <dependency>
24            <groupId>org.apache.deltaspike.core</groupId>
25            <artifactId>deltaspike-core-impl</artifactId>
26            <scope>runtime</scope>
27        </dependency>
28</dependencies>

Il suffit de mettre à jour les dépendances et c’est prêt. Magique, non?

Côté code, rien de sorcier non plus: il faut définir une interface et une classe d’implémentation afin de pouvoir l’injecter. Exemple:

    
 1public interface IUserService {
 2    List<User> getEnabledUsers();
 3}
 4
 5public class UserService implements IUserService {
 6    @Override
 7    public List<User> getEnabledUsers() {
 8        return null; // TODO: please implement search
 9    }
10}
11
12@RequestScoped
13@Path("/login")
14public class WsLogin {
15    private final Logger logger = LogManager.getLogger(WsLogin.class);
16
17    @Inject private IUserService userService;
18}

C’est tout, rien de complexe à mettre en œuvre.

Conclusion

Dans ce premier chapitre, on vient de voir que Spring n’est pas incontournable pour l’aspect CDI d’un projet. Dans le prochain chapitre, on ira un peu plus en détail dans le CDI avec l’injection de propriétés (comme une datasource ou un nom de dossier par exemple).