Gestion des dépendances Java : combien de lignes de code contient mon application ?

Il y a quelques semaines, j’ai eu l’occasion de présenter une conférence lors de la conférence néerlandaise Java JSpring. Mon intervention portait sur la gestion des dépendances Java.

Pendant cette présentation, j’ai créé une application Spring Boot simple et déterminé le nombre de lignes apportées par mes dépendances Java, par rapport au nombre de lignes que j’avais écrites moi-même. L’objectif était de montrer que les dépendances occupent une place importante dans votre application et qu’elles méritent elles aussi toute votre attention. Après la présentation, j’ai publié le tweet suivant, qui a suscité beaucoup d’intérêt et m’a incité à rédiger cet article :

Calculer le nombre de lignes apportées par mes dépendances Java

Étape 1 : générer une application Spring Boot

Tout d’abord, j’ai créé une application Spring Boot à l’aide de Spring Boot Initialzr, avec web comme seule dépendance.

Cela signifie essentiellement que mon projet ne contient que spring-boot-starter-web comme dépendance directe.

Étape 2 : créer un contrôleur REST

Ensuite, j’ai écrit le point de terminaison REST le plus simple qui soit, en 4 lignes :

@RestController
public class Controller {

   @GetMapping("/hello")
   public String hello() {  return "hello"; }
}

Étape 3 : créer le fichier JAR déployable

Le fichier JAR créé à partir de ce projet Java est un JAR « fat » qui contient tous les JAR dont dépend le projet. En effet, Spring Boot intègre essentiellement le serveur d’applications à l’application elle-même.

Étape 4 : analyser le JAR

J’ai ensuite créé une application simple qui exploite le JAR Spring Boot généré. Elle décompresse le fichier JAR et toutes les dépendances qu’il contient. Tous les fichiers de classes des JAR sont décompilés et leurs lignes de code sont comptabilisées.

Étape 5 : recueillir les résultats

• Lignes de code écrites : 4

• JAR : 33

• Fichiers de classes : 9917

• Lignes de code : 518772

Quelques remarques sur les chiffres

Les chiffres ci-dessus sont loin d’être exacts. Les lignes vides et celles qui ne contiennent qu’une accolade ont été ignorées et n’apparaissent donc pas dans le décompte final.

On peut se demander s’il faudrait analyser ces lignes plus en détail et en exclure davantage pour obtenir des chiffres plus précis. De plus, les résultats varient selon le décompilateur utilisé.

Je considère que cela relève davantage de la pseudoscience. Même si les chiffres ne sont pas exacts, ils montrent bien le rôle important que jouent les dépendances dans nos applications. C’était là mon objectif.

Prenez soin de vos dépendances Java

D’accord, les chiffres sont élevés, mais que nous apprend réellement cet exemple ? Tout d’abord, utiliser Spring Boot pour une application Hello World est excessif. Ensuite, Spring Boot est un serveur d’applications : il est donc normal d’obtenir des chiffres aussi élevés, n’est-ce pas ?

Ces remarques sont toutes justes. Je reconnais que c’est le point de terminaison REST le plus inutile qui soit. Cependant, cela met en évidence la part importante que représentent les dépendances dans le binaire que nous mettons en production. Spring Boot étant un framework utilisé par un très grand nombre de développeurs Java, je l’ai délibérément choisi pour cet exemple.

Réfléchissez-y. Dans cet exemple, les lignes de code que j’ai écrites représentent bien moins de 1 % du total des lignes de code que nous mettons en production. Pourtant, en tant qu’équipe, nous sommes responsables de l’ensemble. En cas de problème dans l’application, l’équipe de développement doit le résoudre. La revue de code, la programmation en binôme et l’analyse statique automatisée contribuent assurément à améliorer la base de code. Mais qu’en est-il des 99 % du code que nous utilisons et dont nous dépendons fortement ?

Il est essentiel de prendre soin de vos dépendances et de les mettre à niveau à temps. L’importation d’un package entraîne de nombreuses dépendances et autant de vecteurs d’attaque potentiels. Chaque équipe de développement devrait définir une stratégie de gestion des dépendances Java précisant comment celles-ci sont sélectionnées, mises à jour et supprimées. Du point de vue de la sécurité, vous devriez au minimum être averti si l’une de vos dépendances, directes ou transitives, présente une vulnérabilité.

L’analyse de votre application avec Snyk peut vous aider à détecter les vulnérabilités dans vos dépendances open source. Snyk s’intègre à chaque étape du cycle de vie du développement logiciel (SDLC) et s’adapte facilement : la solution est donc idéale pour l’automatisation. Snyk ne se contente pas de détecter les vulnérabilités : elle vous aide à les repérer le plus tôt possible.

Conclusion

Prendre soin de notre code ne suffit pas toujours : nous devons également surveiller nos dépendances, qui jouent un rôle majeur dans nos applications.

En analysant vos dépendances avec des outils comme Snyk, vous éviterez que leurs vulnérabilités passent inaperçues. De plus, la mise en place d’une stratégie solide de gestion des dépendances Java est essentielle pour garantir que votre application reste facile à maintenir, évolutive, prévisible et, surtout, sécurisée !