沃梦达 / 编程技术 / 编程语言 / Java开发 / 正文

idea聚合工程搭建过程详解

Java开发
2023-01-13

本章主要以order订单服务来远程调用payment支付服务为例，当然这里只是简单的一个远程调用，没有太复杂的逻辑，重点是要掌握的是maven的聚合工程搭建，微服务分模块的思想，每一个步骤我都会详细记录，并且文章下方还提供了git源码地址

注：本篇文章主要参考周阳老师讲解的cloud进行整理的！

前言

本章主要以order订单服务来远程调用payment支付服务为例，当然这里只是简单的一个远程调用，没有太复杂的逻辑，重点是要掌握的是maven的聚合工程搭建，微服务分模块的思想，每一个步骤我都会详细记录，并且文章下方还提供了git源码地址！

最后要实现的代码结构：

框架：mybatis-plus3.4 + springboot2.2.5 + mysql + springcloud的H版本 + spring-cloud-alibaba2.1.0 + maven

本章并不会用到springcloud相关组件，只是在父工程声明了版本！

一、创建父工程

1、New Project

2、聚合父工程的名字

3、指定maven仓库

4、字符编码

5、注解生效激活

6、java编译版本选8

7、File Type过滤

8、父工程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>com.gzl.cn</groupId>
    <artifactId>mscloud</artifactId><packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>

    <modules>
        <module>cloud-provider-payment8001</module>
    </modules>

    <!-- 统一管理jar包版本 -->
    <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>
        <junit.version>4.12</junit.version>
        <log4j.version>1.2.17</log4j.version>
        <lombok.version>1.16.18</lombok.version>
        <mysql.version>5.1.47</mysql.version>
        <druid.version>1.1.16</druid.version>
        <mybatis-plus.boot.version>3.4.0</mybatis-plus.boot.version>
   </properties>

    <!-- 子模块继承之后，提供作用：锁定版本+子modlue不用写groupId和version  -->
    <dependencyManagement>
       <dependencies>
           <!--spring boot 2.2.2-->
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-dependencies</artifactId>
               <version>2.2.2.RELEASE</version>
               <type>pom</type>
               <scope>import</scope>
           </dependency>
           <!--spring cloud Hoxton.SR1-->
           <dependency>
               <groupId>org.springframework.cloud</groupId>
               <artifactId>spring-cloud-dependencies</artifactId>
               <version>Hoxton.SR1</version>
               <type>pom</type>
               <scope>import</scope>
           </dependency>
           <!--spring cloud alibaba 2.1.0.RELEASE-->
           <dependency>
               <groupId>com.alibaba.cloud</groupId>
               <artifactId>spring-cloud-alibaba-dependencies</artifactId>
               <version>2.1.0.RELEASE</version>
               <type>pom</type>
               <scope>import</scope>
           </dependency>
           <dependency>
               <groupId>mysql</groupId>
               <artifactId>mysql-connector-java</artifactId>
               <version>${mysql.version}</version>
           </dependency>
           <dependency>
               <groupId>com.alibaba</groupId>
               <artifactId>druid</artifactId>
               <version>${druid.version}</version>
           </dependency>
           <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>${mybatis-plus.boot.version}</version>
           </dependency>
           <dependency>
               <groupId>junit</groupId>
               <artifactId>junit</artifactId>
               <version>${junit.version}</version>
           </dependency>
           <dependency>
               <groupId>log4j</groupId>
               <artifactId>log4j</artifactId>
               <version>${log4j.version}</version>
           </dependency>
           <dependency>
               <groupId>org.projectlombok</groupId>
               <artifactId>lombok</artifactId>
               <version>${lombok.version}</version>
               <optional>true</optional>
           </dependency>
       </dependencies>
   </dependencyManagement>


   <build>
       <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <!-- maven中跳过单元测试 -->
                <configuration>
                    <skip>true</skip>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

