Tipi di imballaggio Maven

1. Panoramica

Il tipo di packaging è un aspetto importante di qualsiasi progetto Maven. Specifica il tipo di artefatto prodotto dal progetto. Generalmente, una build produce un jar , war , pom o altri eseguibili.

Maven offre molti tipi di imballaggi predefiniti e fornisce anche la flessibilità per definirne uno personalizzato.

In questo tutorial, faremo un tuffo nei tipi di packaging Maven. Innanzitutto, esamineremo i cicli di vita della build in Maven. Quindi, discuteremo ogni tipo di imballaggio, cosa rappresentano e il loro effetto sul ciclo di vita del progetto. Alla fine vedremo come definire un tipo di packaging personalizzato.

2. Tipi di imballaggio predefiniti

Maven offre molti tipi di pacchetti predefiniti che includono un jar , war , ear , pom , rar , ejb e maven-plugin . Ogni tipo di packaging segue un ciclo di vita della build che consiste in fasi. Di solito, ogni fase è una sequenza di obiettivi e svolge un'attività specifica.

Diversi tipi di imballaggio possono avere un obiettivo diverso in una fase particolare. Ad esempio, nella fase del pacchetto del tipo di pacchetto jar , viene eseguito l'obiettivo jar di maven-jar-plugin . Al contrario, per un progetto di guerra , l' obiettivo di guerra di maven-war-plugin viene eseguito nella stessa fase.

2.1. vaso

L'archivio Java, o jar , è uno dei tipi di packaging più popolari. I progetti con questo tipo di packaging producono un file zip compresso con estensione .jar . Può includere classi Java pure, interfacce, risorse e file di metadati.

Per cominciare, diamo un'occhiata ad alcune delle associazioni predefinite da obiettivo a fase di compilazione per il jar :

  • risorse: risorse
  • compilatore: compilare
  • risorse: testResources
  • compilatore: testCompile
  • infallibile: prova
  • vaso: vaso
  • installa: installa
  • deploy: deploy

Definiamo senza indugio il tipo di packaging di un progetto jar :

jar

Se non è stato specificato nulla, Maven presume che il tipo di imballaggio sia un barattolo.

2.2. guerra

In poche parole, un archivio di un'applicazione web - o war - contiene tutti i file relativi a un'applicazione web. Può includere servlet Java, JSP, pagine HTML, un descrittore di distribuzione e risorse correlate. Nel complesso, la guerra ha gli stessi vincoli di obiettivo di un barattolo , ma con un'eccezione: la fase di pacchetto della guerra ha un obiettivo diverso, che è la guerra .

Senza dubbio, jar e war sono i tipi di packaging più popolari nella comunità Java. Una differenza dettagliata tra questi due potrebbe essere una lettura interessante.

Definiamo il tipo di packaging di un'applicazione web:

war

Anche gli altri tipi di imballaggio ejb , par e rar hanno cicli di vita simili, ma ognuno ha un obiettivo di pacchetto diverso.

ejb:ejb or par:par or rar:rar

2.3. orecchio

L'archivio dell'applicazione aziendale, o ear , è un file compresso che contiene un'applicazione J2EE. Consiste di uno o più moduli che possono essere moduli web (impacchettati come file war ) o moduli EJB (impacchettati come file jar ) o entrambi.

In altre parole, l' orecchio è un superset di barattoli e guerre e richiede un server delle applicazioni per eseguire l'applicazione, mentre la guerra richiede solo un contenitore web o un server web per distribuirlo. Gli aspetti che distinguono un server Web da un server applicazioni e cosa sono questi server popolari in Java, sono concetti importanti per uno sviluppatore Java.

Definiamo le associazioni di obiettivi predefinite per l' orecchio :

  • orecchio: generate-application-xml
  • risorse: risorse
  • orecchio: orecchio
  • installa: installa
  • deploy: deploy

Ecco come possiamo definire il tipo di packaging di tali progetti:

ear

2.4. pom

Among all packaging types, pom is the simplest one. It helps to create aggregators and parent projects.

An aggregator or multi-module project assembles submodules coming from different sources. These submodules are regular Maven projects and follow their own build lifecycles. The aggregator POM has all the references of submodules under the modules element.

A parent project allows you to define the inheritance relationship between POMs. The parent POM shares certain configurations, plugins, and dependencies, along with their versions. Most elements from the parent are inherited by its children — exceptions include artifactId, name, and prerequisites.

Because there are no resources to process and no code to compile or test. Hence, the artifacts of pom projects generate itself instead of any executable.

Let's define the packaging type of a multi-module project:

pom

Such projects have the simplest lifecycle that consists of only two steps: install and deploy.

2.5. maven-plugin

Maven offers a variety of useful plugins. However, there might be cases when default plugins are not sufficient enough. In this case, the tool provides the flexibility to create a maven-plugin, according to project needs.

To create a plugin, set the packaging type of the project:

maven-plugin

The maven-plugin has a lifecycle similar to jar‘s lifecycle, but with two exceptions:

  • 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.

Oltre a tutti questi tipi, Maven offre molti altri tipi di pacchetti tramite progetti e plug-in esterni. Ad esempio, nar (archivio nativo), swf e swc sono tipi di packaging per i progetti che producono contenuto Adobe Flash e Flex. Per tali progetti, abbiamo bisogno di un plug-in che definisca il packaging personalizzato e un repository che contenga il plug-in.

4. Conclusione

In questo articolo, abbiamo esaminato vari tipi di imballaggi disponibili in Maven. Inoltre, abbiamo acquisito familiarità con ciò che rappresentano questi tipi e come differiscono nei loro cicli di vita. Alla fine, abbiamo anche imparato come definire un tipo di packaging personalizzato e personalizzare il ciclo di vita della build predefinito.

Tutti gli esempi di codice su Baeldung sono costruiti usando Maven. Assicurati di controllare le nostre varie configurazioni Maven su 0n GitHub.