项目技巧1

创建项目工程的技巧

示例：创建父工程

第一步：初始化maven项目

第二步：使用标签抽取依赖的资源版本号，方便后续调整

第三步：配置父工程锁定的版本，使用该标签的作用：锁定资源的版本号，但是不负责资源的导入

第四步：使用让插件版本锁定作用:不负责插件资源的导入，负责插件版本的锁定

创建公共子工程

编辑第一步：在父工程下新建模块，可以发现pom.xml文件自动使用标签导入父工程的依赖版本，这里的公共子工程需要使用jar包方式打包

第二步：导入其他子工程共同需要的依赖，但是可以不写依赖版本号，因为父工程已经指定

创建其他子工程

导入公共子工程的依赖和自己所需要的依赖

导入自己所需要的插件

使用MybatisX插件快速生成mapper接口，mapperXml文件和每张表对应的pojo类

第一步：下载mybatisX

第二步：使用idea连接数据库

第三步：配置信息，在公共子工程创建

使用

使用JBLSpringBootAppGen插件快速生成SpringBoot启动类

下载编辑

使用

使用spring-security-crypto进行密码加密和校验

导入依赖

配置密码加密器

使用

使用commons-lang3工具包

导入依赖：

使用该包下的StringUtils工具类

创建项目工程的技巧

1.创建出一个父工程，让这个工程的pom.xml来管理子工程的依赖版本，即让子工程的依赖锁定，这样一来我们就可以在父工程的pom.xml文件中直接修改子工程的依赖版本

父工程的作用如下

1.通过该父工程聚合若干个子工程，统一管理若干工程的maven生命周期：clean,compile,package,install,deploy等
2.统一管理子工程的依赖版本（版本锁定）
3.统一管理子工程的插件的版本锁定
4.对于子工程公共的依赖，可以提取到父工程

2. 我们还可以在父工程下创建一个公共子工程，这个工程的作用就是导入其它子工程公共的依赖，这样一来，其他子工程只要导入这个公共子工程，就可以减少代码的冗余。

注意点：父工程使用pom方式打包，其他子工程使用jar包方式打包

因为子工程需要通过<parent>标签来引用父工程的依赖版本

示例：创建父工程

第一步：初始化maven项目

现在下面是一个父工程的pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<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.hhh</groupId>
    <artifactId>stock_parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <description>
        该工程是项目的父工程，核心作用：
            1.通过该父工程聚合若干个子工程，统一管理若干工程的maven生命周期：clean,compile,package,install,deploy等
            2.统一管理子工程的依赖版本（版本锁定）
            3.统一管理子工程的插件的版本锁定
            4.对于子工程公共的依赖，可以提取到父工程
    </description>
</project>

第二步：使用<properties>标签抽取依赖的资源版本号，方便后续调整

<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <maven.surefire.version>2.12.4</maven.surefire.version>
        <mybatis-spring-boot-starter.version>2.1.4</mybatis-spring-boot-starter.version>
        <mysql-driver.version>5.1.49</mysql-driver.version>
        <junit.version>4.13.2</junit.version>
     <spring-boot.version>2.5.3</spring-boot.version>
    </properties>

我们现在使用了<properties>标签来定义了依赖的资源版本号，这样子的好处就是修改版本十分方便

第三步：配置父工程锁定的版本，使用<dependencyManagement> 该标签的作用：锁定资源的版本号，但是不负责资源的导入

 <dependencyManagement>
        <dependencies>
<!--            引入单元测试junit依赖-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
            <!--引入springboot依赖-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-parent</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <!--将springboot中锁定的资源依赖与当前工程锁定的资源依赖进行合并,就是把<properties>标签内容合并-->
                <scope>import</scope>
            </dependency>
            <!--引入mybatis场景依赖-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis-spring-boot-starter.version}</version>
            </dependency>       
            <!--mysql驱动包-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql-driver.version}</version>
            </dependency>     
        </dependencies>
    </dependencyManagement>

注意：这里引入引入springboot依赖依赖时需要<type>指定打包方式，<scope>指定作用范围：

将springboot中锁定的资源依赖与当前工程锁定的资源依赖进行合并,就是把它们的<properties>标签内容合并

第四步：使用<pluginManagement> 让插件版本锁定作用:不负责插件资源的导入，负责插件版本的锁定

 <build>
        <!--插件版本锁定 作用:不负责插件资源的导入，负责插件版本的锁定-->
        <pluginManagement>
            <plugins>
                <!--Springboot核心插件-->
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <version>${spring-boot.version}</version>
                    <executions>
                        <execution>
                            <goals>
                                <!--防止打包时出现找不到springboot启动类的情况-->
                                <goal>repackage</goal>
                            </goals>
                        </execution>
                    </executions>
                    <configuration>
                        <excludes>
                            <!--插件运行时排除依赖-->
                            <exclude>
                                <groupId>org.springframework.boot</groupId>
                                <artifactId>spring-boot-configuration-processor</artifactId>
                            </exclude>
                        </excludes>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>

这样一来父工程就搭建完毕，可以发现父工程没有导入依赖，只是让依赖版本锁定