Conosci rapidamente Maven

Forse non sono sufficientemente competente, ma quando ho iniziato con Maven, ero confuso da vari tutorial non chiari, ma ho scoperto che molte delle sue funzionalità non sono così difficili come si potrebbe pensare.

Questo articolo è rivolto ai principianti di Maven, con l'obiettivo di farli comprendere Maven il più rapidamente possibile e godere di tutti i vantaggi che offre.

[Una domanda semplice]

Prima di procedere con l'insegnamento, faccio una domanda semplice.

Supponiamo che tu stia sviluppando due progetti Java in Eclipse, chiamiamoli A e B, dove alcune funzionalità del progetto A dipendono da alcune classi del progetto B, come mantenere questa relazione di dipendenza?

È così che facevo prima di usare Maven, imballavo il progetto B come jar e lo importavo nel Library del progetto A.

Questo metodo ha chiari svantaggi:

1. Se si scopre un bug in B durante lo sviluppo, è necessario reimballare B e ricompilare il progetto A.

2. Durante lo sviluppo congiunto del progetto A, per garantire che funzioni correttamente, è necessario o scegliere di includere B nel pacchetto di A, o scegliere di distribuire B come farebbe e informare i sviluppatori del metodo d'uso. Sia questo metodo che l'altro non è particolarmente buono, il primo potrebbe comportare uno spreco di risorse (ad esempio, gli sviluppatori potrebbero essere al lavoro su altri progetti che dipendono da B, che è già memorizzato localmente), mentre l'altro potrebbe comportare rischi per il funzionamento del progetto (è noto che affidarsi all'uomo comporta un tasso di fallimento).

Quindi, controllare manualmente le dipendenze tra i progetti è chiaramente un metodo 'imperfetto'.

[Introduzione a Maven]

Secondo il mio parere, la funzione centrale di Maven è la descrizione ragionevole delle dipendenze tra i progetti.

Tutti i progetti Maven contengono un file chiamato pom.xml, nel quale sono registrati i campi <groupId><artifactId><version> e altri, compilati durante la creazione del progetto Maven, che Maven utilizza per localizzare il progetto.

Un altro tag chiave nel pom è <dependencies>, sotto cui possono essere inclusi diversi tag <dependency>, e sotto <dependency> ci sono i campi di dipendenza descritti in precedenza come <groupId><artifactId><version> che determinano una versione di progetto unica.

Un tipico pom.xml [proveniente dal progetto luajava]:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" 
  <modelVersion>4.0.0</modelVersion> 
  <groupId>org.keplerproject</groupId> 
  <artifactId>luajava</artifactId> 
  <version>1.1</version> 
  <packaging>jar</packaging> 
  <name>luajava</name> 
  <url>http://maven.apache.org</url> 
  <properties> 
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> 
  </properties> 
  <build> 
    <plugins> 
      <plugin> 
        <groupId>org.apache.maven.plugins</groupId> 
        <artifactId>maven-compiler-plugin</artifactId> 
        <version>2.0.2</version> 
        <configuration> 
          <source>1.7</source> 
          <target>1.7</target> 
        </configuration> 
      </plugin> 
    </plugins> 
  </build> 
  <dependencies> 
    <dependency> 
      <groupId>junit</groupId> 
      <artifactId>junit</artifactId> 
      <version>3.8.1</version> 
      <scope>test</scope> 
    </dependency> 
  </dependencies> 
</project> 

[Repository Maven]

Prendiamo come esempio i progetti A e B, scriviamo <dependency> per associare il progetto B nel file pom del progetto A, Maven troverà il progetto B nella working area e creerà la dipendenza. In questo momento, il progetto A può accedere direttamente alle risorse delle classi del progetto B, e quando si debugga A, continuerà a colpire i breakpoint impostati nel progetto B.

Oltre alle dipendenze correlate alla working area, Maven può anche associare un progetto in un'immagine remota, per impostazione predefinita, se non ci sono record di progetto corrispondenti nella working area, Maven si connetterà al magazzino centrale per cercare, se trova, lo scaricherà nella libreria locale (sul Windows, la libreria locale si trova nella directory .m2 dei documenti dell'utente), e configurerà automaticamente l'associazione. Questa è una funzionalità molto conveniente, quando abbiamo bisogno di supporto aggiuntivo per jar, non dobbiamo più scaricare e introdurre manualmente, ci basta incollare il campo delle dipendenze del progetto richiesto nel punto appropriato del pom, e il resto lo farà Maven.

[Un esempio]

Allora, come possiamo sapere i campi necessari come groupId del progetto richiesto?

