springboot第4集：springboot模块化开发与项目搭建流程-六虎

Spring Boot 是一个依据 Spring 结构的快速开发结构，能够用于构建独立的、出产级别的应用程序。在进行模块化开发时，将应用程序拆分为多个小的、可重用的模块，每个模块负责完成自己的功用。下面是 Spring Boot 模块化开发与项目建立的流程：

确认应用程序的功用需求：首先需求清晰应用程序要完成哪些功用，确认各个模块的职责。
创立 Maven 项目：运用 Maven 构建东西创立一个空的项目，在 pom.xml 文件中增加 Spring Boot 的依靠。
创立父子模块结构：依据应用程序的功用需求，创立多个子模块，并将其作为父模块的子模块。
装备父模块：在父模块的 pom.xml 文件中，增加子模块的依靠和一致的装备信息，如日志、数据库等。
装备子模块：在子模块的 pom.xml 文件中，增加当时模块的依靠和装备信息，如控制器、服务、存储库、东西类、异常处理等。
编写代码：在每个模块中编写相应的代码，完成相应的事务逻辑。
测验模块：对每个模块进行单元测验，保证其功用正常，无 bug。
打包布置：运用 Maven 打包并布置到服务器上，发动应用程序。
装备文件：在每个子模块中增加 application.yml 或许 application.properties 文件，别离装备当时模块所需的特点信息，如数据源、端口号、日志等级等。
公共模块：对于多个子模块都需求运用到的东西类、装备信息等，能够将其笼统为一个公共模块，这样就能够避免重复编写代码，提高了代码复用率。
拦截器：在子模块中增加拦截器，扩展应用程序的功用，如记录恳求日志、权限校验、异常处理等。
Web 层：在子模块中增加控制器，完成 HTTP 恳求和响应，处理 Web 层相关的事务逻辑。
服务层：在子模块中增加服务类，封装详细的事务逻辑，被 Web 层调用。
存储库层：在子模块中增加存储库接口，用于拜访数据库或其他数据存储办法，如 Redis、Elasticsearch 等。
异常处理：在子模块中增加异常处理类，处理应用程序中呈现的异常情况，如参数校验失败、数据库拜访异常等。

运用 Spring Boot 进行模块化开发：

创立 Maven 项目，并在 pom.xml 文件中增加 Spring Boot 的依靠：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>${spring.boot.version}</version>
</dependency>

$ mkdir parent-module
$ cd parent-module
$ mvn archetype:generate -DgroupId=com.example -DartifactId=parent-module -DinteractiveMode=false
$ mkdir child-module-1
$ cd child-module-1
$ mvn archetype:generate -DgroupId=com.example -DartifactId=child-module-1 -DinteractiveMode=false
$ mkdir child-module-2
$ cd child-module-2
$ mvn archetype:generate -DgroupId=com.example -DartifactId=child-module-2 -DinteractiveMode=false

装备父模块的 pom.xml 文件：

<modules>
    <module>child-module-1</module>
    <module>child-module-2</module>
</modules>

装备子模块的 pom.xml 文件：

子模块 1：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>${spring.boot.version}</version>
    </dependency>
</dependencies>

子模块 2：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
        <version>${spring.boot.version}</version>
    </dependency>
</dependencies>

编写代码：

子模块 1：在 src/main/java/com/example/child_module_1 目录下增加 HelloWorldController.java 文件，完成 HTTP 恳求和响应：

@RestController
public class HelloWorldController {
    @GetMapping("/hello")
    public String helloWorld() {
        return "Hello, World!";
    }
}

子模块 2：在 src/main/java/com/example/child_module_2 目录下增加 UserRepository.java 文件，完成对用户表的拜访和操作：

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    List<User> findByAge(int age);
}

测验模块：在每个子模块中编写相应的测验用例，保证其功用正常，无 bug。
打包布置：运用 Maven 打包并布置到服务器上，发动应用程序。

Spring Boot Starter Data JPA是一个Spring Boot的starter，它为运用Java Persistence API（JPA）和Hibernate ORM结构的开发者供给了便当。JPA是一个标准化的ORM结构，它供给了一种将Java目标映射到联系数据库中的办法，从而使开发人员能够运用面向目标的办法来操作数据。

Spring Boot Starter Data JPA供给了主动装备，包括：

数据源的装备
实体管理器的装备
事务管理的装备

经过简略地增加Spring Boot Starter Data JPA依靠项，您就能够快速地在Spring Boot应用程序中启用JPA功用，并开始运用Hibernate ORM结构。

此外，Spring Boot Starter Data JPA还支撑其他功用，如:

Spring Data JPA：供给了一组易于运用的存储库接口，用于拜访数据库，并供给分页、排序、查询构建等功用。
Spring Data REST：为Spring Data存储库供给RESTful API。
Spring Batch：供给了批处理作业处理的支撑。
Flyway和Liquibase：供给了数据库搬迁的支撑，能够轻松地管理数据库形式的变更。

