Esquema de construção do projeto de agregação do Maven

Engenharia agregada: Refere-se ao Mavendesenvolvimento modular baseado em engenharia. Suas vantagens são:

1. O diretório é claro e fácil de gerenciar
2. Apoiar o desenvolvimento separado (equipe)
3. Gerenciamento de versão de dependência conveniente e unificado

Na prática, é assim que eu entendo (pode estar errado, mas acho que a mente está aberta e tudo bem para entender o que faz sentido).

O chefe do projeto enviou uma tarefa e fez o seguinte primeiro:

1. A estrutura do projeto é configurada com antecedência e o gerenciamento de dependênciaspom no arquivo é especificado
2. A cada pessoa são atribuídas as tarefas subjacentes , como: classe de entidade, teste Mapper+, camada de serviço, controlador...
3. Como o limite de tempo de cada pessoa é diferente e elas podem ser responsáveis ​​por vários projetos ao mesmo tempo, é provável que o trabalho em equipe seja realizado em uma escada.

OK, em seguida, vamos aprender sobre engenharia de agregação para as duas primeiras coisas.

etapa

Nova construção

Crie um novo projeto vazio e especifique-o mavencomo uma ferramenta de gerenciamento de pacotes.

Depois de entrar no projeto, exclua srco diretório, porque este é um projeto pai, que srcé usado como diretório de código-fonte, e o projeto pai não edita o código aqui, portanto, exclua-o diretamente.

Editar arquivo pom - gerenciamento unificado de dependências

O mainstream é usar SpringBootdesenvolvimento, então você pode especificar o pai de um diretório pai:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.6.RELEASE</version>
</parent>
复制代码

No propertiesrótulo, especifique o número da versão da qual nosso projeto precisa se basear. Isso é spring-boot-starter-parentfeito principalmente na forma de referência. Se você estiver interessado, pode clicar para dar uma olhada spring-boot-dependencies.

Para introduzir um projeto de integração posteriormente, alguns pacotes básicos são introduzidos primeiro e seus números de versão são especificados:

1. mybatis-plus: estrutura da camada de persistência de dados
2. knife4j: estrutura de documentação de interface
3. jwt: autenticação de segurança jwt
4. fastjson: conversão de formato json

<properties>
    <java.version>1.8</java.version>
    <mybatis-plus.version>3.4.1</mybatis-plus.version>
    <mysql.version>8.0.30</mysql.version>
    <knife4j.version>3.0.3</knife4j.version>
    <jwt.version>0.9.1</jwt.version>
    <fastjson.version>2.0.21</fastjson.version>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
复制代码

O objetivo disso é primeiro garantir que não haja conflito nos pacotes dos quais este projeto depende.

Isso não é suficiente. É apenas para especificar o número da versão, que é o mesmo que definir uma variável. Para introduzir a configuração de dependência para projetos subseqüentes, o número da versão não será inserido. Também precisamos escrever dependencyManagementrótulos.

<dependencyManagement>
    <dependencies>
        <!--mybatis-plus 持久层-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <!--knife4j-->
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>knife4j-spring-boot-starter</artifactId>
            <version>${knife4j.version}</version>
        </dependency>
        <!--jjwt-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>${jwt.version}</version>
        </dependency>
        <!--fastjson-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>
    </dependencies>
</dependencyManagement>
复制代码

Desta forma, não é mais necessário especificar o número da versão quando os submódulos subsequentes importam esta dependência .

Novo Módulo - Atribuir Tarefas

Clique como mostrado na figura

Aqui está um exemplo, as outras etapas são as mesmas. O ponto chave é ver claramente Parentque o que está escrito é o correspondente no projeto pai.artifactId

Verificação: Uma seta azul para baixo está visível no projeto pai:

Isso significa que um submódulo independente foi criado neste projeto.

Em seguida, atribua esses módulos da ordem de trabalho inferior . Os submódulos podem dependenciesser dependentes escrevendo descrições de outros submódulos (como segue), por exemplo: camada servicede dependência camadamapper

<dependency>
    <groupId>top.chengyunlai</groupId>
    <artifactId>mapper</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>
复制代码