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

最新推荐文章于 2024-06-08 23:56:35 发布
最新推荐文章于 2024-06-08 23:56:35 发布
阅读量9k 收藏 67
点赞数 16
分类专栏： 项目架构 文章标签： Java-Web项目 Maven 多模块 SpringBoot idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dalaoliang886/article/details/81160270
版权

                                                       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="timeBetweenEvictionRunsMillis" value="60000" />
        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="25200000" />

        <!-- 打开removeAbandoned功能 -->
        <property name="removeAbandoned" value="true" />
        <!-- 1800秒，也就是30分钟 -->
        <property name="removeAbandonedTimeout" value="1800" />
        <!-- 关闭abanded连接时输出错误日志 -->
        <property name="logAbandoned" value="true" />

        <!-- 监控数据库 -->
        <!-- <property name="filters" value="stat" /> -->
        <property name="filters" value="mergeStat" />
    </bean>

    <!-- 配置sqlSessionFactory -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 实例化sqlSessionFactory时需要使用上述配置好的数据源以及SQL映射文件 -->
        <property name="dataSource" ref="dataSource" />
        <!-- 自动扫描/mapper/目录下的所有SQL映射的xml文件 -->
        <property name="mapperLocations" value="classpath:/mapper/*.xml" />
    </bean>

    <!-- 配置扫描器 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 扫描com.mc.jibook.dao这个包以及它的子包下的所有映射接口类 -->
        <property name="basePackage" value="com.mc.jibook.dao" />
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
    </bean>
</beans>

 

24. 数据库db配置

在上面，spring-context.xml扫描了properties目录下的不同环境下的数据库配置，spring-mybatis.xml引用了db_url，db_username，db_password等数据库配置，所以，现在编写db配置。

1）在ji-book-web层下的resources目录新建properties的存放数据库配置目录。

dev目录下的db.properties为开发环境的数据库配置，test目录下的db.properties为测试环境的数据库配置，prod目录下的db.properties为生产环境的数据库配置。

2）编写db.properties数据库配置文件，各个环境的配置前面的参数都一样，其内容如下：

driverClassName=com.mysql.jdbc.Driver
validationQuery=SELECT 1
db_url=jdbc:mysql://192.168.0.1/mcdb_dev?characterEncoding=UTF-8&allowMultiQueries=true&serverTimezone=UTC&autoReconnect=true&failOverReadOnly=false&zeroDateTimeBehavior=convertToNull&useSSL=false
db_username=mc
db_password=12345678

 

25. 配置web工程

整个ji-book工程，要配置web.xml，在其引入spring的配置才能很好地运行整个web项目。

在ji-book-web层下，webapp目录下是设置web工程的配置，编写web.xml文件，其内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         id="iperp-report" version="3.0" metadata-complete="true">

    <display-name>jibook-web</display-name>

    <!-- 设置web工程的欢迎页面 -->
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>

    <!-- 读取spring-context上下文的配置 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-context.xml</param-value>
    </context-param>

    <!-- 设置context上下文的监听器 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- 设置web工程的编码格式 -->
    <filter>
        <filter-name>charEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>charEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- 设置web工程的servlet配置 引入spring-mvc的配置 -->
    <servlet>
        <servlet-name>Spring MVC Dispatcher Servlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>2</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>Spring MVC Dispatcher Servlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

 

26. 编写返回结果的页面

根据spring-mvc的配置，得在web层里的webapp目录下新建/WEB-INF/view/的目录，结果页面都放view目录下，并且根据后缀，得是.jsp的文件才能成为结果跳转页面。

返回成功的页面，success.jsp，其内容如下：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>success</title>
    </head>
    <body>
        <h1>great! it is success!</h1>
    </body>
</html>

 

返回失败的页面，fail.jsp，其内容如下：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>fail</title>
    </head>
    <body>
        <h1>sorry! it is fail!</h1>
    </body>
</html>

 

在web层的webapp目录下，直接新建index.jsp，欢迎页面，其内容如下：

