PricingLoginStart free
Scala for Backend Engineering & Functional Programming · Leçon

Gestion des dépendances et modules d’extension

Gérez les bibliothèques externes, déclarez les dépendances et utilisez les modules d’extension SBT pour étendre les fonctionnalités de construction.

Leçon 2 sur 311 étapes

Gestion des dépendances et modules d’extension est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 2 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 3 leçons au total.

Pourquoi utiliser des bibliothèques externes ?

Lors de la création de projets Scala, vous avez souvent besoin de fonctionnalités qui ne font pas partie du langage lui-même. La journalisation, l’accès aux bases de données ou les infrastructures web en sont des exemples courants.

Au lieu d’écrire vous-même tout ce code, vous pouvez utiliser des bibliothèques externes (également appelées dépendances). Il s’agit de paquets de code préécrit que d’autres développeurs ont créés et partagés.

Ajouter des bibliothèques à build.sbt

SBT facilite l’ajout de ces bibliothèques externes. Vous les déclarez dans votre fichier build.sbt à l’aide du paramètre libraryDependencies.

Voici la syntaxe de base :

  • "org.group" : l’identifiant de l’organisation ou du groupe.
  • % "artifact" : l’identifiant de l’artefact (le nom de la bibliothèque). Utilisez %% pour les bibliothèques Scala afin d’adapter automatiquement la version de Scala.
  • % "version" : la version précise de la bibliothèque souhaitée.

Exemple :

libraryDependencies += "org.slf4j" % "slf4j-simple" % "1.7.32"

Portées des dépendances : compilation et tests

Les bibliothèques peuvent n’être nécessaires que pour certaines parties de votre projet. SBT utilise des portées pour gérer cela.

  • compile (par défaut) : nécessaire pour compiler et exécuter votre code principal.
  • test : nécessaire uniquement pour compiler et exécuter votre code de test (par exemple, une infrastructure de test comme ScalaTest).
  • runtime : inutile lors de la compilation, mais requis lorsque l’application s’exécute.

Vous indiquez la portée comme ceci :

libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.16" % "test"

Récupération automatique des dépendances

Imaginez qu’une bibliothèque que vous utilisez, comme une infrastructure web, utilise elle-même d’autres bibliothèques. On les appelle des dépendances transitives.

SBT se charge automatiquement de récupérer toutes ces dépendances indirectes. Lorsque vous ajoutez une bibliothèque, SBT recherche ses propres dépendances et les télécharge également, afin que votre projet dispose de tout ce dont il a besoin.

Vous n’avez ainsi pas à suivre manuellement des dizaines de bibliothèques !

Journaliser avec SLF4J

Utilisons une bibliothèque de journalisation courante, SLF4J (Simple Logging Facade for Java), avec son implémentation simple. Commencez par l’ajouter à votre build.sbt :

libraryDependencies += "org.slf4j" % "slf4j-simple" % "1.7.32"

Exécutez maintenant le code Scala ci-dessous pour voir le résultat. Remarquez que nous importons org.slf4j.LoggerFactory, qui provient de notre nouvelle dépendance.

import org.slf4j.LoggerFactory

object Main {
  private val logger = LoggerFactory.getLogger(getClass.getName)

  def main(args: Array[String]): Unit = {
    logger.info("Hello from a logged message!")
    println("This is a standard print output.")
  }
}

Étendre SBT avec des modules d’extension

Au-delà de la gestion des bibliothèques, SBT lui-même peut être étendu à l’aide de modules d’extension. Ce sont des fichiers JAR spéciaux qui ajoutent de nouvelles commandes ou de nouveaux paramètres à SBT.

Il existe par exemple des modules pour créer des paquets d’applications, les déployer sur des serveurs ou même les intégrer à des outils précis comme les formateurs de code.

Ils contribuent à automatiser les tâches courantes et à fluidifier votre processus de développement.

Déclarer des modules d’extension dans plugins.sbt

Contrairement aux dépendances ordinaires, qui vont dans build.sbt, les modules d’extension SBT sont déclarés dans un fichier spécial : project/plugins.sbt. Ce fichier se trouve dans le répertoire project, à la racine de votre projet SBT.

La syntaxe ressemble à celle des dépendances, mais vous utilisez addSbtPlugin :

addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "2.1.1")

Cela indique à SBT de télécharger et d’activer le module d’extension indiqué pour votre projet.

Créer un JAR autonome avec sbt-assembly

Un module d’extension populaire est sbt-assembly. Il crée un unique « JAR autonome » exécutable contenant le code de votre application et toutes ses dépendances.

Commencez par ajouter le module d’extension à project/plugins.sbt :

addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "2.1.1")

Après l’avoir ajouté, vous pouvez exécuter sbt assembly depuis votre terminal pour créer le JAR. Le code Scala ci-dessous correspond à ce que sbt-assembly empaquetterait.

object Main {
  def main(args: Array[String]): Unit = {
    println("This is a simple application.")
    println("sbt-assembly would package this along with its dependencies into a single JAR.")
  }
}

Gestion des versions et résolveurs

À mesure que votre projet grandit, la gestion de nombreuses dépendances peut devenir délicate. Voici quelques conseils :

  • Versions cohérentes : utilisez la même version d’une bibliothèque dans tous les modules afin d’éviter les conflits.
  • Résolveurs : SBT récupère les bibliothèques depuis des dépôts (comme Maven Central). Vous pouvez ajouter des résolveurs personnalisés si une bibliothèque ne se trouve pas dans les dépôts par défaut.

Par défaut, SBT utilise des dépôts publics standard. Pour les bibliothèques privées, vous devez indiquer un résolveur personnalisé dans build.sbt.

Ordonner les étapes

Vous souhaitez ajouter une nouvelle bibliothèque externe à votre projet Scala et l’utiliser. Placez les étapes suivantes dans le bon ordre.

Réponds-y dans la leçon interactive

Résumé de la leçon

Excellent travail ! Vous avez appris à gérer du code externe dans vos projets Scala.

  • Les dépendances (bibliothèques) sont ajoutées à build.sbt à l’aide de libraryDependencies.
  • SBT gère les dépendances transitives et prend en charge différents contextes (comme compile et test).
  • Les extensions étendent les fonctionnalités de SBT et sont déclarées dans project/plugins.sbt à l’aide de addSbtPlugin.

Maîtriser la gestion des dépendances et des extensions est essentiel pour créer efficacement des applications Scala complexes et robustes !

Gratuit pour commencer

Apprends Scala avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
39
Leçons
143
Commencer gratuitementVoir le cours complet

Questions Fréquemment Posées

La leçon « Gestion des dépendances et modules d’extension » est-elle gratuite ?

Oui — le texte complet de « Gestion des dépendances et modules d’extension » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Gestion des dépendances et modules d’extension » ?

Gérez les bibliothèques externes, déclarez les dépendances et utilisez les modules d’extension SBT pour étendre les fonctionnalités de construction. Tu pratiques Scala for Backend Engineering & Functional Programming avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Scala for Backend Engineering & Functional Programming ?

Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 3.

Combien de temps prend la leçon « Gestion des dépendances et modules d’extension » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Scala for Backend Engineering & Functional Programming ?

Oui. Chaque leçon Scala for Backend Engineering & Functional Programming inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Configuration et bases des projets SBT
  2. Gestion des dépendances et modules d’extension
  3. Constructions multi-projets et déploiement
← Retour à Scala for Backend Engineering & Functional Programming