SpringBoot+Mybatis多模块（module）项目搭建教程（springboot多模块mybatis配置）

25-03-02 11

本文将介绍SpringBoot+Mybatis多模块的详细情况，特别是关于module项目搭建教程的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些关于I

本文将介绍SpringBoot+Mybatis多模块的详细情况，特别是关于module项目搭建教程的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些关于IDEA SpringBoot多模块项目搭建详细过程(转)、IDEA 创建 Spring Boot 多模块项目（Multi Modules）、IDEA+Maven + 多个 Module 模块（创建多模块 SpringBoot 整合项目）、IDEA构建多模块（Module）项目的知识。

本文目录一览：

SpringBoot+Mybatis多模块（module）项目搭建教程（springboot多模块mybatis配置）
IDEA SpringBoot多模块项目搭建详细过程(转)
IDEA 创建 Spring Boot 多模块项目（Multi Modules）
IDEA+Maven + 多个 Module 模块（创建多模块 SpringBoot 整合项目）
IDEA构建多模块（Module）项目

SpringBoot+Mybatis多模块（module）项目搭建教程（springboot多模块mybatis配置）

一、前言

最近公司项目准备开始重构，框架选定为SpringBoot+Mybatis，本篇主要记录了在IDEA中搭建SpringBoot多模块项目的过程。

1、开发工具及系统环境

IDE：IntelliJ IDEA 2018.2
系统环境：mac OSX

2、项目目录结构

biz层：业务逻辑层
dao层：数据持久层
web层：请求处理层

二、搭建步骤

1、创建父工程

① IDEA 工具栏选择菜单 File -> New -> Project...

② 选择Spring Initializr，Initializr默认选择Default，点击Next

③ 填写输入框，点击Next

④ 这步不需要选择直接点Next

⑤ 点击Finish创建项目

⑥ 最终得到的项目目录结构如下

⑦ 删除无用的.mvn目录、src目录、mvnw及mvnw.cmd文件，最终只留.gitignore和pom.xml

2、创建子模块

① 选择项目根目录beta右键呼出菜单，选择New -> Module

② 选择Maven，点击Next

③ 填写ArifactId，点击Next

④ 修改Module name增加横杠提升可读性，点击Finish

⑤ 同理添加【beta-dao】、【beta-web】子模块，最终得到项目目录结构如下图

3、运行项目

① 在beta-web层创建com.yibao.beta.web包（注意：这是多层目录结构并非单个目录名，com >> yibao >> beta >> web）并添加入口类BetaWebApplication.java

package com.yibao.beta.web;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author linjian
 * @date 2018/9/29
 */
@SpringBootApplication
public class BetaWebApplication {

    public static void main(String[] args) {
        SpringApplication.run(BetaWebApplication.class, args);
    }
}

② 在com.yibao.beta.web包中添加controller目录并新建一个controller，添加test方法测试接口是否可以正常访问

package com.yibao.beta.web.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author linjian
 * @date 2018/9/29
 */
@RestController
@RequestMapping("demo")
public class DemoController {

    @GetMapping("test")
    public String test() {
        return "Hello World!";
    }
}

③ 运行BetaWebApplication类中的main方法启动项目，默认端口为8080，访问http://localhost:8080/demo/test得到如下效果

以上虽然项目能正常启动，但是模块间的依赖关系却还未添加，下面继续完善

4、配置模块间的依赖关系

各个子模块的依赖关系：biz层依赖dao层，web层依赖biz层

① 父pom文件中声明所有子模块依赖（dependencyManagement及dependencies的区别自行查阅文档）

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.yibao.beta</groupId>
            <artifactId>beta-biz</artifactId>
            <version>${beta.version}</version>
        </dependency>
        <dependency>
            <groupId>com.yibao.beta</groupId>
            <artifactId>beta-dao</artifactId>
            <version>${beta.version}</version>
        </dependency>
        <dependency>
            <groupId>com.yibao.beta</groupId>
            <artifactId>beta-web</artifactId>
            <version>${beta.version}</version>
        </dependency>
    </dependencies>
</dependencyManagement>

其中${beta.version}定义在properties标签中

② 在beta-web层中的pom文件中添加beta-biz依赖

<dependencies>
    <dependency>
        <groupId>com.yibao.beta</groupId>
        <artifactId>beta-biz</artifactId>
    </dependency>
</dependencies>

③ 在beta-biz层中的pom文件中添加beta-dao依赖

<dependencies>
    <dependency>
        <groupId>com.yibao.beta</groupId>
        <artifactId>beta-dao</artifactId>
    </dependency>
</dependencies>

5、web层调用biz层接口测试

① 在beta-biz层创建com.yibao.beta.biz包，添加service目录并在其中创建DemoService接口类

package com.yibao.beta.biz.service;

/**
 * @author linjian
 * @date 2018/9/29
 */
public interface DemoService {

    String test();
}

package com.yibao.beta.biz.service.impl;

import com.yibao.beta.biz.service.DemoService;
import org.springframework.stereotype.Service;

/**
 * @author linjian
 * @date 2018/9/29
 */
@Service
public class DemoServiceImpl implements DemoService {

    @Override
    public String test() {
        return "test";
    }
}

② DemoController通过@Autowired注解注入DemoService，修改DemoController的test方法使之调用DemoService的test方法，最终如下所示

package com.yibao.beta.web.controller;

import com.yibao.beta.biz.service.DemoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author linjian
 * @date 2018/9/29
 */
@RestController
@RequestMapping("demo")
public class DemoController {

    @Autowired
    private DemoService demoService;

    @GetMapping("test")
    public String test() {
        return demoService.test();
    }
}

③ 再次运行BetaWebApplication类中的main方法启动项目，发现如下报错

***************************
APPLICATION Failed TO START
***************************

Description:

Field demoService in com.yibao.beta.web.controller.DemoController required a bean of type 'com.yibao.beta.biz.service.DemoService' that Could not be found.


Action:

Consider defining a bean of type 'com.yibao.beta.biz.service.DemoService' in your configuration.

原因是找不到DemoService类，此时需要在BetaWebApplication入口类中增加包扫描，设置@SpringBootApplication注解中的scanBasePackages值为com.yibao.beta，最终如下所示

package com.yibao.beta.web;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author linjian
 * @date 2018/9/29
 */
@SpringBootApplication(scanBasePackages = "com.yibao.beta")
@MapperScan("com.yibao.beta.dao.mapper")
public class BetaWebApplication {

    public static void main(String[] args) {
        SpringApplication.run(BetaWebApplication.class, args);
    }
}

设置完后重新运行main方法，项目正常启动，访问http://localhost:8080/demo/test得到如下效果

6、集成Mybatis

① 父pom文件中声明mybatis-spring-boot-starter及lombok依赖

dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.22</version>
        </dependency>
    </dependencies>
</dependencyManagement>

② 在beta-dao层中的pom文件中添加上述依赖

<dependencies>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>MysqL</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
</dependencies>

③ 在beta-dao层创建com.yibao.beta.dao包，通过mybatis-genertaor工具生成dao层相关文件（DO、Mapper、xml），存放目录如下

④ applicatio.properties文件添加jdbc及mybatis相应配置项

spring.datasource.driverClassName = com.MysqL.jdbc.Driver
spring.datasource.url = jdbc:MysqL://192.168.1.1/test?useUnicode=true&characterEncoding=utf-8
spring.datasource.username = test
spring.datasource.password = 123456

mybatis.mapper-locations = classpath:mybatis/*.xml
mybatis.type-aliases-package = com.yibao.beta.dao.entity

⑤ DemoService通过@Autowired注解注入UserMapper，修改DemoService的test方法使之调用UserMapper的selectByPrimaryKey方法，最终如下所示

package com.yibao.beta.biz.service.impl;

import com.yibao.beta.biz.service.DemoService;
import com.yibao.beta.dao.entity.UserDO;
import com.yibao.beta.dao.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author linjian
 * @date 2018/9/29
 */
@Service
public class DemoServiceImpl implements DemoService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public String test() {
        UserDO user = userMapper.selectByPrimaryKey(1);
        return user.toString();
    }
}

⑥ 再次运行BetaWebApplication类中的main方法启动项目，发现如下报错

APPLICATION Failed TO START
***************************

Description:

Field userMapper in com.yibao.beta.biz.service.impl.DemoServiceImpl required a bean of type 'com.yibao.beta.dao.mapper.UserMapper' that Could not be found.


Action:

Consider defining a bean of type 'com.yibao.beta.dao.mapper.UserMapper' in your configuration.

原因是找不到UserMapper类，此时需要在BetaWebApplication入口类中增加dao层包扫描，添加@MapperScan注解并设置其值为com.yibao.beta.dao.mapper，最终如下所示

package com.yibao.beta.web;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author linjian
 * @date 2018/9/29
 */
@SpringBootApplication(scanBasePackages = "com.yibao.beta")
@MapperScan("com.yibao.beta.dao.mapper")
public class BetaWebApplication {

    public static void main(String[] args) {
        SpringApplication.run(BetaWebApplication.class, args);
    }
}

设置完后重新运行main方法，项目正常启动，访问http://localhost:8080/demo/test得到如下效果

至此，一个简单的SpringBoot+Mybatis多模块项目已经搭建完毕，我们也通过启动项目调用接口验证其正确性。

四、总结

一个层次分明的多模块工程结构不仅方便维护，而且有利于后续微服务化。在此结构的基础上还可以扩展common层（公共组件）、server层（如dubbo对外提供的服务）

此为项目重构的第一步，后续还会的框架中集成logback、disconf、redis、dubbo等组件

五、未提到的坑

在搭建过程中还遇到一个maven私服的问题，原因是公司内部的maven私服配置的中央仓库为阿里的远程仓库，它与maven自带的远程仓库相比有些jar包版本并不全，导致在搭建过程中好几次因为没拉到相应jar包导致项目启动不了。

IDEA SpringBoot多模块项目搭建详细过程(转)

文章转自https://blog.csdn.net/zcf980/article/details/83040029

项目源码：链接: https://pan.baidu.com/s/1Gp9cY1Qf51tG9-5gUZsnHQ 提取码: 5izt

CSDN源码下载： https://download.csdn.net/download/zcf980/10719615

1. 项目介绍：

本项目包含一个父工程 demo 和四个子模块（demo-base, demo-dao, demo-service, demo-web)， demo-base 为其他三个模块的公共内容，四个模块都依赖父模块， demo-dao 依赖 demo-base； demo-service 依赖 demo-dao, 间接依赖 demo-base; demo-web 依赖 demo-service, 间接依赖demo-base和demo-dao

2. 搭建思路：

先创建一个 Spring Initializr工程 demo 作为父工程，然后在父工程再建四个子 Module (demo-base, demo-demo-dao, demo-service), 其实他们就是四个普通的Spring Initializr工程

3.开始搭建

首先，创建一个Spring Initializr项目和子Module

！！！！注意：修改demo 的 pom 文件中的打包方式为 pom

好戏开始：
刚才演示创建成一个SpringBoot 工程，下面正式开始演示搭建多模块
(1) 第一步，删除刚才创建工程里的文件，只保留(.idea文件夹 , 和项目 pom 文件, 以及一个 *.iml 文件 )

（2）第二步，创建子 Module （demo-base， demo-dao, demo-service 和 demo-web）先创建demo-base子工程

创建好了 demo-base 子项目，为子工程 demo-base 生命父工程以及为父工程声明子 Module（在 demo 和 demo-base 的 pom 文件中添加如下代码）

---->在 demo-base 中声明父工程，注意：此时demo-base继承的是 SpringBoot提供的父工程，需要修改<parent></parent>

中的版本信息，修改成父项目 demo 的版本信息（直接将父项目 demo 的pom文件中的版本信息复制粘贴到 mode-base 中即可）

--- 声明父工程

<parent>
<groupId>demo</groupId>
<artifactId>demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<relativePath/> 
</parent>
----声明子 Module

<modules>
<module>demo-base</module>
</modules>
修改后的父工程 demo 的 pom 文件

<?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>demo</groupId>
<artifactId>demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>demo</name>
<description>Demo project for Spring Boot</description>


<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.16.RELEASE</version>
<relativePath/> 
</parent>


<modules>
<module>demo-base</module>
</modules>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>

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

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>

</project>
修改后的 demo-base 的 pom 文件

<?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>demo</groupId>
<artifactId>demo-base</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>demo-base</name>
<description>Demo project for Spring Boot</description>


<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.16.RELEASE</version>
<relativePath/> 
</parent>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>

</project>
创建demo-dao, demo-service 创建方法一样，这里只演示demo-dao的创建

创建demo-web 模块与demo-dao创建除了第4步，完全相同需要添加 web依赖，在创建过程的第4步需要添加 web 依赖

(4) 第三步保留demo-web的启动类和配置文件，其他项目的启动类都删除，整个项目只需要一个启动类和一个配置文件

demo-base: /demo/demo-base/src/main/java/demobase/demo/DemoBaseApplication.java 删除

/demo/demo-base/src/main/java/resource/* 删除

demo-dao: /demo/demo-dao/src/main/java/demodao/demo/DemoDaoApplication.java 删除

/demo/demo-dao/src/main/java/resource/* 删除

demo-service: /demo/demo-service/src/main/java/demoservice/demo/DemoServiceApplication.java 删除

/demo/demo-service/src/main/java/resource/* 删除

(5)第四步在 demo-dao 中添加 demo-base 的依赖信息，在 demo-service 中添加 demo-dao 的依赖信息，在 demo-web 中添加 demo-service 的依赖信息, 依赖信息添加到各 pom 文件下的 <dependencies> </dependencies>节点下

添加依赖信息后的 demo-dao 的依赖信息

<dependencies>


<dependency>
<groupId>demo</groupId>
<artifactId>demo-base</artifactId>
<version>0.0.1-SNAPSHOT</version>
<scope>compile</scope>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
添加依赖信息后的 demo-service 的依赖信息
<dependencies>


<dependency>
<groupId>demo</groupId>
<artifactId>demo-dao</artifactId>
<version>0.0.1-SNAPSHOT</version>
<scope>compile</scope>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
添加依赖信息后的 demo-web 的依赖信息

<dependencies>


<dependency>
<groupId>demo</groupId>
<artifactId>demo-service</artifactId>
<version>0.0.1-SNAPSHOT</version>
<scope>compile</scope>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
(6)第五步编写测试代码

编写好代码后三个模块的目录结构（demo-base还未用上，但实际项目中很有用）：

下面贴上代码：

给demo-dao 添加

Demo.java

package demo.demodao;

import javax.persistence.*;

@Entity(name = "demo") //设置实体名，在数据库中是表名
public class Demo {

@Id
@GeneratedValue(strategy = GenerationType.AUTO) //设置自动增长
@Column(name = "id")
private Integer id;

@Column(name = "name") //设置数据库字段名
private String name;

@Column(name = "id")
private Integer id;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Integer getId() {
return id;
}

public void setId(Integer id) {
this.id = id;
}
}
DemoRepository.java

package demo.demodao;

import org.springframework.data.jpa.repository.JpaRepository;

public interface DemoRepository extends JpaRepository<Demo, Integer> {

}
DemoService.java

package demo.demoservice;

import demo.demodao.Demo;

import java.util.List;

public interface DemoService {

Demo addOne(Demo demo);

}
DemoServiceImpl.java

package demo.demoservice.impl;

import demo.demodao.Demo;
import demo.demodao.DemoRepository;
import demo.demoservice.DemoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class DemoServiceImpl implements DemoService {

@Autowired
private DemoRepository demoRepository;

@Override
public Demo addOne(Demo demo) {
return this.demoRepository.save(demo);
}
}
DemoController.java

package demo.demoweb;

import demo.demodao.Demo;
import demo.demoservice.DemoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class DemoController {

@Autowired
private DemoService demoService;

@ResponseBody // 返回 Json 数据
@GetMapping("add")
private Demo add(){
Demo demo = new Demo();
demo.setName("姓名");
demo.setId(1);
return demoService.addOne(demo); // 成功返回保存后的 demo
}

}
第六步：创建数据库，修改配置文件

创建输数据库 test

修改配置文件：将 demo-web Resource目录下 application.properties 文件名改为 applicatin.yml并添加以下内容：

spring:
datasource:
# jdbc:mysql://localhost:3306/test 数据库地址
url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&useSSL=false
username: root # 数据库用户名
password: xxxxxx # 数据库密码
driver-class-name: com.mysql.jdbc.Driver # 数据库驱动

jpa:
hibernate:
ddl-auto: create-drop # create-drop 如果实体对应的表已存在，先删除再创建，否则直接创建
# ！！！注意：第一次运行时可设置为 create-drop, 这样就不需要手动创建数据库表, 但是后面运行务必设置为none

(7) 第七步：大功告成，运行项目

直接运行会报错

已解决：将启动类 DemoApplication 移动到 demo 包下

移动：

运行成功！！！！！！！

项目搭建过程中遇到的问题：

Error:(3, 20) java: 程序包demo.demodao不存在

解决方法，在控制台执行 mvn clean

IDEA 创建 Spring Boot 多模块项目（Multi Modules）

本准备写点代码实例放到网站，太多的模板，反而每次新建工程的时候很麻烦。于是准备把这个章节的内容提前先讲讲。正好把这个代码也管理起来。话说这个多模块功能还挺爽。

写过 C# 项目用过 Visual Studio 的人已经用惯了一大把的项目放在一个解决方案中，下面我来实践一下 Java Spring Boot 的玩法。

TOC {:toc}

本项目源码spring-boot-study-helloworld下载本项目源码spring-boot-study-helloworld-service下载

本章演示的多模块之间的关系如下图：spring-boot-study-helloworld 依赖人 spring-boot-study-helloworld-service 调用其方法 message 输出字符串。项目关系图

本章节主要实现

一个 maven 工程下多个模块项目按时
一个 maven 工程下各个项目的依赖关系
一个 maven 工程下可以有多个 web application 项目共存

1 建立根项目 Root Project

使用 IDEA 创建一个 Maven 工程

File>New>Project，如下图选择 maven ，注意 Create from archetype 不能打钩，然后点击【Next】下一步。
填写GroupId（包名）、Artifact（项目名）即可。点击【Next】下一步

groupId=com.fishpro
artifactId=springstudy

项目名设置为 spring-boot-study
打开 pom.xml 编辑，增加 <packaging>pom</packaging>

<?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.fishpro</groupId>
    <artifactId>springstudy</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
</project>

删除 src 文件
注意如果您是创建的 spring 项目作为根项目，那么您需要删除 src、mvnw、mvnw.cmd、HELP.md、.mvn 文件

2 建立子项目

子项目可以是类库项目、Web应用项目

应用模块项目例如 Application 或 Web Application
类库 Jar 模块项目，即 Library Jar

2.1 建立子Web Application 模块 spring-boot-study-helloworld

右键项目名称 spring-boot-study > New > Module 进入项目模块新增页面
因为我们这里是 Spring Boot 项目，那么我选择 Spring Initializr 选择【Next】
填写GroupId（包名）、Artifact（项目名）即可。点击【Next】下一步

groupId=com.fishpro
artifactId=helloworld

设置模块为 maven 中的子模块 项目名设置为 spring-boot-study-helloworld，至此子项目已经添加完了，但你会发现，子项目不能允许调试，必须在根目录下的 pom.xml 配置此项目才行。
设置父项目 pom.xml 加入模块 spring-boot-study-helloworld

<?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.fishpro</groupId>
    <artifactId>springstudy</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <modules>
        <module>spring-boot-study-helloworld</module>
    </modules>
</project>

重命名application.properties 为 application.yml 增加端口设置，为了和前天模块不冲突

server:
  port: 8082

设置父项目的pom 7. 简单调试，右键 com.fishpro.helloworld.HelloworldApplication > Run HelloworldApplication 子项目 Helloworld 就运行起来了。调试子模块项目 我们还可以使用相同的方式增加多个模块

2.2 建立另一个 library jar 子模块项目 spring-boot-study-hellowrld-servie

右键项目名称 spring-boot-study > New > Module 进入项目模块新增页面
因为我们这里是 Spring Boot 项目，那么我选择 Spring Initializr 选择【Next】
填写GroupId（包名）、Artifact（项目名）即可。点击【Next】下一步

groupId=com.fishpro.helloworld
artifactId=service 4.新建类 MyService

package com.fishpro.helloworld.service;
import org.springframework.stereotype.Service;
@Service
public class MyService {
    public String message(){
        return "this is module for helloworld.service method message";
    }
}

2.3 建立模块之间的依赖关系

有的时候一个项目的 dao、service、controller 是分在不同的模块中，那么他们之间就有一些依赖关系，通常这些依赖关系是单向的。

本项目中项目 spring-boot-study-hellowrld 依赖项目 spring-boot-study-helloworld-service ，那么在 spring-boot-study-hellowrld 模块下 pom.xml 中设置

<dependency>
	<groupId>com.fishpro.helloworld</groupId>
	<artifactId>service</artifactId>
	<version>0.0.1-SNAPSHOT</version>
</dependency>

2.4 在 helloworld 模块中调用 helloworld.service 模块方法

我们在 helloworld 项目下新建 controller.IndexController

package com.fishpro.helloworld.controller;

import com.fishpro.helloworld.service.MyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class IndexController {
    @Autowired
    MyService myService;
    @GetMapping("/say")
    public String say(){
        return  myService.message();
    }
}

在浏览器中输入 http://localhost:8082/say 显示 hellowrld 项目调用成功

this is module for helloworld.service method message

2.4 建立另一个独立的 web application 子模块项目 spring-boot-study-log

我们再建立一个项目，项目名称 spring-boot-study-log 方法同第 2 节一样。最终效果图如下：多项目效果图

至此，我们发现可以多个 web application 是可以共存的。所以我们后面的所有示例都是在这个项目中体现。

2.5 图形化管理模块界面

IDEA 中也可以通过图形化管理模块在 File > Project Structrue 中管理项目的模块多模块项目管理

本项目中 application.properties 已经重新命名为 application.yml

IDEA+Maven + 多个 Module 模块（创建多模块 SpringBoot 整合项目）

最近在学习 springboot，先从创建项目开始，一般项目都是一个项目下会有多个模块，这里先创建一个最简单的实例，一个项目下有一个 springboot 模块项目提供 web 服务，引用另一个 java 项目（相当于业务逻辑）
期望的项目结构如下
springboot-test
—-springboot-api
—-springboot-utils

一、创建空 Maven 项目
首先打开 IDEA，点击 “Create New Project”

选择 Maven，点击下一步

填写信息，直到完成项目创建

创建成功后

删除 src 文件夹，在 pom 文件中添加

二、创建 Springboot 项目模块
在根项目上点击右键，选择 Module

选择 Spring Initializr

填写信息

选择依赖项

完成向导，springboot-api 是新建出来的项目

三、创建 utils 项目模块
再次新建 Module

选择 Spring Initializr

填写信息

什么都不选，完成向导

完成后项目结构如下

四、添加项目依赖
我们希望 api 项目能够使用 utils 项目的类，需要在 api 项目中引用 utils 项目
在 api 项目的 pom.xml 的 dependencies 节点添加如下内容

<dependency>
<groupId>com.gl</groupId>
<artifactId>springboot-utils</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
结果如下

五、编写测试代码
上面添加好了依赖，下面我们分别编写 api 项目和 utils 项目的测试代码验证一下项目结构和依赖

假设我们在 utils 项目中有个 helper 类，类里有个获取系统时间的方法，希望访问 api 接口的时候返回系统时间，api 接口需要使用 helper 类获取系统时间

1、编写 utils 项目代码
在 utils 项目下建立包和类，如下

类中写方法
/**
* 获取当前时间
* @return
*/
public static Date getCurDate()
{
Date d = new Date();
return d;
}

2、编写 api 项目代码
在 api 项目的代码下添加包
在新建的包下添加测试类
最终结构如下

编写接口方法

3、测试
执行 api 项目

访问接口地址，可以显示出来时间

---------------------
作者：天堂地址不详 Y
来源：CSDN
原文：https://blog.csdn.net/tiantangdizhibuxiang/article/details/81130297
版权声明：本文为博主原创文章，转载请附上博文链接！

IDEA构建多模块（Module）项目

参考视频

IDEA-多模块（Module）项目的构建

https://www.bilibili.com/video/BV18a4y1i7nF?p=4&spm_id_from=pageDriver

IDEA-Module的使用
IDEA设置Module之间的依赖关系
IDEA多Module调用和测试
IDEA创建多Module Maven项目

Project（工程）和Module（模块）

当前，主流的大型项目都是分布式部署的，结构一般如下：

IDEA一个项目下，可以有多个模块，各模块之间可以相互依赖和调用。它们是属于同一业务项目下的模块。

IDEA创建项目的时候，默认是单模块的。

module需要先移除，然后才能删除

1.创建第一个project工程demo

创建成功后，找到main方法可运行

2.创建一个模块demo1

3.运行模块demo

主模块无需做任何操作，就可直接运行

4.运行模块demo1

模块demo1的方法不能运行，需要进行一些设置。

经过如下设置后，主模块demo和子模块demo1均可运行

主模块demo的设置（原来就有，不是我设置的）

创建后，我移除了这个模块，然后又添加进来，才设置了这些，都是参考主模块设置的

2个模块端口是冲突的，所以我修改了一下

application.yml

server:
  port: 9002

server:
  port: 9001

运行

运行效果

关于SpringBoot+Mybatis多模块和module项目搭建教程的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于IDEA SpringBoot多模块项目搭建详细过程(转)、IDEA 创建 Spring Boot 多模块项目（Multi Modules）、IDEA+Maven + 多个 Module 模块（创建多模块 SpringBoot 整合项目）、IDEA构建多模块（Module）项目的相关信息，请在本站寻找。

本文标签：