<repositories>
    <repository>
        <id>public</id>
        <name>aliyun nexus</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        <releases>
            <enabled>true</enabled>
        </releases>
    </repository>
</repositories>

这是一个 Maven 的装备文件，它界说了一个 Maven 库房的方位和相关信息。

详细来说，这个装备文件中包含了一个元素，表明界说一个库房。在这个元素下面，又有一个元素，表明界说一个库房的详细信息。

这个库房的 id 是 “public”，称号是 “aliyun nexus”，URL 是 maven.aliyun.com/nexus/conte… Nexus 服务器上，而且能够经过这个 URL 地址拜访。

在 <releases> 元素下面，<enabled> 元素设置为 true，表明这个库房答应发布 release 版别的构件。也就是说，当一个 Maven 项目需求运用这个库房中的某个构件时，它会先查找该库房是否存在这个构件，假如存在则下载并运用；假如不存在，则会去其他装备的库房中查找。

<pluginRepositories>
    <pluginRepository>
        <id>public</id>
        <name>aliyun nexus</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        <releases>
            <enabled>true</enabled>
        </releases>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
    </pluginRepository>
</pluginRepositories>

这是一个 Maven 的装备文件，用于装备 Maven 插件的库房信息。

详细来说，这个装备文件中包含了一个 <pluginRepositories> 元素，表明界说了一个插件库房。在这个元素下面，又有一个 <pluginRepository> 元素，表明界说了一个插件库房的详细信息。

这个插件库房的 id 是 “public”，称号是 “aliyun nexus”，URL 是 maven.aliyun.com/nexus/conte… Nexus 服务器上，而且能够经过这个 URL 地址拜访。

在 <releases> 元素下面，<enabled> 元素设置为 true，表明这个插件库房答应发布 release 版别的插件；在 <snapshots> 元素下面，<enabled> 元素设置为 false，表明这个插件库房不答应发布 snapshot 版别的插件。

Maven 插件库房和构件库房类似，不同之处在于它们别离寄存不同类型的文件。插件库房主要用于寄存 Maven 插件的相关信息和代码，而构件库房则主要用于寄存项目的编译结果（如 jar、war 等文件）。

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-text</artifactId>
    <version>1.10.0</version>
</dependency>

这是一个 Maven 项目中用来声明依靠的装备，表明该项目依靠于 org.apache.commons 安排下的 commons-text 模块，版别号为 1.10.0。

详细来说，安排名和模块名别离对应 Maven 库房中的目录结构，因而 Maven 能够经过这些信息找到并下载需求的依靠包。在本例中，commons-text 模块供给了 Apache Commons Text 库的完成，能够用于处理文本相关操作，如字符串处理、格局化等。

在 Maven 中，依靠声明的格局一般为 <groupId>:<artifactId>:<version>，表明依靠的安排、模块及其版别信息。Maven 会依据依靠信息主动下载所需的依靠包，并将其增加到项目的 classpath 中，以便在代码中调用相应的类和办法。

<!--mapStruct依靠-->
<dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct</artifactId>
    <version>${mapstruct.version}</version>
</dependency>
<dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct-processor</artifactId>
    <version>${mapstruct.version}</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>javax.inject</groupId>
    <artifactId>javax.inject</artifactId>
    <version>1</version>
</dependency>

这是一个 Maven 项目的 pom.xml 文件中的一些依靠项装备。Maven 是一个 Java 的构建东西，能够主动化项目的构建和依靠项管理。

这里列出了三个依靠项:

org.mapstruct:mapstruct 是 MapStruct 库的依靠项，它是一个 Java Bean 映射库，用于简化两个目标之间的映射。${mapstruct.version} 是一个变量，将在 Maven 装备文件中设置它的值。
org.mapstruct:mapstruct-processor 也是 MapStruct 库的依靠项。该库供给了编译时生成代码的功用，以便进行更好的类型查看和保证正确性。<scope> 元素设置为 “provided”，表明这个依靠项由编译器或布置环境供给，而不是由 Maven 供给。
javax.inject:javax.inject 是 JSR-330 (依靠注入标准) 的完成，它包含了注解和接口，能够轻松地完成依靠注入形式。

POM 文件的详细代码解释：