关于maven依赖 ${xxx.version}报错问题：不用管他，当我们有了子项目之后，这里就不报错了。

二、Maven工程细节复习

Maven 使用dependencyManagement 元素来提供了一种管理依赖版本号的方式。
通常会在一个组织或者项目的最顶层的父POM 中看到dependencyManagement 元素。

作用： pom.xml 中的dependencyManagement 元素能让所有在子项目中引用一个依赖而不用显式的列出版本号。 Maven 会沿着父子层次向上走，直到找到一个拥有dependencyManagement 元素的项目，然后它就会使用这个dependencyManagement 元素中指定的版本号。

例如在父项目里：xml代码

<dependencyManagement>
   <dependencies>
	   <dependency>
		   <groupId>mysql</groupId>
		   <artifactId>mysql-connector-java</artifactId>
		   <version>5.1.47</version>
	   </dependency>
   </dependencies>
</dependencyManagement>

然后在子项目里就可以添加mysql-connector时可以不指定版本号,例如：xml代码

<dependencies>
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
	</dependency>
</dependencies>

好处： 如果有多个子项目都引用同一样依赖，则可以避免在每个使用的子项目里都声明一个版本号，这样当想升级或切换到另一个版本时，只需要在顶层父容器里更新，而不需要一个一个子项目的修改 ；另外如果某个子项目需要另外的一个版本，只需要声明version就可以。

注意：

  • dependencyManagement里只是声明依赖，并不实现引入，因此子项目需要显示的声明需要用的依赖。
  • 如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项，并且没有指定具体版本，
  • 才会从父项目中继承该项，并且version和scope都读取自父pom;
  • 如果子项目中指定了版本号，那么会使用子项目中指定的jar版本。
  • 父工程创建完成执行mvn:install将父工程发布到仓库方便子工程继承

三、创建子工程

1、微服务提供者支付Module模块

创建过后的项目结构：

（1）、删掉无用的文件

（2）、创建cloud-provider-payment8001项目

右键项目-》new-》Module

（3）、改pom

<?xml version="1.0" encoding="UTF-8"?>
<?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>mscloud</artifactId><groupId>com.gzl.cn</groupId><version>1.0-SNAPSHOT</version></parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-provider-payment8001</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <!--mysql-connector-java-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--jdbc-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

（4）、写yml

server:
  port: 8001

spring:
  application:
    name: cloud-payment-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db2022?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: root

# mybatis-plus配置打印sql日志
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

（5）、创建表

CREATE TABLE `payment` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'ID',
  `serial` varchar(200) DEFAULT '',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8

（6）、创建启动类

@SpringBootApplication
@MapperScan("com.gzl.cn.mapper")
public class PaymentMain8001 {
    public static void main(String[] args) {
        SpringApplication.run(PaymentMain8001.class, args);
    }
}

（7）、创建实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("payment")
public class Payment implements Serializable {

    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    @TableField(value = "serial")
    private String serial;
}

这个类用于作为controller统一接口返回参数类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommonResult<T> {
    private Integer code;
    private String message;
    private T data;

    public CommonResult(Integer code, String message) {
        this(code, message, null);
    }
}

（8）、创建mapper类

@Repository
public interface PaymentMapper extends BaseMapper<Payment> {
}

（9）、创建controller类

@RestController
@Slf4j
public class PaymentController {

    @Autowired
    private PaymentMapper paymentMapper;

    @PostMapping(value = "/payment/create")
    public CommonResult create(@RequestBody Payment payment) {
        int result = paymentMapper.insert(payment);
        log.info("*****插入操作返回结果:" + result);

        if (result > 0) {
            return new CommonResult(200, "插入数据库成功", result);
        } else {
            return new CommonResult(444, "插入数据库失败", null);
        }
    }

    @GetMapping(value = "/payment/get/{id}")
    public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id) {
        Payment payment = paymentMapper.selectById(id);
        log.info("*****查询结果:{}", payment);
        if (payment != null) {
            return new CommonResult(200, "查询成功", payment);
        } else {
            return new CommonResult(444, "没有对应记录,查询ID: " + id, null);
        }
    }
}

