java - starter - Modulo Maven con avvio a molla

spring-boot-starter-web (2)

Non è necessario utilizzare il genitore di avvio di avvio a molla, è solo un modo per iniziare rapidamente. Tutto ciò che fornisce sono la gestione delle dipendenze e la gestione dei plugin. Puoi fare entrambe le cose, e puoi usare le dipendenze boot-spring (o equivalentemente il genitore) per gestire le dipendenze se vuoi un passaggio a metà. Per farlo, usa scope=import come questo

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <type>pom</type>
            <version>1.0.2.RELEASE</version>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Mi piace configurare le mie applicazioni in Maven creando moduli come;

<groupId>com.app</groupId>
<artifactId>example-app</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>pom</packaging>

<modules>
    <module>app-api</module>
    <module>app-impl</module>
    <module>app-web</module>
</modules>

I moduli quindi usano l'app di esempio come genitore.

Ora voglio usare 'spring-boot' per la mia applicazione web.

C'è un modo per configurare Maven in modo che il mio 'app-web' sia un'applicazione di avvio a molla?

Il problema che sto affrontando è che devi usare spring-boot come genitore.

Un'altra alternativa è quella di includere nel padre pom, la dichiarazione genitore per l'avvio a molla, come mostrato in questo post

esempio-app pom.xml:

<project>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.2.5.RELEASE</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    // rest of the example-app pom declarations
</project>

Dopodiché, nei moduli poms (app-web, app-impl, ecc.), Dichiarate esempio-app come genitore, ma ora potete includere le dipendenze iniziali come fareste normalmente in un progetto normale.

app-web pom.xml:

<project>
    <parent>
        <groupId>org.demo</groupId>
        <artifactId>example-app</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <name>app-web</name>
    <artifactId>app-web</artifactId>
    <version>1.0-SNAPSHOT</version> 
    <packaging>war</packaging>

    <dependencies>
        <dependency>
            <groupId>org.demo</groupId>
            <artifactId>app-api</artifactId>
            <version>1.0-SNAPSHOT</version> 
        </dependency>
        <dependency>
            <groupId>org.demo</groupId>
            <artifactId>app-impl</artifactId>
            <version>1.0-SNAPSHOT</version> 
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
    </dependencies>
    // rest of the app-web pom declarations
</project>

Per quanto riguarda la gestione delle versioni, ciò che ho usato in questi esempi non sono esattamente le migliori pratiche, ma poiché è fuori dalla portata della domanda ho ignorato l'uso di dependencyManagement e delle proprietà dei genitori.

Inoltre, se c'è un antipasto che viene utilizzato in ogni modulo, è possibile dichiarare la dipendenza nel pom principale e quindi tutti i moduli lo erediteranno (ad esempio spring-boot-starter-test )