28个步骤快速搭建基于SpringBoot的Maven多模块Java Web项目

 

背景：平常一般的web项目，通常会使用SSH（Struts+Spring+Hibernate）、SSM（SpringMVC+Spring+Mybatis）等框架，普通的独立的比较小的项目只需要使用单模块就能满足。

单模块——

优点：简单明了，便捷使用。

缺点：每次修改一个文件，都要整体打包，不利于扩展，随着项目越来越大，比较臃肿，build的时间过长，难以维护。

 

经过项目的不断发展和添加功能需求，为了适应这种变化，需要有先见之明，搭建好可以扩展的多模块项目，用Maven管理的比较大的项目大部分都是分模块的，每个模块都对应着一个pom.xml。它们之间通过继承和聚合相互关联。

多模块——

优点：结构清晰，方便分模块打包，分模块开发，分模块部署，有利于扩展，方便管理维护，遵守设计模式原则“高内聚，低耦合”。

缺点：随着项目变大，模块变多，自然变复杂。

 

多模块JavaWeb项目结构设计：

简约式分层结构：

       system-parent（项目父目录）

----pom.xml

----system-domain（域模型层）

----pom.xml

----system-dao（数据库访问层）

----pom.xml

----system-service（业务逻辑层）

----pom.xml

----system-web（表现层）

----pom.xml

 

分布式分层结构：

       system（项目父目录，一般写项目名作为父目录、根目录）

----pom.xml

----system-model（数据模型层、实体层，可用entity、domain表示）

----pom.xml

----system-dao（数据库访问层）

----pom.xml

----system-dao-impl（数据库访问实现层，如果用mybatis这里框架可以省略这层）

----pom.xml

----system-service（业务逻辑接口层）

----pom.xml

----system-service-impl（业务逻辑接口实现层，使用dubbo时，要发布该层）

----pom.xml

----system-web（表现层、可用controller控制表现层表示）

----pom.xml

----system-common（公共通用层、存放些base类等）

----pom.xml

----system-utils（工具层、存放些工具类等）

----pom.xml

----system-rabbitmq（独立模块功能层，根据需要可以多个功能模块层，例如cas, redis等）

----pom.xml

以上分布式分层的各个模块是聚合关系；

聚合关系——多模块里的模块都是聚合关系，把多个能独立运行的模块聚在一起，这些子模块可以是平行独立关系，也可以是继承关系（假如，rabbitmq继承utils，虽然是父子关系，也可以一起聚合在system这个父目录下）。

继承关系——为了消除重复，不重复引用jar包，假如设置rabbitmq继承utils，rabbitmq就可以不在重复引用jar，都可以使用utils已经有的jar包。

依赖关系——在任何独立maven项目里，例如utlis项目里，需要使用apache项目里的common-lang3包，就可以依赖引用该jar包。

举个栗子——

一个大项目需要使用聚合、继承、依赖关系来组成。

在system大项目里，不只一个web项目，因为业务发展需要有两个后台项目和一个公共包项目，web1项目（dao+service+utils），web2项目（dao+service+common），tools公共包项目（utils+common+rabbitmq）。

那么system里聚合着web1、web2、tools、dao、service、utils、common、rabbitmq这些子模块项目，不管他们之间是平行关系，还是父子继承关系。聚合父目录，只是一个大容器，把里面能独立执行的子模块都展示出来，不管子模块之间又有什么关系，其关系都在配置中体现出来。

rabbitmq项目继承了utils项目，他俩是继承关系。

web1项目要运行起来，需要有dao、service、utils这些模块支持，他们是依赖关系。当需要另外建立一个可运行的web3项目，也需要依赖dao、service等模块，可以根据需要添加依赖到web3项目里，web1、web3和其他模块一起聚合在system这个父目录，方便管理，方便依赖组合。

聚合、继承、依赖关系都体现了面向对象的原则。子模块之间通过继承、依赖相互组合，形成一个可以运行的jar、pom、war包项目，再统一聚合在system父模块里，方便管理各个模块。

 

实战——