<?xml version="1.0" encoding="UTF-8"?>
<!-- 界说 Maven 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">
    <!-- 界说该 POM 的模型版别号 -->
    <modelVersion>4.0.0</modelVersion>
    <!-- 界说项目坐标，即安排名、项目名和版别号 -->
    <groupId></groupId>
    <artifactId></artifactId>
    <version></version>
    <!-- 界说项目打包办法为 pom，表明该项目不生成 jar 或 war 包 -->
    <packaging>pom</packaging>
    <!-- 界说 maven 多模块项目中的模块称号，能够是多个子模块 -->
    <modules>
        <module>common</module>
        <module>logging</module>
    </modules>
    <!-- 界说该项目的称号和 URL -->
    <name></name>
    <url></url>
    <!-- 界说该 POM 的父级 POM，界说一些公共装备 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.4</version>
    </parent>
    <!-- 界说一些特点值，便于后边引用 -->
    <properties>
        <log4j2.version>2.17.0</log4j2.version>
        <logback.version>1.2.9</logback.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <log4jdbc.version>1.16</log4jdbc.version>
        <swagger.version>2.9.2</swagger.version>
        <fastjson.version>1.2.83</fastjson.version>
        <druid.version>1.2.8</druid.version>
        <commons-pool2.version>2.11.1</commons-pool2.version>
        <mapstruct.version>1.4.2.Final</mapstruct.version>
    </properties>
    <!-- 项目所需的依靠库 -->
    <dependencies>
        <!--Spring boot 核心-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!--Spring boot Web容器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--Spring boot 测验-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--Spring boot 安全结构-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <!-- spring boot 缓存 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <!--Spring boot Redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--spring boot 集成redis所需common-pool2-->
        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-pool2 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>${commons-pool2.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
                        <artifactId>commons-lang3</artifactId>
            <version>3.13.0</version>
        </dependency>
        <!--hibernate-validator-->
        <dependency>
            <groupId>org.hibernate.validator</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>6.2.0.Final</version>
        </dependency>
        <!--mysql数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.27</version>
        </dependency>
        <!--Druid连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>${druid.version}</version>
        </dependency>
        <!--MyBatis Plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3</version>
        </dependency>
        <!--FastJson-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>
        <!--Swagger-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>${swagger.version}</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>${swagger.version}</version>
        </dependency>
        <!--MapStruct-->
        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct</artifactId>
            <version>${mapstruct.version}</version>
        </dependency>
        <!--Lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--Log4j2-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>${log4j2.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>${log4j2.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-web</artifactId>
            <version>${log4j2.version}</version>
        </dependency>
        <!--Logback-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>${logback.version}</version>
        </dependency>
        <dependency>
            <groupId>net.logstash.logback</groupId>
            <artifactId>logstash-logback-encoder</artifactId>
            <version>6.6</version>
        </dependency>
    </dependencies>
    <!-- 界说构建相关的装备信息 -->
    <build>
        <!-- 指定打包时跳过测验阶段 -->
        <skipTests>true</skipTests>
    </build>
    <!-- 界说 Maven 库房 -->
    <repositories>
        <repository>
            <id>aliyun</id>
            <url>https://maven.aliyun.com/repository/public</url>
        </repository>
    </repositories>
    <!-- 界说 Maven 插件库房 -->
    <pluginRepositories>
        <pluginRepository>
            <id>aliyun-plug</id>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        </pluginRepository>
    </pluginRepositories>
</project>

archetype是什么

在Spring Boot中，Archetype是一个项目模板，它界说了项目的结构、依靠和其他装备。当您创立一个新的Spring Boot项目时，能够运用Archetype来快速设置项目的根本结构和依靠。

挑选合适的Archetype取决于您的需求和项目类型。例如，假如您正在开发一个Web应用程序，能够挑选Spring Boot Web Archetype；假如您正在开发一个RESTful API，能够挑选Spring Boot RESTful Service Archetype。除此之外，还有一些Archetype用于测验、安全等方面。

您能够在Maven库房中找到Spring Boot Archetype。要运用它们，请运用Maven命令行东西或集成开发环境（IDE）中供给的功用从Archetype生成新项目。

总结：

Spring Boot是一个依据Spring结构的开发结构，它能够快速构建应用程序并支撑模块化开发。下面是Spring Boot模块化开发与项目建立的流程：

确认项目需求：确认项目的需求和功用，包括数据库设计，用户界面设计等。
创立Maven项目：运用Maven创立Spring Boot项目，并增加所需求的依靠。在pom.xml文件中指定Spring Boot的版别以及其他依靠项。
装备数据库：装备Spring Boot与数据库的连接，运用Spring Data JPA进行数据拜访操作。
增加模块：依据需求增加所需求的模块，例如Web模块、Security模块等。每个模块都需求在pom.xml文件中声明所需的依靠。
设计API接口：依据需求设计RESTful API接口，并编写相应的Controller层代码。
完成事务逻辑：在Service层完成事务逻辑，并将其注入到Controller中。
编写测验代码：编写单元测验和集成测验代码，保证项目的正确性和安全性。
打包布置：运用Maven打包项目，并将其布置到服务器上。

以上是Spring Boot模块化开发与项目建立的大致流程，详细完成过程会因项目需求和场景而有所不同。

联系作者vx：xiaoda0423

库房地址：github.com/webVueBlog/…

springboot第4集：springboot模块化开发与项目搭建流程

相关文章

管理研发团队后，我发现用「速率」做度量错得离谱……

SpringBoot之加载自动配置类中的两个注解

小白都会的数据可视化大屏搭建，速来学习

Harmony OS的未来

作者信息