（10）、测试一下两个接口，确保接口可以正常访问

2、微服务消费者订单Module模块

创建过后的项目结构：

（1）、创建cloud-provider-payment8001项目
（2）、改pom（pom跟上个model的pom一样就行）
（3）、写yml（跟上面的model也一样，端口不一样，名称不一样）

 server:
  port: 80
spring:
  application:
    name: cloud-order-service

（4）、主启动
（5）、创建配置类，远程调用我用的RestTemplate，所以这个配置类主要就是把RestTemplate注入到容器

@Configuration
public class ApplicationContextConfig {
   @Bean
   public RestTemplate restTemplate() {
       return new RestTemplate();
   }
}

（6）、创建实体类（跟上个服务的实体类一模一样）
（7）、创建controller

@RestController
public class OrderController {
    public static final String PaymentSrv_URL = "http://localhost:8001";
    @Autowired
    private RestTemplate restTemplate;
    @GetMapping("/consumer/payment/create") //客户端用浏览器是get请求，但是底层实质发送post调用服务端8001
    public CommonResult create(Payment payment) {
        return restTemplate.postForObject(PaymentSrv_URL + "/payment/create", payment, CommonResult.class);
    }

    @GetMapping("/consumer/payment/get/{id}")
    public CommonResult getPayment(@PathVariable Long id) {
        return restTemplate.getForObject(PaymentSrv_URL + "/payment/get/" + id, CommonResult.class, id);
    }
}

（8）、测试接口

3、创建common共用

（1）、观察问题，我们可以创建一个model来专门存放公用的 entity 或者 util 等等，甚至共用的pom依赖我们都可以放到这个里面来。

假如要是存放公用的依赖一定要注意点，例如mysql的依赖，一旦放到公共的model里面，那也就是意味着只要是web的模块引入了公用model，就需要配置mysql，否则项目启动就会报错！所以向model存放公用依赖的时候一定要慎重！

（2）、新建cloud-api-common
（3）、创建pom

<dependencies>
	<!--实体类当中用到了lombok所以需要引入lombok-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>5.1.0</version>
    </dependency>
    <!--我们用的mybatis-plus所以实体类会存在一些mybatis-plus的注解，所以需要引入这个-->
    <dependency>
         <groupId>com.baomidou</groupId>
         <artifactId>mybatis-plus-annotation</artifactId>
         <version>3.4.0</version>
         <scope>compile</scope>
     </dependency>
</dependencies>

（4）、将entity放到这个项目当中
（5）、maven命令clean install一下，或者可以在这里clean install

clean install就是打成jar包放到我们的maven本地仓库当中，然后我们别的项目就可以通过坐标来引用他。

（6）、删除各自的原先有过的entity文件夹
（7）、添加依赖，在8001和80的model当中添加，让他引入我们自己的common

<dependency>
    <groupId>com.gzl.cn</groupId>
    <artifactId>cloud-api-common</artifactId>
    <version>${project.version}</version>
</dependency>

创建过后的项目结构：

git源码：https://gitee.com/gzl_com/spring-cloud.git

到此这篇关于idea聚合工程搭建详解的文章就介绍到这了,更多相关idea聚合工程内容请搜索编程学习网以前的文章希望大家以后多多支持编程学习网！

本文标题为：idea聚合工程搭建过程详解

上一篇： Java开发学习之Bean的作用域和生命周期详解
下一篇： 一文搞懂Spring AOP的五大通知类型

基础教程推荐

学习HTML
学习jQuery
学习Laravel
学习CSS3
学习Vue.js
学习Bootstrap5
学习ThinkPHP
学习AJAX
猜你喜欢
最新文章
热门文章
编程基础
热门标签
网站首页 HTML/CSS 菜单 Layui Yii2