使用idea搭建一个maven多模块java web项目（使用分布式分层结构）

idea版本：IntelliJ IDEA 2017.2.6

开发前准备：需要配置maven，1）先下载maven，win安装版本，下载地址在：http://maven.apache.org/download.cgi；2）解压在安装目录下，配置环境变量；3）在其conf目录下的settings.xml，把本地仓储目录和远程仓储地址，或镜像地址配置好，这样才会下载相应jar包比较快速，国内比较好用的镜像如 阿里云的镜像站（首推，新站，速度暴快）：

本地配置如：<localRepository>H:/repository</localRepository>

镜像配置如：在mirrors标签下加上如下

<mirror>
    <id>nexus-aliyun</id>
    <name>Nexus aliyun</name>
    <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
    <mirrorOf>central</mirrorOf>
</mirror>

 

4）在idea的maven配置上，使用该本地的安装好的maven，如下：

 

开始建立maven多模块工程——

1. new project 新建maven project；

2. 首先创建项目父目录，root目录，所以，不需要建立archetype结构原型（maven项目模板），不用在create from archetype打勾，直接默认建立maven父工程，普通的pom打包模式，直接点击next；

3. 在GroupId输入组织id号，一般用“.”点号来间隔；ArtifactId输入项目名称（项目根目录），一般用“-”横杠来间隔；Version输入版本号，snapshot快照版本，release发布版本；输入完毕，点击Next；

4. 由于idea会把filepath换成一个单词，可以一眼看出结构，有结构有条理，还是把jibook换成ji-book，项目名称用“-”横杠作为分词；点击Finish，新建多模块javaweb项目的父目录；

5. 由于自动生成的pom.xml，是没有打包配置，需要在父目录的pom文件里添加packaging为pom；

6. 新建项目ji-book的model层子目录，project栏里右击ji-book父目录，选择new-->Module；

7. model子目录也是默认建立jar打包方式的工程，不用使用maven模版，不用打勾create from archetype，点击Next；

8. add as module to 和 parent都选择ji-book做父目录；GroupId和Version都跟父目录一样；ArtifactId子项目名为ji-book-*，这样的命名，跟maven的仓库里的坐标命名方式一致；点击Next；

9. 为了保持层次感和目录一致，把整合起来的一个单词jibookmodel变成用“-”来间隔的path路径；

改变成如下，最后点击Finish；

10. 由于model层子模块是打包成jar的模式，要在pom.xml添加打jar包的打包方式；

11. 建立dao层、service层、service-impl层、utils层、common层的子模块都按照建立model层的子模块一样的操作，重复6-10步；

12. 建立web层子模块，由于web子项目是web项目，需要打包成war包的，首先new-->module；

13. 因为要建立web工程，需要使用maven模版，在create from archetype打勾，选择maven-archetype-webapp模板，点击Next；

14. parent、groupId、version这些都保持不变，ArtifactId输入web子项目的名称，点击Finish；

15. 选择maven的安装目录，settings.xml的maven配置文件的path，local repository本地仓储的path目录；查看建立web项目的项目参数，确认无误，点击Next；

16. 输入module name子模块名字，还有子模块的path目录；最后点击Finish；

17. 点击Finish之后，idea会自动生成webapp项目，自动生成打包方式为war包的pom.xml配置；自动在src目录下有webapp目录，有web项目的标准文件WEB-INF目录下的web.xml配置文件；

PS:

没有java源代码目录？

由于上面只有resources和webapp文件夹存放相关资源，没有java来存放java源代码，这个需要自己去建立，并且还要更新ji-book-web.iml的idea特有的配置文件，有时候rebuild，clean之后都不能马上更新得到。

更新idea的配置文件的方法：删除隐藏的idea文件夹，关掉idea编辑器，再重新打开能重新导入maven-project。

 

另一种新建ji-book-web工程方法：

1）根model模块一样，不用使用maven模版，不用打勾create from archetype，点击Next；

2）接下来的命名，目录，父模块等设置跟model模块一样；

3）在pom.xml文件里添加<packaging>war</packaging>，这样就可以打出war包；