<!DOCTYPE html>
<html>
    <head>
        <title>index</title>
    </head>
    <body>
        <h2>Hello World!</h2>
    </body>
</html>

 

26. 编译打包

在idea右侧有一个maven工具插件，可以很方便地运行各个maven项目的生命周期的命令，插件的命令等。当然也可以在命令行下执行maven的命令。

常用maven命令如下：

mvn clean清理命令，可以清空已经编译生成的target目录下的文件，以便重新编译打包。

在ji-book目录下执行clean命令如下：

mvn compile编译命令，编译父目录可以把旗下的所有子模块全部编译。

mvn install安装命令，可以把编译好的模块以jar或者war包形式安装存放到本地仓库里，方便其他项目调用。

mvn package打包命令，可以把源文件，资源文件，编译好的class文件打包起来，按照配置好的war包或者jar包形式打包好。

 

编译打包本jibook项目：

1）清理ji-book父目录工程；

2）编译 ji-book工程；

3）安装ji-book工程；

4）编译ji-book-web子目录工程；

5）打包ji-book-web子目录工程，把所有子目录工程的代码都集合起来打包war包。

PS：如果改动某一个子目录工程的代码，只需要重新mvn clean compile 清除和编译就可以重新打包运行，不用整个项目都清理和编译了。

 

27. 部署运行web项目

由于在ji-book-web子目录工程下的pom.xml已经配置好了tomcat的plugin插件，这个web项目就可以直接在idea编译器下把web项目部署在tomcat中间件下，运行该web工程。

在idea的右侧也又maven project运行maven插件的工具栏，可以很好控制操作maven插件。

经过编译打包好了ji-book-web，会在ji-book-web层里target目录下，生成ji-book-web的war包。

可以把这个ji-book-web.war文件拿去部署在tomcat，jetty，jboss等中间件下，也可以在idea的tomcat插件下部署运行，在右侧的工具栏下双击，plugins下的tomcat7:run;

然后在输出屏幕上出现如下运行web工程成功

打开web工程的欢迎页，在浏览器上输入http://localhost:8181/ji-book-web/，就可以成功看到如下欢迎页面：

 

28. 调试保存用户接口

web项目的根路径是http://localhost:8181/ji-book-web/

在UserController上的保存用户接口的路径是：http://localhost:8181/ji-book-web/user/saveUser

使用postman调试dev开发环境的保存用户接口

1）在postman的url上输入保存用户接口：http://localhost:8181/ji-book-web/user/saveUser，并选择post方式；

2）输入保存用户的params用户信息参数；

3）点击send，调用保存用户接口；

执行成功，就会返回success.jsp页面，再查看开发环境的数据库，就可以查看到新插入的用户信息。

 

切换到测试环境的数据库，调试测试环境的保存用户接口

1）切换测试数据库，在ji-book-web层里，pom.xml的profile配置，把默认选择dev开发环境配置改为test测试环境；

2）重新清理ji-book-web工程，重新编译，重新打包；

经过重新清理，编译，打包，profiles配置也变成了test。

3）重新运行tomcat，重新部署运行web项目；

从输出屏幕上可以知道web的工程url，当前配置文件是读取哪个环境的，编译的时间等。

4）按照开发环境的postman调试接口步骤，测试保存用户接口；

点击send按钮，开始调试接口，成功后跳转到success.jsp页面；

再查看test测试环境的数据库，查看插入的用户信息数据。

大功告成，28个步骤就可以快速搭建基于springboot的maven多模块java-web工程，并且运行成功！

 

 

dalaoliang886
关注
  • 16
    点赞
  • 踩
  • 67
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
java分布式项目搭建_IDEA+SpringBoot+Mybatis+maven分布式项目框架的搭建
weixin_42365266的博客
02-19 996
参考文章：https://blog.csdn.net/qq_34410726/article/details/98214992一、maven分布式工程的基本架构demo #父工程模块，主要用来定义整个分布式工程的依赖版本----common #公共模块，主要用来定义一些公共的组件，比如实体类等----function-one #功能模块1，引入common模块--...
那些年，我敲过的代码：Springboot框架、Maven的分层结构
shuize123的博客
08-30 474
今天的课程主要讲四个： maven的组进分层和平时做的包分层的区别 为什么要搭建分层，它的逻辑是什么？ 怎么去搭建、去配置？ 最后搭建好的是怎样的？
SpringBoot+Maven搭建分模块项目
少年闰土
03-14 868
前面介绍的项目都是一个整体的 SpringBoot 项目，在实际的开发过程中，特别是微服务部分，经常需要将各个功能模块分开，使用 Maven 就能很好的实现这个效果1. 父级项目添加子模块的配置有两处，分别在 和 下，子模块的信息一定要填写准确2. 由于 Controller 模块还作为启动模块，特别要主要各个模块之间的包名的关系。
【web开发】第28节：SpringbootWeb - Maven进阶篇（2）
最新发布
m0_46013789的博客
06-08 1003
Maven 翻译为"专家"、"内行"，是 Apache 下的一个纯 Java 开发的开源项目。基于项目对象模型（缩写：POM）概念，Maven利用一个中央信息片断能管理一个项目的构建、报告和文档等步骤。Maven 是一个项目管理工具，可以对 Java 项目进行构建、依赖管理。
SpringCloud微服务架构前后端分离项目实践
weixin_50196917的博客
06-07 4904
一款 Java 语言基于 SpringCloud、Vue、ElementUI、MySQL等框架精心打造的一款前后端分离框架，致力于实现模块化、组件化、可插拔的前后端分离架构敏捷开发框架，可用于快速搭建前后端分离后台管理系统，本着简化开发、提升开发效率的初衷，目前框架已集成了完整的RBAC权限架构和常规基础模块，前端Vue端支持多主题切换，可以根据自己喜欢的风格选择想一个的主题的个性化呈现的需
java分布式架构的搭建_微服务中基于Spring Boot的maven分布式项目框架的搭建
weixin_36352023的博客
02-25 507
项目介绍这里搭建的是基于 maven 的分布式工程，因为在一个项目中，多个微服务是属于同一个工程，只不过是提供不同的服务而已，再加上 IDEA 是默认一个窗口打开一个项目工程(这点和 eclipse 不同)，如果项目大，不用 maven 聚合工程的话，那估计会打开十几个窗口……会崩溃……而且在架构上，也应该使用 maven 分布式工程来搭建微服务架构。这里手把手教大家在 IDEA 中搭建基于 ma...
Springboot多模块 整合 mybatis maven项目
01-27
在这个"Springboot多模块整合Mybatis Maven项目"中，我们将深入探讨这些技术的集成和使用。 首先，我们来看Spring Boot。Spring Boot的核心理念是"约定优于配置"，它内置了大量默认配置，如Tomcat服务器、Spring ...
springboot maven基础搭建.rar
06-03
通过以上步骤，你就完成了一个基础的SpringBoot、MyBatis、Maven和MySQL项目搭建。这只是一个起点，你可以根据需求进一步扩展，例如添加更多的SpringBoot特性、集成其他服务、优化MyBatis的配置等。对于初学者来说，...
SpringBoot快速搭建实现三步骤解析
08-19
快速搭建SpringBoot应用的三步骤如下： 1. **创建一个普通Maven工程** Maven是Java项目管理工具，它帮助管理项目的构建、报告和文档。在创建SpringBoot项目时，首先需要建立一个标准的Maven项目结构，包括`pom.xml...
IDEA+springboot+mybatis+oracle多模块项目
10-19
这是一个基于IDEA集成开发环境，使用SpringBoot、MyBatis框架，并与Oracle数据库结合的多模块项目。在深入了解这个项目之前，我们先来逐一解析每个关键组件。 **1. IDEA (IntelliJ IDEA)**：IDEA是JetBrains公司...
IDEA快速搭建一个SpringBoot3项目
04-20
在本文中，我们将深入探讨如何使用IntelliJ IDEA（IntelliJ IDEA的简称）这个强大的Java集成开发环境来快速搭建一个基于Spring Boot 3的项目。Spring Boot是Spring框架的一个扩展，它简化了创建独立、生产级别的基于...
搭建maven+springboot+spring的项目架构(一)
小面包
07-04 1020
摘要： 大家好；很久没跟大家在网上写文章分享了；本人参加工作实习到现在转正；我想着想把自己学的东西以通俗易懂的向大家介绍；因为现在社会所用的框架与学校所学的相差不是很大；但是这个人啊一旦接触新的东西就有害怕的感觉；所以我决定从醉醉基础初步向大家展示如何手动一步一步去搭建这样的一个环境；并让大家快速的去了解它。那下面咋们就正式开始吧。 所需工具如下： 社会一般公司都会用idea这个工具；所以还没有...
使用Java和Springboot开发Web应用
YouAreTwoGoods的博客
05-04 884
简单的介绍了springboot web项目的创建，希望能给看此博客的学习者们一个入门的引领。
JavaWeb基础3——Maven基础&MyBatis
vincewm的博客
07-21 5099
构建工具Maven、Maven安装配置、基本使用、IDEA使用Maven、依赖管理、插件、Mybatis、核心配置文件mybatis-config.xml、Mapper代理开发、配置文件实现增删改查、Mybatis参数传递、注解实现增删改查
用maven搭建多模块企业级项目(步骤详细)
热门推荐
御前两把刀的专栏
08-18 1万+
一 开发环境 Eclipse JavaEE IDE，版本代号：Mars.2Release (4.5.2) apache-maven-3.3.9 JDK1.7 apache-tomcat-7.0.29。   二 分模块开发的好处 用Maven管理的比较大的项目大部分都是分模块的，每个模块都对应着一个pom.xml。它们之间通过继承和聚合相互关联。那么，为什么要这么做呢？我们明明在开发一
JavaWeb(三层构架)
qq_64001795的博客
04-12 3788
一、JavaEE开发模式 1.为什么需要分层？ 业务处理的代码与JSP代码混在一起，不易于阅读，不易于代码维护，采用三层软件设计架构后，软件系统在可扩展性和可复用性方面得到极大提高， 2.软件设计中的分层模式 分层模式是最常见的一种架构模式；甚至可以说分层模式是很多架构模式的基础。 模型1 模型1第一代 javaweb03-07 在一个JSP页面中存储这所有交互的代码（HTML+CSS+JS+数据库交互的代码） 模型1第二代 jav...
javaweb项目中完成数据的增删改查操作((maven，mybaits，tomcat，servlet，jsp包含 MVC模式 和 三层架构 ))
weixin_62023527的博客
09-24 1834
javaweb项目中数据的增删改查详细代码内容
java web开发（IDEA下的多module开发）
嵌入式-老费，一个分享专业嵌入式知识的blog
10-07 1526
【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】 稍微复杂一点的程序，都不会只有一个执行文件。而对于java来说，可能一个jar文件同时被web和app使用，这个时候把jar独立出来是最好的选择。所以，对于开发者而言，掌握IDEA下面的多module开发是一个重要的功能。 另外，值得注意的是，IDEA下面的project和其他IDE所说的project不是一回事。以eclipse举例，上面的workspace类似于
SpringBoot入门，快速搭建简单Web应用环境
Nicole1121的博客
07-13 197
我采用的是IDEA来创建的环境 1.基本环境（自行下载安装） JDK:1.8 Intellij IDEA:2018.2.6 Maven:3.5.0 2.开始搭建 首先新建项目： 这是点完finish后的项目目录： 很明显，现在文件夹对应的状态是不对的，要给对应的文件夹“标注”上对应的“角色”，操作步骤如下： file ==》projectStruc...
maven搭建springboot项目
08-16
通过以上步骤，就可以使用Maven快速搭建一个Spring Boot项目了。在项目构建过程中，Maven会自动下载和管理项目所需的依赖，简化了项目配置和管理的工作。同时，Spring Boot框架提供了丰富的功能和约定，使得开发者...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值