In generale, se un progetto ufficiale supporta Maven, nella sua pagina ci dovrebbe essere un campo delle dipendenze da copiare, ma ci sono anche casi in cui supporta Maven ma non fornisce un campo delle dipendenze. Altri progetti hanno funzionalità Maven mantenute da terze parti, in questo caso è difficile ottenere supporto per Maven dai canali ufficiali.

Quindi, la soluzione preferita per cercare i campi delle dipendenze è utilizzare il servizio di ricerca di Maven.

Ti consiglio un indirizzo: mvnrepository.com

Ecco un esempio di come utilizzare Eclipse per associare il driver MySql JDBC, prima di tutto, conferma il supporto per Maven in Help->About Eclipse:

Nella versione più recente di Eclipse, è già integrato il supporto per Maven, se la versione è più vecchia, puoi installare l'estensione Maven.

Creiamo prima un progetto Maven, New->Project->MavenProject->Create as simple project (skip archetype selection).

Ecco una parte molto importante, riempi i campi di dipendenza del progetto come groupId, ecc. Questi campi verranno utilizzati quando altri progetti si dipenderanno da questo, i campi non compilati sono opzionali:

Poi andiamo a cercare "MySql JDBC" su mvnrepository.com

In breve tempo abbiamo trovato il risultato, clicca per vedere le informazioni dettagliate sulla versione:

Ecco elencate diverse versioni e utilizzi di MySql JDBC, qui scegliamo la seconda versione più recente, 5.1.34:

Copiare il contenuto della casella Maven e scrivetelo sotto <dependencies> del file pom:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" 
  <modelVersion>4.0.0</modelVersion> 
  <groupId>com.test</groupId> 
  <artifactId>maventest</artifactId> 
  <version>0.0.1-SNAPSHOT</version> 
  <dependencies> 
    <dependency> 
      <groupId>mysql</groupId> 
      <artifactId>mysql-connector-java</artifactId> 
      <version>5.1.34</version> 
    </dependency> 
  </dependencies> 
</project> 

Dopo la fine del caricamento di Progress, vedrai che nel progetto sono stati aggiunti Maven Dependencies, dove puoi trovare il pacchetto JDBC driver che abbiamo appena introdotto:

[Altre funzionalità]

1. Repository mirror

Evidentemente, il repository centrale di Maven ha un carico molto alto e non è in Cina, quindi la velocità è molto lenta e a volte non si possono trovare le dipendenze. Pertanto, in particolare in situazioni di sviluppo di team a livello piccolo, costruire un Maven private server può migliorare notevolmente l'efficienza. Consigliamo uno strumento di costruzione di repository mirror Maven: Nexus: http://www.sonatype.org/nexus/

Puoi usarlo per costruire rapidamente e facilmente un repository mirror Maven privato, poi puoi configurarlo nel file settings.xml di Maven.

2. Scaricamento lazy del codice sorgente src

In alcuni casi, possiamo consultare i file sorgenti dei progetti dipendenti, in questo caso possiamo tentare di fare doppio clic sui file class, se ci sono file sorgenti nei repository Maven, saranno scaricati automaticamente localmente e Eclipse li caricherà e li visualizzerà automaticamente.

3. Configurazione dei parametri di compilazione

L'autore utilizza la versione Eclipse Luna, la versione di compilazione Java predefinita di Maven è 1.5, possiamo specificare la versione di compilazione in pom per aumentarla a 1.7 (vedere il tag build in luajavapom); inoltre, queste impostazioni saranno lette e configurate correttamente da strumenti di automazione come Jenkins CI.

Sommario

Questo è tutto il contenuto dell'articolo su come imparare rapidamente Maven, spero sia utile a tutti. Chi è interessato può continuare a consultare altre sezioni correlate su questo sito. Se ci sono punti insufficienti, non esitare a lasciare un commento. Grazie per il supporto degli amici a questo sito!

Dichiarazione: il contenuto di questo articolo è stato tratto da Internet, il copyright è di proprietà del rispettivo proprietario, il contenuto è stato contribuito e caricato autonomamente dagli utenti di Internet, questo sito non detiene il diritto di proprietà, non è stato editato manualmente e non assume alcuna responsabilità legale correlata. Se trovi contenuti sospetti di violazione del copyright, ti preghiamo di inviare una e-mail a: notice#oldtoolbag.com (al momento dell'invio dell'e-mail, sostituisci # con @) per segnalare, fornendo prove pertinenti. Una volta verificata, questo sito eliminerà immediatamente il contenuto sospetto di violazione del copyright.