4）在src/main文件夹下创建Java代码文件夹java、resources资源配置文件、webapp的文件夹下放WEB-INF文件夹存放web信息配置，还有web.xml项目配置文件；

这样就可以在方便地搭建java-web项目，又可以随时更新idea的配置文件ji-book-web.iml。

 

18. 编写建表SQL，在dao层里的资源目录resources新建一个存放sql语句的目录；

命名为ji-book-sql，存放工程里的sql命令文件；

19. 设计User数据表结构，新建create_table_sql.sql建表sql文件来编写建表sql语句；

PS: 工程、目录之间用“-”横杠间隔，文件等用“_”下划线来间隔；

新建create_table_sql.sql建表sql文件

编写User的建表sql:

--用户表 add by MC 2018-1-30
DROP TABLE IF EXISTS `ji_book_user`;
CREATE TABLE `ji_book_user` (
    `id` varchar(38) NOT NULL COMMENT '用户表主键',
    `nick_name` varchar(38) DEFAULT NULL COMMENT '昵称',
    `gender` tinyint(2) DEFAULT NULL COMMENT '性别：0- 未知；1- 男；2- 女',
    `country` varchar(28) DEFAULT NULL COMMENT '城市',
    `status` varchar(8) DEFAULT 'y' COMMENT '状态：y-启用；n-禁用，默认为y',
    `create_account` varchar(255) DEFAULT NULL COMMENT '创建帐号',
    `create_time` date DEFAULT NULL COMMENT '创建时间',
    `update_account` varchar(255) DEFAULT NULL COMMENT '更改帐号',
    `update_time` date DEFAULT NULL COMMENT '更改日期',
    PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

 

20. 编写model层的UserDO实体类，实体类一般以DO结尾；

包路径应该跟groupId和artifactId结合相同，包路径应该是com.mc.jibook，把ji-book改为jibook，或者用简写jb，com.mc.jb，只有同包路径才能打包在一起，方便管理和编译打包；

1）先建立包，路径为com.mc.jibook.model

项目包根目录为com.mc.jibook，而model层的路径为com.mc.jibook.model；

2）创建User实体类UserDO;

编写UserDO类的字段，及其get/set方法，字段命名规则运用驼峰命名法则，例如ji_book改为jiBook；

package com.mc.jibook.model;

import java.util.Date;

/**
 * 用户表实体类
 * @author mc
 * @date 2017-1-30
 */
public class UserDO {
    /**
     * 用户表主键
     */
    private String id;
    /**
     * 昵称
     */
    private String nickName;
    /**
     * 性别：0- 未知；1- 男；2- 女
     */
    private Integer gender;
    /**
     * 城市
     */
    private String country;
    /**
     * 状态：y-启用；n-禁用，默认为y
     */
    private String status;
    /**
     * 创建帐号
     */
    private String createAccount;
    /**
     * 创建时间
     */
    private Date createTime;
    /**
     * 更改帐号
     */
    private String updateAccount;
    /**
     * 更改日期
     */
    private Date updateTime;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getNickName() {
        return nickName;
    }

    public void setNickName(String nickName) {
        this.nickName = nickName;
    }

    public Integer getGender() {
        return gender;
    }

    public void setGender(Integer gender) {
        this.gender = gender;
    }

    public String getCountry() {
        return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    public String getCreateAccount() {
        return createAccount;
    }

    public void setCreateAccount(String createAccount) {
        this.createAccount = createAccount;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public String getUpdateAccount() {
        return updateAccount;
    }

    public void setUpdateAccount(String updateAccount) {
        this.updateAccount = updateAccount;
    }

    public Date getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }
    /**
     * POJO都需要重写toString方法，可以方便打印信息，排查问题
     * @return
     */
    @Override
    public String toString() {
        return "UserDO{" +
                "id='" + id + ''' +
                ", nickName='" + nickName + ''' +
                ", gender=" + gender +
                ", country='" + country + ''' +
                ", status='" + status + ''' +
                ", createAccount='" + createAccount + ''' +
                ", createTime=" + createTime +
                ", updateAccount='" + updateAccount + ''' +
                ", updateTime=" + updateTime +
                '}';
    }
}

 

21. 添加jar依赖

ji-book root目录

在parent父目录的pom.xml文件上添加工程里需要使用到所有jar包依赖，有利于统一管理版本号。

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.mc</groupId>
    <artifactId>ji-book</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>

    <!-- 子目录子模块管理 -->
    <modules>
        <module>ji-book-model</module>
        <module>ji-book-dao</module>
        <module>ji-book-service</module>
        <module>ji-book-service-impl</module>
        <module>ji-book-utils</module>
        <module>ji-book-common</module>
        <module>ji-book-web</module>
    </modules>

    <!-- 依赖的jar版本号参数常量，有利于版本号统一 -->
    <properties>
        <mysql.version>5.1.21</mysql.version>
        <mybatis.version>3.4.1</mybatis.version>
        <mybatis.spring.version>1.3.0</mybatis.spring.version>
        <spring.version>4.3.2.RELEASE</spring.version>
        <druid.version>1.0.24</druid.version>
        <servlet.version>3.1.0</servlet.version>
        <jsp.api.version>2.2</jsp.api.version>
        <jstl.version>1.2</jstl.version>
    </properties>

    <!-- maven依赖管理 在父目录导入需要使用的jar包，子模块可以选择导入，有利于版本统一控制 -->
    <dependencyManagement>
        <dependencies>
            <!-- mysql start -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <!-- mysql end -->

            <!-- mybatis begin -->
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>${mybatis.spring.version}</version>
            </dependency>
            <!-- mybatis end -->

            <!-- spring start -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-tx</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-web</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aop</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <!-- spring end -->

            <!-- druid start -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>${druid.version}</version>
            </dependency>
            <!-- druid end -->

            <!-- javax-servlet start -->
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>${servlet.version}</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>javax.servlet.jsp</groupId>
                <artifactId>jsp-api</artifactId>
                <version>${jsp.api.version}</version>
            </dependency>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>jstl</artifactId>
                <version>${jstl.version}</version>
            </dependency>
            <!-- javax-servlet end -->
        </dependencies>
    </dependencyManagement>
</project>

 

ji-book-model层

在ji-book-model模块里的pom.xml只需要加上maven插件compiler，方便编译其源代码。

ji-book-model模块的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">
    <parent>
        <artifactId>ji-book</artifactId>
        <groupId>com.mc</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ji-book-model</artifactId>

    <packaging>jar</packaging>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

 

ji-book-dao层

在ji-book-dao模块里的pom.xml引入需要的mysql、mybatis、druid的jar包依赖，而且引入model模块，以致可以使用model模块的类，最后还要加上maven插件compiler，方便编译其源代码。

ji-book-dao模块的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">
    <parent>
        <artifactId>ji-book</artifactId>
        <groupId>com.mc</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ji-book-dao</artifactId>
    <packaging>jar</packaging>

    <dependencies>
        <!-- 引入model模块 -->
        <dependency>
            <groupId>com.mc</groupId>
            <artifactId>ji-book-model</artifactId>
            <!-- 引用当前项目的版本号1.0-SNAPSHOT当作model的版本 -->
            <version>${project.version}</version>
        </dependency>

        <!-- 由于父工程模块定义引用了该jar包，版本号可以让父模块统一管理，这里不用写版本号 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

 

ji-book-service层

在ji-book-service模块里的pom.xml引入model模块的，编写业务逻辑层的接口可以引入model的实体类，最后还要加上maven插件compiler，方便编译其源代码。

ji-book-service模块的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">
    <parent>
        <artifactId>ji-book</artifactId>
        <groupId>com.mc</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ji-book-service</artifactId>

    <packaging>jar</packaging>

    <dependencies>
        <!-- 引入model模块 -->
        <dependency>
            <groupId>com.mc</groupId>
            <artifactId>ji-book-model</artifactId>
            <!-- 引用当前项目的版本号1.0-SNAPSHOT当作model的版本 -->
            <version>${project.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

 

ji-book-service-impl层

在ji-book-service-impl模块里的pom.xml引入dao和service模块，由于dao和service都有引入model模块，所以service-impl模块可以引用所有的模块；还有需要引入spring-context，spring-jdbc的jar包，方便在业务逻辑实现类使用service标签注入到服务接口里，最后还要加上maven插件compiler，方便编译其源代码。

ji-book-service-impl模块的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">
    <parent>
        <artifactId>ji-book</artifactId>
        <groupId>com.mc</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ji-book-service-impl</artifactId>
    <packaging>jar</packaging>

    <dependencies>
        <!-- 引入dao模块 -->
        <dependency>
            <groupId>com.mc</groupId>
            <artifactId>ji-book-dao</artifactId>
            <!-- 引用当前项目的版本号1.0-SNAPSHOT当作model的版本 -->
            <version>${project.version}</version>
        </dependency>
        <!-- 引入service模块 -->
        <dependency>
            <groupId>com.mc</groupId>
            <artifactId>ji-book-service</artifactId>
            <!-- 引用当前项目的版本号1.0-SNAPSHOT当作model的版本 -->
            <version>${project.version}</version>
        </dependency>

        <!-- 引入spring的jar包，方便在业务逻辑实现类使用service标签注入到服务接口里 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

 

ji-book-web层

在ji-book-web模块里的pom.xml只需要引入service-impl模块，由于service-impl可以引用dao、service、model模块，所以web模块可以引用所有的模块；还有需要引入spring相对应的jar包，以可以使用spring配置和管理需要的框架，接着还要加上maven插件compiler，方便编译其源代码，再加上tomcat7的插件，可以打包和部署项目到tomcat中间件上运行。

profiles配置 —— 最后得配置项目的profiles，方便切换各种环境的配置。

ji-book-web模块的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">
    <parent>
        <artifactId>ji-book</artifactId>
        <groupId>com.mc</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ji-book-web</artifactId>
    <packaging>war</packaging>

    <dependencies>
        <!-- 引入service-impl模块 -->
        <dependency>
            <groupId>com.mc</groupId>
            <artifactId>ji-book-service-impl</artifactId>
            <!-- 引用当前项目的版本号1.0-SNAPSHOT当作model的版本 -->
            <version>${project.version}</version>
        </dependency>
        <!-- 由于父工程模块定义引用了该jar包，版本号可以让父模块统一管理，这里不用写版本号 -->
        <!-- spring start -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
        </dependency>
        <!-- spring end -->
    </dependencies>

    <!-- 配置各种环境的profile，方便各种环境配置的切换 -->
    <profiles>
        <profile>
            <id>dev</id>
            <properties>
                <env.type>dev</env.type>
            </properties>
            <!-- 默认选择哪个配置，需要的话把activation设置在哪个profile里 -->
            <activation>
                <activeByDefault>true</activeByDefault>
            </activation>
        </profile>
        <profile>
            <id>test</id>
            <properties>
                <env.type>test</env.type>
            </properties>
        </profile>
        <profile>
            <id>prod</id>
            <properties>
                <env.type>prod</env.type>
            </properties>
        </profile>
    </profiles>

    <build>
        <resources>
            <!-- 项目相关的所有资源路径列表，例如和项目相关的配置文件、属性文件，这些资源被包含在最终的打包文件里 -->
            <resource>
                <!--描述存放资源的目录，该路径相对POM路径 -->
                <directory>src/main/resources</directory>
                <includes>
                    <!--包含的模式列表, profile配置文件所在路径 -->
                    <include>/properties/**/*.properties</include>
                </includes>
            </resource>
            <resource>
                <!--描述存放资源的目录，该路径相对POM路径 -->
                <directory>src/main/resources</directory>
                <!--是否使用参数值代替参数名。参数值取自properties元素或者文件里配置的属性，文件在filters元素里列出，必须加上 -->
                <filtering>true</filtering>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>

            <!-- 引入tomcat中间件的maven插件，方便打包发布运行war包 -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <port>8181</port>
                    <charset>UTF-8</charset>
                    <server>tomcat7</server>
                </configuration>
            </plugin>
        </plugins>

        <!-- 最终打包出来的war包名称 -->
        <finalName>ji-book-web</finalName>
    </build>
</project>

 

其他模块如ji-book-utils、ji-book-common模块项目，可以按照需求，在各层引入，其pom.xml按需要引入jar包依赖。这里就略过了。

写好了pom.xml文件，其相对应的*.iml的idea配置文件也会有所更新。

如果没有更新，不能获取相应的jar包和依赖，可以尝试一下几个方法：

1）rebuild下项目；

2）更新maven，对root目录ji-book进行clean+compile；

3）删除隐藏的idea文件夹，关掉idea编辑器，再重新打开能重新导入maven-project。

 

22. 编写java代码

1）model层Java代码

已经按照mysql数据库的sql建表设计，编写好了UserDO实体类，如步骤20。

2）dao层Java代码

在dao模块里java的目录下，创建com.mc.jibook.dao的包，在该包下，创建UserDAO.java源文件，内容如下：

package com.mc.jibook.dao;

import com.mc.jibook.model.UserDO;

/**
 * 用户DAO层 接口
 * @author mc
 * @date 2018-2-8
 */
public interface UserDAO {

    /**
     * 保存用户
     * @param userDO
     * @return
     */
    int saveUser(UserDO userDO);

}

 

在resources目录下新建mapper目录，在mapper目录下新建mybatis的mapper配置文件，UserMapper.xml相当于DAO层接口的实现，其内容如下：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.mc.jibook.dao.UserDAO">
    <resultMap id="BaseResultMap" type="com.mc.jibook.model.UserDO">
        <id column="id" property="id" jdbcType="VARCHAR" />
        <result column="nick_name" property="nickName" jdbcType="VARCHAR" />
        <result column="gender" property="gender" jdbcType="TINYINT" />
        <result column="country" property="country" jdbcType="VARCHAR" />
        <result column="status" property="status" jdbcType="VARCHAR" />
        <result column="create_account" property="createAccount" jdbcType="VARCHAR" />
        <result column="create_time" property="createTime" jdbcType="DATE" />
        <result column="update_account" property="updateAccount" jdbcType="VARCHAR" />
        <result column="update_time" property="updateTime" jdbcType="DATE" />
    </resultMap>

    <insert id="saveUser" parameterType="com.mc.jibook.model.UserDO" >
        INSERT INTO ji_book_user (id, nick_name, gender,
        country, status, create_account, create_time, update_account, update_time
        )
        VALUES (#{id,jdbcType=VARCHAR}, #{nickName,jdbcType=VARCHAR}, #{gender,jdbcType=TINYINT},#{country,jdbcType=VARCHAR},
        #{status,jdbcType=VARCHAR}, #{createAccount,jdbcType=VARCHAR}, #{createTime,jdbcType=DATE},
        #{updateAccount,jdbcType=VARCHAR}, #{updateTime,jdbcType=DATE}
        )
    </insert>
</mapper>

 

PS：UserDAO的saveUser方法名要与UserMapper的saveUser方法名一致。

3）service层Java代码

在service层的java目录下，创建com.mc.jibook.service的包，在该包下，创建UserService.java源文件，内容如下：

package com.mc.jibook.service;

import com.mc.jibook.model.UserDO;

/**
 * 用户的业务逻辑 接口
 * @author mc
 * @date 2018-2-8
 */
public interface UserService {

    /**
     * 保存用户
     * @param userDO
     */
    void saveUser(UserDO userDO);

}

 

4）service-impl层Java代码

在service-impl层的java目录下，创建com.mc.jibook.service.impl的包，在该包下，创建UserServiceImpl.java源文件，内容如下：

package com.mc.jibook.service.impl;

import com.mc.jibook.dao.UserDAO;
import com.mc.jibook.model.UserDO;
import com.mc.jibook.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * 用户的业务逻辑 接口
 * @author mc
 * @date 2018-2-8
 * service注解，可使serviceImpl自动注入service，以"userService"命名，在controller里调用就该以userService命名才能起到注入效果
 */
@Service("userService")
public class UserServiceImpl implements UserService{

    /**
     * Autowired自动注入注解，可以自动完成UserDAO的初始化
     */
    @Autowired
    private UserDAO userDAO;

    @Override
    public void saveUser(UserDO userDO) {
//调用userDao的saveUser方法，保存用户
        userDAO.saveUser(userDO);
    }
}

 

5）web层Java代码

在web层的java目录下，创建com.mc.jibook.web的包，在该包下，创建UserController.java源文件，内容如下：

package com.mc.jibook.controller;

import com.mc.jibook.model.UserDO;
import com.mc.jibook.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * 用户的controller控制类
 * @author mc
 * @date 2018-2-8
 * controller注解用于标注该类为控制层类，其方法都是可对外发布的接口
 * RequestMapping注解用于标明对外接口的路径
 */
@Controller
@RequestMapping("/user")
public class UserController {

    /**
     * Autowired自动注入注解，由于service-impl类里service注解以userService命名，所以这里也该这样命名才能使用
     */
    @Autowired
    private UserService userService;

    @RequestMapping("/saveUser")
    public String saveUser(UserDO userDO) {
        try {
//调用userService的保持用户方法saveUser
            userService.saveUser(userDO);
//由于spring-mvc.xml配置了返回结果以/view/为前缀，.jsp为后缀的设置，当返回success结果，就回跳转到/view/success.jsp页面，如果失败就跳转到/view/fail.jsp
            return "success";
        } catch (Exception e) {
            return "fail";
        }
    }
}

 

PS：由于上面的各个层的java的包路径都是以com.mc.jibook开头的，这样package打包的时候，可以把这些层的java代码都打包在同一个包里，方便管理。

 

23. spring配置

由于引入了spring框架，有用到spring注解和springMVC，得在ji-book-web工程下的resources目录下编写spring配置。

spring-context.xml为spring的总配置（上下文配置），web工程首先读取该配置，其内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <!-- 引入db.properties属性文件 -->
    <context:property-placeholder location="classpath:properties/${env.type}/*.properties" />
    <!-- 自动扫描(自动注入)，扫描com.mc.jibook以及它的子包的所有使用@Service注解标注的类 -->
    <context:component-scan base-package="com.mc.jibook" />

    <!-- 引入mybatis配置 -->
    <import resource="spring-mybatis.xml" />
</beans>

 

spring-mvc.xml为springMVC的配置文件，与springMVC相关的配置，其内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:annotation-config />
    <!-- 组件扫描 -->
    <context:component-scan base-package="com.mc.jibook" use-default-filters="false">
        <!-- 扫描Controller的注解 -->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller" />
        <!-- 扫描Service的注解 -->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Service"/>
    </context:component-scan>

    <!-- 配置视图解析器 如何把handler 方法返回值解析为实际的物理视图 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name = "prefix" value="/WEB-INF/view/"></property>
        <property name = "suffix" value = ".jsp"></property>
    </bean>
</beans>

 

spring-mybatis.xml为spring结合mybatis的配置，可以配置mybatis相关的数据库配置，在前面spring-context.xml配置已经引入，其内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">

    <!-- 数据源 org.apache.commons.dbcp.BasicDataSource com.alibaba.druid.pool.DruidDataSource -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">

        <property name="driverClassName" value="${driverClassName}" />
        <property name="url" value="${db_url}" />
        <property name="username" value="${db_username}" />
        <property name="password" value="${db_password}" />

        <!-- 初始化连接大小 -->
        <property name="initialSize" value="0" />
        <!-- 连接池最大使用连接数量 -->
        <property name="maxActive" value="20" />
        <!-- 连接池最小空闲 -->
        <property name="minIdle" value="0" />
        <!-- 获取连接最大等待时间 -->
        <property name="maxWait" value="60000" />

        <property name="validationQuery" value="${validationQuery}" />
        <property name="testOnBorrow" value="false" />
        <property name="testOnReturn" value="false" />
        <property name="testWhileIdle" value="true" />

        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvic