Types d'emballage Maven

1. Vue d'ensemble

Le type d'emballage est un aspect important de tout projet Maven. Il spécifie le type d'artefact produit par le projet. Généralement, une construction produit un fichier jar , war , pom ou autre exécutable.

Maven propose de nombreux types d'emballage par défaut et offre également la flexibilité de définir un emballage personnalisé.

Dans ce didacticiel, nous allons approfondir les types d'empaquetage Maven. Tout d'abord, nous allons examiner les cycles de vie de build dans Maven. Ensuite, nous discuterons de chaque type de packaging, de ce qu'ils représentent et de leur effet sur le cycle de vie du projet. Au final, nous verrons comment définir un type d'emballage personnalisé.

2. Types d'emballage par défaut

Maven propose de nombreux types de packaging par défaut qui incluent un jar , war , ear , pom , rar , ejb et maven-plugin . Chaque type de packaging suit un cycle de vie de build qui se compose de phases. Habituellement, chaque phase est une séquence d'objectifs et exécute une tâche spécifique.

Différents types d'emballage peuvent avoir un objectif différent dans une phase particulière. Par exemple, dans la phase de paquet de pot de type d'emballage, maven-plugin-pot but jar » est exécuté. A l'inverse, pour un projet de guerre, l' objectif de guerre de maven-war-plugin est exécuté dans la même phase.

2.1. pot

L'archive Java - ou jar - est l'un des types d'emballage les plus populaires. Les projets avec ce type d'empaquetage produisent un fichier zip compressé avec l' extension .jar . Il peut inclure des classes Java pures, des interfaces, des ressources et des fichiers de métadonnées.

Pour commencer, examinons quelques-unes des liaisons par défaut entre l'objectif et la phase de construction pour le fichier jar :

  • ressources: ressources
  • compilateur: compiler
  • ressources: testResources
  • compilateur: testCompile
  • infaillible: test
  • pot: pot
  • installer: installer
  • déployer: déployer

Sans plus attendre, définissons le type de packaging d'un projet jar :

jar

Si rien n'a été spécifié, Maven suppose que le type d'emballage est un pot.

2.2. guerre

En termes simples, une archive d'application Web - ou war - contient tous les fichiers liés à une application Web. Il peut inclure des servlets Java, des JSP, des pages HTML, un descripteur de déploiement et des ressources associées. Dans l'ensemble, la guerre a les mêmes objectifs qu'un bocal , mais à une exception près - la phase du paquet de la guerre a un objectif différent, qui est la guerre .

Sans aucun doute, jar et war sont les types d'emballage les plus populaires dans la communauté Java. Une différence détaillée entre ces deux pourrait être une lecture intéressante.

Définissons le type de packaging d'une application web:

war

Les autres types de packaging ejb , par et rar ont également des cycles de vie similaires, mais chacun a un objectif de package différent.

ejb:ejb or par:par or rar:rar

2.3. oreille

L'archive d'application d'entreprise - ou oreille - est un fichier compressé contenant une application J2EE. Il se compose d'un ou plusieurs modules qui peuvent être des modules Web (emballés sous forme de fichier war ) ou des modules EJB (conditionnés sous forme de fichier jar ) ou les deux.

Pour le dire différemment, l' oreille est un sur-ensemble de jars et de guerres et nécessite un serveur d'applications pour exécuter l'application, alors que la guerre ne nécessite qu'un conteneur Web ou un serveur Web pour la déployer. Les aspects qui distinguent un serveur Web d'un serveur d'applications, et ce que sont ces serveurs populaires en Java, sont des concepts importants pour un développeur Java.

Définissons les liaisons d'objectifs par défaut pour l' oreille :

  • oreille: generate-application-xml
  • ressources: ressources
  • oreille: oreille
  • installer: installer
  • déployer: déployer

Voici comment nous pouvons définir le type d'emballage de tels projets:

ear

2.4. pom

Parmi tous les types d'emballage, pom est le plus simple. Il aide à créer des agrégateurs et des projets parents.

Un agrégateur ou projet multi-module assemble des sous-modules provenant de différentes sources. Ces sous-modules sont des projets Maven réguliers et suivent leur propre cycle de vie de construction. L'agrégateur POM a toutes les références des sous-modules sous l' élément modules .

Un projet parent vous permet de définir la relation d'héritage entre les POM. Le POM parent partage certaines configurations, plugins et dépendances, ainsi que leurs versions. La plupart des éléments du parent sont hérités par ses enfants - les exceptions incluent artifactId , name et prerequisites .

Parce qu'il n'y a aucune ressource à traiter et aucun code à compiler ou à tester. Par conséquent, les artefacts des projets pom se génèrent eux-mêmes au lieu de tout exécutable.

Définissons le type de packaging d'un projet multi-module:

pom

Ces projets ont le cycle de vie le plus simple qui ne se compose que de deux étapes: l' installation et le déploiement .

2.5. maven-plugin

Maven propose une variété de plugins utiles. Cependant, il peut y avoir des cas où les plugins par défaut ne sont pas suffisants. Dans ce cas, l'outil offre la flexibilité de créer un maven-plugin, en fonction des besoins du projet.

Pour créer un plugin, définissez le type de packaging du projet:

maven-plugin

Le maven-plugin a un cycle de vie similaire au cycle de vie de jar , mais à deux exceptions près:

  • plugin: descriptor is bound to the generate-resources phase
  • plugin: addPluginArtifactMetadata is added to the package phase

For this type of project, a maven-plugin-api dependency is required.

2.6. ejb

Enterprise Java Beans – or ejb – help to create scalable, distributed server-side applications. EJBs often provide the business logic of an application. A typical EJB architecture consists of three components: Enterprise Java Beans (EJBs), the EJB container, and an application server.

Now, let's define the packaging type of the EJB project:

ejb

The ejb packaging type also has a similar lifecycle as jar packaging, but with a different package goal. The package goal for this type of project is ejb:ejb.

The project, with ejb packaging type, requires a maven-ejb-plugin to execute lifecycle goals. Maven provides support for EJB 2 and 3. If no version is specified, then default version 2 is used.

2.7. rar

Resource adapter – or rar – is an archive file that serves as a valid format for the deployment of resource adapters to an application server. Basically, it is a system-level driver that connects a Java application to an enterprise information system (EIS).

Here's the declaration of packaging type for a resource adapter:

rar

Every resource adapter archive consists of two parts: a jar file that contains source code and a ra.xml that serves as a deployment descriptor.

Again, the lifecycle phases are the same as a jar or war packaging with one exception: Thepackage phase executes the rar goal that consists of a maven-rar-plugin to package the archives.

3. Other Packaging Types

So far, we've looked at various packaging types that Maven offers as default. Now, let's imagine we want our project to produce an artifact with a .zip extension. In this case, the default packaging types can't help us.

Maven also provides some more packaging types through plugins. With the help of these plugins, we can define a custom packaging type and its build lifecycle. Some of these types are:

  • msi
  • rpm
  • tar
  • tar.bz2
  • tar.gz
  • tbz
  • zip

To define a custom type, we have to define its packagingtype and phases in its lifecycle. For this, create a components.xml file under the src/main/resources/META-INF/plexus directory:

 org.apache.maven.lifecycle.mapping.LifecycleMapping zip org.apache.maven.lifecycle.mapping.DefaultLifecycleMapping   org.apache.maven.plugins:maven-resources-plugin:resources com.baeldung.maven.plugins:maven-zip-plugin:zip org.apache.maven.plugins:maven-install-plugin:install org.apache.maven.plugins:maven-deploy-plugin:deploy   

Until now, Maven doesn't know anything about our new packaging type and its lifecycle. To make it visible, let's add the plugin in the pom file of the project and set extensions to true:

  com.baeldung.maven.plugins maven-zip-plugin true  

Now, the project will be available for a scan, and the system will look into plugins and compnenets.xml file, too.

Outre tous ces types, Maven propose de nombreux autres types de packaging via des projets externes et des plugins. Par exemple, nar (archive native), swf et swc sont des types de packaging pour les projets qui produisent du contenu Adobe Flash et Flex. Pour de tels projets, nous avons besoin d'un plugin qui définit un packaging personnalisé et d'un référentiel contenant le plugin.

4. Conclusion

Dans cet article, nous avons examiné différents types d'emballage disponibles dans Maven. De plus, nous nous sommes familiarisés avec ce que ces types représentent et en quoi ils diffèrent dans leur cycle de vie. En fin de compte, nous avons également appris à définir un type d'emballage personnalisé et à personnaliser le cycle de vie de construction par défaut.

Tous les exemples de code sur Baeldung sont construits à l'aide de Maven. Assurez-vous de consulter nos différentes configurations Maven sur 0n GitHub.