springboot分模块用啥调用

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了springboot分模块用啥调用相关的知识，希望对你有一定的参考价值。

.首先在edu的pom里面导入vod的依赖

<dependency>
<groupId>cn.yl</groupId>
<artifactId>service_vod</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
1
2
3
4
5
1
2
3
4
5
2.在edu的驱动类EDUApplication上的

@SpringBootApplication
1
1
改成

@SpringBootApplication(scanBasePackages = "cn.yl.service.vod","cn.yl.service.edu")
1
1
3.（将 vod 的application.yml 改成如 application-vod.yml 的样式名 ） 在edu的 application.yml 里面添加

spring:
profiles:
active: vod
1
2
3
1
2
3
完成，在测试类中测试
-------使用@Autowired 装填自己模块的方法 如果还是报红

将类上的

！！！！！！！！！！！！！！！！！！！！！！

@SpringBootTest
1
1
改成

@SpringBootTest(classes = EDUApplication.class)
1
1
@Autowired
private VodService vodService;
1
2
1
2
文章知识点与官方知识档案匹配
Java技能树首页概览
109559 人正在系统学习中
打开CSDN APP，看更多技术内容

两个SpringBoot模块互相调用_springboot模块间调用_今晚我一个人的博 ...
两个SpringBoot模块互相调用 注意:本文未使用SpringCloud的Feign和OpenFeign 我们直接上操作步骤 1,首先,在启动类加入RestTemplate,在项目启动的时候,使用@Bean注册到容器中 @SpringBootApplication public class GennlifeGdszApplication ...
继续访问
SpringBoot跨系统调用接口方案_springboot 跨系统_仙道Bob的博客-CSDN...
项目开发中存在系统之间互调问题,又不想用dubbo,这里提供几种springboot方案: 1、使用Feign进行消费(推荐) 2、使用原始httpClient请求 3、使用RestTemplate方法 二、方案 方案一:使用Feign进行消费(推荐) ...
继续访问
Springboot多模块 整合 mybatis maven项目
springboot项目分成多个模块（maven）的简单使用，在加上mybatis 初学者相当实用！
两个SpringBoot模块互相调用
两个SpringBoot模块互相调用 注意:本文未使用SpringCloud的Feign和OpenFeign 我们直接上操作步骤 1，首先，在启动类加入RestTemplate，在项目启动的时候，使用@Bean注册到容器中 @SpringBootApplication public class GennlifeGdszApplication public static void main(String[] args) SpringApplication.run(Gennli
继续访问
SpringBoot +Cloud多模块彼此调用笔记_天亮再出发的博客
首先我们用脚手架创建一个SpringBoot项目 父项目的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...
继续访问
SpringCloud项目跨模块调用报 程序包...不存在 找不到符号
试了常见的所有方法,均不奏效,最终通过比较两个模块的pom文件,得以解决: 在被调用的System模块下加入以下配置: <build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId...
继续访问
最新发布 springboot多个service互相调用的事务处理方式
springboot中service之间相互调用
继续访问
Spring Boot多模块化后,服务间调用的坑及解决
添加配置后截图如下，其中common-1.0-SNAPSHOT-exec.jar为可执行jar，common-1.0-SNAPSHOT.jar为普通jar包。common也是SpringBoot工程，SpringBoot工程打包编译时，会生成两种jar包，一种是普通的jar，另一种是可执行jar。默认情况下，这两种jar的名称相同，在不做配置的情况下，普通的jar先生成，可执行jar后生成，造成可执行jar会覆盖普通的jar。| - - - - - common（通用工具类子工程）parent（父类工程）
继续访问
记Spring Boot多模块(跨module)@Resource、@Autowired等bean注入 NULL问题
在启动类上加上@SpringBootApplication(scanBasePackages = “com.saynight”) 或者@SpringBootApplication及@ComponentScan(basePackages = “com.saynight”) 联合使用 依赖Bean加上@Resource、@Autowire注解，依赖Bean.java文件如CircuitBreakerFactory上加上@Service、@Component注解。 注意bean初始化时代码执行顺序。
继续访问
基于springboot的两个项目之间的远程调用
基于springboot的两个项目之间的远程调用，有问题请提出
两个SpringBoot模块互相调用(基于SpringCloud-Alibaba)
使用SpringCloud-Alibaba组件,利用Nacos,OpenFeign完成远程调用功能一，简介二，环境配置1，首先引入依赖，根据自己使用的spring cloud版本选择2，修改对应服务的配置文件，将服务注册到nacos注册中心三，代码编写1，修改对应服务的启动类，完成服务注册2，编写远程调用方法四，注意事项五，启动项目，此时远程调用接口已经调通，完活收工。 一，简介 在SpringCloud分布式微服务系统中，常会遇到远程调用其他模块的问题，SpringCloud-Alibaba提供了Naco
继续访问

解决SpringBoot引用别的模块无法注入的问题
多模块开发的时候，A模块引入B模块，却无法注入B模块中被。容器中的注解，都是无法在A模块中注入进来。等，只要是你能想到能将类放置在。属性指定包的扫描路径。属性指定包的扫描路径。
继续访问

SpringCloud实现一个模块调用另一个模块的服务
SpringCloud实现一个模块调用另一个模块的服务 简介 基于SpringCloud框架搭建的项目，不同模块之间是无法调用各自的服务的，但是经常我们需要使用这样的模式去开发，那么如何实现不同模块之间的服务调用呢？ 准备 1.在需要调用其他模块服务的项目中创建一个package包，里面定义三个类，如下图 在要调用别的模块的模块加依赖 <dependency> <groupId...
继续访问
SpringBoot：一个模块加载另一个的模块的配置文件
目的：父工程parent下的两个模块，common和eureka，使eureka模块的配置文件可以读取common的配置文件 首先是配置文件类型，我使用的是yml，使用properties也是一样的 目录结构如图： 在commom模块中添加一些自定义配置 yml文件必须以application-XXX.yml格式命名,不然后续配置无法识别 在eureka模块中的配置 # 配置读取common文件 spring: profiles: active: common 通过$表达式,就可以拿
继续访问

springboot中各模块间实现bean之间互相调用（service以及自定义的bean）
1.建一个项目，两个module(注意项目和module都是创建类型如下图) 2. 新建module1: demo1 ; module2: demo3，实现demo3 调用 demo1 的service 建好如图： 3.在demo3中引入demo1的依赖，demo3的pom文件中加入： <dependency> <groupId>com.example</groupId> ...
继续访问

Springcloud-实现跨项目相互调用（简易版）
Spring Cloud Alibaba provides a one-stop solution for application development for the distributed solutions of Alibaba middleware. - 版本说明 · alibaba/spring-cloud-alibaba Wiki。本次将使用订单服务微服务调用用户以及商品的微服务，我们先启动用户以及商品的微服务 最后使用订单微服务调用。-- SpringBoot 依赖配置 -->
继续访问

SpringCloud笔记一： 跨模块调用，服务注册发现（Eureka、Nacos）
Day1：跨模块调用，服务注册发现（Eureka）
继续访问

热门推荐 SpringBoot实现一个项目多模块，多主启动模块，每个模块多环境配置文件
我们在日常开发过程中，在新建一个项目中，我们经常会将一个项目按照功能性、模块等将一个项目分成多个子项目，这些子项目都包含在主项目中。 对于Spring、SpringBoot中实现多模块化，网上有很多教程，这里就不在讲述了。 本次主要讲的是如何在一个项目中能够有两个Application，即有两个启动类，启动不同的启动类，能够访问不同的功能，另外我们开发项目时，需要将配置分为开发环境、测试环境、生产...
继续访问

springboot自定义工具类中,如何调用service层方法
springboot自定义工具类中，如果想调用service层方法，是不能使用传统方式实现的，比如@Autowired HolidayService holidayService或者new HolidayServiceImpl(),需要特殊的配置才能实现调用,否则报null指针异常。
继续访问
【springboot】微服务，实现模块之间的调用
springboot就是spring，是快速配置spring的脚手架，springcloud是很多框架的集合，要使用里面的框架依赖于springboot。@FeignClient(“service-vod”) 指定模块其中service-vod为模块名称，但不能有_/vodService/vod/video/deleteByVoId/videoId 路径不能错。地址：http://localhost:8848/nacos。将模块在注册中心中注册，实现微服务模块之间的互相调用。
继续访问

绝了！这款工具让SpringBoot不再需要Controller、Service、DAO、Mapper！
Dataway介绍 Dataway 是基于 DataQL 服务聚合能力，为应用提供的一个接口配置工具，使得使用者无需开发任何代码就配置一个满足需求的接口。整个接口配置、测试、冒烟、发布，一站式都通过 Dataway 提供的 UI 界面完成。UI 会以 Jar 包方式提供并集成到应用中并和应用共享同一个 http 端口，应用无需单独为 Dataway 开辟新的管理端口。 这种内嵌集成方式模式的优点是，可以使得大部分老项目都可以在无侵入的情况下直接应用 Dataway。进而改进老项目的迭代效率，大大减少企
继续访问
SpringBoot - 跨模块调用自定义注解失败
SpringBoot - 跨模块调用自定义注解失败
继续访问
Spring Boot 多模块开发， 子模块的bean调用问题及解决方法
Spring Boot 多模块工程 1、新建一个maven工程 工程名 ：spring-boot-sample-project 删除多余的文件，只留spring-boot-sample-project工程中的pom.xml文件 2、在spring-boot-sample-project工程中增加子模块 新增：spring-boot-sample-api 模块，注 参考技术A 在Spring Boot中分模块化开发时，可以使用Maven或Gradle多模块项目结构进行管理和调用。具体操作如下：

1. 创建一个父项目，用于管理整个Spring Boot项目的多个模块。

2. 在父项目下创建多个子模块，例如：core模块、service模块、web模块等，每个模块都有自己的pom.xml（Maven）或build.gradle（Gradle）文件，用于管理模块依赖和构建配置。

3. 在父项目的pom.xml（Maven）或build.gradle（Gradle）中，添加对子模块的依赖管理。

4. 在各个模块的代码中，通过Java的import语句、注解或自动装配机制引用其他模块的类或接口。例如，在web模块中可以调用service模块提供的服务。

5. 如果子模块之间存在相互调用的情况，可以在被调用的子模块的pom.xml（Maven）或build.gradle（Gradle）文件中添加相关依赖，然后通过Java的import语句引用其他模块的类或接口。例如：在service模块中调用core模块的方法。

6. 在开发和调试过程中，可以在各个子模块中单独运行和测试。最终打包时，父项目会将各个子模块的代码整合到一个可执行的程序中。

通过以上这种多模块项目结构，可以让Spring Boot项目更加清晰、易于维护和扩展。 参考技术B 在Spring Boot中，分模块可以通过Maven进行实现，可以将不同模块的代码、依赖和资源文件分别打包为一个jar文件。可以通过以下步骤将不同模块的代码进行打包：

1.在Maven项目中创建一个父pom.xml文件，并定义子模块。

2.在子模块中添加依赖和配置文件，这些文件只包含特定的功能和配置。

3.在父pom.xml文件中定义一个<modules>元素来包含所有子模块。

4.通过Maven进行构建打包，生成多个jar文件。

在调用时，可以通过在主程序中引入对应的jar包，然后调用其中的函数和类实现特定的功能。常见的调用方式包括：

1.在Spring Boot应用程序中使用@SpringBootApplication注解，以便能够扫描和加载所有子模块的代码。

2.在配置文件中配置子模块相关的URL和端口等信息。

3.在主程序中通过调用子模块的服务、方法和类等实现多模块之间的交互和调用。

总之，在Spring Boot中使用分模块需要进行一定的配置和编码，以便实现模块之间的依赖和调用。同时，在多模块项目中需要进行模块的合理设计，提高代码的可复用性和可维护性。 参考技术C 您好！在Spring Boot中，分模块可以使用Maven或Gradle来实现。Maven是一种Java项目管理工具，Gradle是一种基于Groovy的构建工具。无论使用哪种工具，都需要在项目的根目录下创建一个父级模块，然后在该模块下创建子模块。
在Maven中，您可以使用<modules>标签将所有子模块列出，然后使用<dependency>标签在父模块和子模块之间建立依赖关系。在Gradle中，您可以使用include和dependencies语句来实现类似的操作。
在调用子模块时，您可以使用Spring Boot的自动配置功能，它会自动扫描所有的模块并加载它们的配置。您也可以使用@ComponentScan注释来手动指定要扫描的包。
总之，使用Maven或Gradle来实现Spring Boot的分模块开发非常方便，可以帮助您更好地组织代码并提高项目的可维护性。 参考技术D springboot模块调用】内容共 100 条
[Python] 模块调用

mb5fdcad8719a20
609 天前
在t_1中定义全局变量a，t_2调用t_1函数，观察a的变化 t_1： a = 0 b = [] def f(): global a a += 1 b.append(1) 函数中的a需要声明global，否则会报错，b不需要声明 t_2： import t_1 t_1.f() t_1.f() pri ...
转载133 阅读点赞评论
SpringBoot 缓存模块

Oolong6868
204 天前
默认的缓存配置 在诸多的缓存自动配置类中, SpringBoot默认装配的是 , 他使用的 是 , 使用 当底层的数据结构,按照Cache的名字查询出Cache, 每一个Cache中存在多个k v键值对,缓存值 几个主要的概念&常用缓存注解 名称 | 解释 | Cache | 缓存接口，主要实现由
原创48 阅读点赞评论
调用模块的方法

大任
128 天前
在开.Acti
原创63 阅读点赞评论
thinkphp 跨模块调用

mob604756f9c5f2
2805 天前
5.13跨模块调用在开发过程中经常会在当前模块调用其他模块的方法，这个时候就涉及到跨模块调用，我们还可以了解到A和R两个快捷方法的使用。例如，我们在Index模块调用User模块的操作方法classIndexActionextendsActionpublicfunctionindex()//实例...
转载80 阅读点赞2
php调用Java模块

mb5fdcaeb38fa57
4481 天前
Java语言功能强大，因此在许多情况下在php中来调用Java的功能将十分有用。在php中调用Java语言有两种方法，一种是使用php中的Java扩展模块，另一种是使用minij2ee应用服务器提供的SJOP协议实现。下面我们来比较一下这两种方法各自的特点。1.php的Java模块php发布版中包含一个Java扩展模块，可以用来调用Java对象，例如：<?php$system=new Jav
转载96 阅读点赞2
Python调用PyAutoGUI模块

wx6296d048c716d
301 天前
目录GUI自动化工具鼠标鼠标移动鼠标拖动鼠标 补间/缓动鼠标点击鼠标的滚动功能键盘GUI自动化工具PyAutoGUI
原创231 阅读点赞评论
Springboot多模块打包

达达智能
35 天前
子模块必须是jar才行<packaging>jar</packaging>子模块打包添加下面的打包配置<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId>
原创62 阅读点赞评论
springboot 集成aop模块

lifeneedyou
1407 天前
aop是spring的核心之一，在springboot之前，使用AOP已经相对比较多了，主要在开发中用于实现日志记录，安全校验，权限等功能。在springboot把Spring的核心功能都简化使用之后，aop的配置并没有太大的变化，基本还是原来的使用。我们做系统增强，分为前增强，后增强，环绕增强三种基本类型，当然我看还有一些实现了return增强之类的，本质上都一样的。Springboot通过@A
原创952 阅读点赞评论
SpringBoot多模块开发

mb5ff5930cde1cd
608 天前
在Javaweb项目开发中为了便于后期的维护，我们一般会进行分层开发，常见的就是分为model

springboot 搭建多模块调用以及打包执行

一 springboot搭建多模块规则

1.1 规则描述

1.父pom.xml 打包方式，jar要更改为pom，build 需要更改

2.不需要打包的模块pom.xml文件中不要写<build>，全删掉，例如有些工程中的common模块，domain模块，dao模块，service模  块都不需要打包

3.在子模块中需要声明父工程，填写父工程位置<relativePath>../pom.xml</relativePath>

4.关于applicatin.properties配置文件，只需要在启动的模块中配置就可以了，

5.关于打包为什么打包jar包，不打war包，打war包目的是war包可以运行在tomcat下，但是SpringBoot是内置tomcat，如果你打war包，前提是干掉内置的tomcat，然后才能打包，各种麻烦，直接打包可执行jar包，使用java -jar 命令就可以完美的运行起来很方便！
6.对象之间的调用是使用@Autowired 注解 来实现注入。

1.2 打比方案例说明

多模块搭建，首先肯定得有一个父工程，还有若干个子模块，子模块可以理解为，可以继承父模块

整个工程你就当作一个公司，父工程（退休了什么也不干）只需要声明有几个儿子（子模块）就完事了，

假设让子模块api作为程序启动模块，子模块api声明父工程是谁，就当他是大儿子，公司他管事，pom.xml文件需要打包，需要build配置，需要其它子模块协助。

其它子模块声明父工程是谁，之间关系都是兄弟，不需要打包，哪里需要去哪里！

二 操作案例

2.1 首先创建一个父模块

1.首先创建一个父模块：huadian-multil-model

2.将工程中的src进行删除

2.2 创建需要的各个子模块

1.创建api，domain，common，dao，service等模块

选中父工程，右键 new module，如下图：

2.最后创建的工程如下：

2.3 各个模块的关系

父模块：  huadian-multil-model

子模块： huadian-api       （页面交互接收、传递数据，唯一有启动类的模块）

              huadian-common   一些常用工具类

             huadian-domain    （实体类）

             huadian-services   （处理业务逻辑）

            huadian-dao   （用于持久化数据跟数据库交互）

调用关系： huadian-api 依赖 huadian-common、huadian-domain、 huadian-services、huadian-dao

               huadian-services  依赖 huadian-common、huadian-domain、 huadian-dao

                huadian-dao   依赖    huadian-common、huadian-domain

                huadian-common 依赖   huadian-domain

2.4 各个模块的pom文件

2.4.1 父模块

<?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>
  <modules>
    <module>huadian-api</module>
    <module>huadian-common</module>
    <module>huadain-service</module>
    <module>huadian-domain</module>
      <module>huadian-dao</module>
  </modules>
  <!--指定项目的spring boot的版本-->
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.3.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>
  <!--版本号-->
  <groupId>com.huadian</groupId>
  <artifactId>huadian-multil-model</artifactId>
  <packaging>pom</packaging> <!--父类为pom-->
  <version>1.0-SNAPSHOT</version>

  <name>huadian-multil-model</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</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>

  <!-- 阿里云maven仓库 -->
  <repositories>
    <repository>
      <id>public</id>
      <name>aliyun nexus</name>
      <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
      <releases>
        <enabled>true</enabled>
      </releases>
    </repository>
  </repositories>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.1</version>
        <configuration>
          <source>${java.version}</source>
          <target>${java.version}</target>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>2.19.1</version>
        <configuration>
          <skipTests>true</skipTests>    <!--默认关掉单元测试 -->
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

2.4.2 api子模块

<?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>
  <!--声明父模块-->
  <parent>
    <groupId>com.huadian</groupId>
    <artifactId>huadian-multil-model</artifactId>
    <version>1.0-SNAPSHOT</version>
    <relativePath>../pom.xml</relativePath>
  </parent>
  <!-- api子模块 -->
  <groupId>com.huadian</groupId>
  <artifactId>huadian-api</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>huadian-api</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</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>
    <!--依赖domain模块-->
    <dependency>
      <groupId>com.huadian</groupId>
      <artifactId>huadian-domain</artifactId>
      <version>1.0-SNAPSHOT</version>
      <!-- <version>${project.parent.version}</version>  -->
    </dependency>
    <!-- 依赖common模块 -->
    <dependency>
    <groupId>com.huadian</groupId>
    <artifactId>huadian-common</artifactId>
    <version>1.0-SNAPSHOT</version>
    </dependency>
    <!-- serverice子模块 -->
    <dependency>
      <groupId>com.huadian</groupId>
      <artifactId>huadain-service</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
    <!-- 依赖dao模块 -->
    <dependency>
      <groupId>com.huadian</groupId>
      <artifactId>huadian-dao</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>

  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <configuration>
          <!-- 指定该Main Class为全局的唯一入口 -->
          <mainClass>com.huadian.App</mainClass>
          <layout>ZIP</layout>
        </configuration>
        <executions>
          <execution>
            <goals>
              <goal>repackage</goal><!--可以把依赖的包都打包到生成的Jar包中-->
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>

2.4.3  service子模块

<?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>
  <!--声明父模块-->
  <parent>
    <groupId>com.huadian</groupId>
    <artifactId>huadian-multil-model</artifactId>
    <version>1.0-SNAPSHOT</version>
    <relativePath>../pom.xml</relativePath>
  </parent>
  <!-- serverice子模块 -->
  <groupId>com.huadian</groupId>
  <artifactId>huadain-service</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>huadain-service</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.mybatis.spring.boot</groupId>
      <artifactId>mybatis-spring-boot-starter</artifactId>
      <version>1.3.2</version>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <scope>runtime</scope>
    </dependency>
    <!--依赖domain模块-->
    <dependency>
      <groupId>com.huadian</groupId>
      <artifactId>huadian-domain</artifactId>
      <version>1.0-SNAPSHOT</version>
      <!-- <version>${project.parent.version}</version>  -->
    </dependency>
    <!-- 依赖common模块 -->
    <dependency>
      <groupId>com.huadian</groupId>
      <artifactId>huadian-common</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
    <!-- 依赖dao模块 -->
    <dependency>
      <groupId>com.huadian</groupId>
      <artifactId>huadian-dao</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>
  </dependencies>

</project>

2.4.4 dao子模块

<?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>
  <!--声明父模块-->
  <parent>
    <groupId>com.huadian</groupId>
    <artifactId>huadian-multil-model</artifactId>
    <version>1.0-SNAPSHOT</version>
    <relativePath>../pom.xml</relativePath>
  </parent>
  <!-- 子模块 -->
  <groupId>com.huadian</groupId>
  <artifactId>huadian-dao</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>huadian-dao</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!--依赖domain模块-->
    <dependency>
      <groupId>com.huadian</groupId>
      <artifactId>huadian-domain</artifactId>
      <version>1.0-SNAPSHOT</version>
      <!-- <version>${project.parent.version}</version>  -->
    </dependency>
  </dependencies>


</project>

2.4.5 common子模块

<?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>
  <!--声明父模块-->
  <parent>
    <groupId>com.huadian</groupId>
    <artifactId>huadian-multil-model</artifactId>
    <version>1.0-SNAPSHOT</version>
    <relativePath>../pom.xml</relativePath>
  </parent>
  <!-- common 子模块 -->
  <groupId>com.huadian</groupId>
  <artifactId>huadian-common</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>

  <name>huadian-common</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</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>
    <!--依赖domain模块-->
    <dependency>
      <groupId>com.huadian</groupId>
      <artifactId>huadian-domain</artifactId>
      <version>1.0-SNAPSHOT</version>
      <!-- <version>${project.parent.version}</version>  -->
    </dependency>

  </dependencies>


</project>

2.4.6 domain子模块

<?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>
  <modules>
    <module>huadian-api</module>
    <module>huadian-common</module>
    <module>huadain-service</module>
    <module>huadian-domain</module>
      <module>huadian-dao</module>
  </modules>
  <!--指定项目的spring boot的版本-->
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.3.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>
  <!--版本号-->
  <groupId>com.huadian</groupId>
  <artifactId>huadian-multil-model</artifactId>
  <packaging>pom</packaging> <!--父类为pom-->
  <version>1.0-SNAPSHOT</version>

  <name>huadian-multil-model</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</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>

  <!-- 阿里云maven仓库 -->
  <repositories>
    <repository>
      <id>public</id>
      <name>aliyun nexus</name>
      <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
      <releases>
        <enabled>true</enabled>
      </releases>
    </repository>
  </repositories>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.1</version>
        <configuration>
          <source>${java.version}</source>
          <target>${java.version}</target>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>2.19.1</version>
        <configuration>
          <skipTests>true</skipTests>    <!--默认关掉单元测试 -->
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

2.5 测试

三  打包

1.不能在api模块package，需要在父模块下，一起打包，如下图

2. 这个时候api模块已经打好包，进入target下执行java -jar

参考：https://blog.csdn.net/baidu_41885330/article/details/81875395

源代码见github

 

以上是关于springboot分模块用啥调用的主要内容，如果未能解决你的问题，请参考以下文章

求助：python 处理日志，用啥模块比较好

不用Swagger，那我用啥？

不用Swagger，那我用啥？

建立java与python的接口，让java能调用python脚本。请问可以用啥方式？

C# winform 类似于如下图显示用啥控件绑定并实现分页

python非线性规划用啥模块