微服务初级入门实战分布式项目构建

微服务初级入门实战分布式项目构建

1、创建聚合工程springcloud2022

1.1、创建maven工程

父工程名称

1.2、选择maven版本

1.3、修改字符编码

1.4、注解生效激活

1.5、选择java编译版本

1.6、过滤不需要的文件

目录是为了不在项目显示下面的忽略的文件

创建的maven项目还附带了src目录内容，将其移除，因为父工程是不需要的，只会用到pom.xml文件

2、父工程pom.xml文件的编写

<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.0modelVersion>

  <groupId>com.zcl.springcloudgroupId>
  <artifactId>springcloud2022artifactId>
  <version>1.0-SNAPSHOTversion>
  <packaging>pompackaging>

  
  <properties>
    <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    <maven.compiler.source>1.8maven.compiler.source>
    <maven.compiler.target>1.8maven.compiler.target>
    <junit.version>4.12junit.version>
    <log4j.version>1.2.17log4j.version>
    <lombok.version>1.16.18lombok.version>
    <mysql.version>5.1.47mysql.version>
    <druid.version>1.1.16druid.version>
    <mybatis.spring.boot.version>1.3.0mybatis.spring.boot.version>
  properties>

  
  <dependencyManagement>
    <dependencies>
      
      <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-dependenciesartifactId>
        <version>2.2.2.RELEASEversion>
        <type>pomtype>
        <scope>importscope>
      dependency>
      
      <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-dependenciesartifactId>
        <version>Hoxton.SR1version>
        <type>pomtype>
        <scope>importscope>
      dependency>
      
      <dependency>
        <groupId>com.alibaba.cloudgroupId>
        <artifactId>spring-cloud-alibaba-dependenciesartifactId>
        <version>2.1.0.RELEASEversion>
        <type>pomtype>
        <scope>importscope>
      dependency>
      <dependency>
        <groupId>mysqlgroupId>
        <artifactId>mysql-connector-javaartifactId>
        <version>${mysql.version}version>
      dependency>
      <dependency>
        <groupId>com.alibabagroupId>
        <artifactId>druidartifactId>
        <version>${druid.version}version>
      dependency>
      <dependency>
        <groupId>org.mybatis.spring.bootgroupId>
        <artifactId>mybatis-spring-boot-starterartifactId>
        <version>${mybatis.spring.boot.version}version>
      dependency>
      <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>${junit.version}version>
      dependency>
      <dependency>
        <groupId>log4jgroupId>
        <artifactId>log4jartifactId>
        <version>${log4j.version}version>
      dependency>
      <dependency>
        <groupId>org.projectlombokgroupId>
        <artifactId>lombokartifactId>
        <version>${lombok.version}version>
        <optional>trueoptional>
      dependency>
    dependencies>
  dependencyManagement>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-maven-pluginartifactId>
        <configuration>
          <fork>truefork>
          <addResources>trueaddResources>
        configuration>
      plugin>
    plugins>
  build>
project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

2.1、dependencyManagement与dependencies的区别

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

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

如果需要使用自己规定的版本，就自己添加版本的信息就可以了

2.2、Maven跳过单元测试

如果没有点击，那么在打包或编译的时候也会把单元测试的内容执行一次

3、服务提供者支付模块

注意：不说明包的创建路径，自己看package包结构进行创建

3.1、在父工程下创建子工程cloud-provider-payment8001

3.2、修改pom.xml文件

<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>springcloud2022artifactId>
        <groupId>com.zcl.springcloudgroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>cloud-provider-payment8001artifactId>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>
        

        
        <dependency>
            <groupId>org.mybatis.spring.bootgroupId>
            <artifactId>mybatis-spring-boot-starterartifactId>
        dependency>
        
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>druid-spring-boot-starterartifactId>
            <version>1.1.10version>
        dependency>
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-jdbcartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <scope>runtimescope>
            <optional>trueoptional>
        dependency>
        
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
    dependencies>

project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

3.3、编写YAML配置文件

server:
  port: 8081

spring:
  application:
    name: cloud-payment-service # 指定程序名称
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource # 数据源操作类型
    driver-class-name: org.gjt.mm.mysql.Driver # mysql驱动包
    url: jdbc:mysql://localhost:3306/cloud2022?useUnicode=true&characterEncoding=utf-8&useSSL=false # 使用5.0mysql数据库
    username: root
    password: 1234

mybatis:
  mapper-locations: classpath:mapper/*.xml # 映射文件
  type-aliases-package: com.zcl.springcloud.entities # 所有实体所在的包


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

3.4、编写项目启动类

package com.zcl.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * 描述：项目启动类
 *
 * @author zhong
 * @date 2022-09-14 10:43
 */
@SpringBootApplication
public class PaymentMain8001 {
    public static void main(String[] args) {
        SpringApplication.run(PaymentMain8001.class, args);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

3.5、编写业务类

1、编写MySQL数据库内

创建一个cloud2022数据库,并执行下面的语句生产支付表

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
1
2
3
4
5

2、编写实体

数据库字段映射实体

package com.zcl.springcloud.entities;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * 描述：订单实体类
 *
 * @author zhong
 * @date 2022-09-14 10:56
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Payment implements Serializable {
    /**订单id*/
    private Long id;
    /**订单流水*/
    private String serial;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

统一的返回前端数据实体

package com.zcl.springcloud.entities;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 描述：返回前端通用的json实体
 *
 * @author zhong
 * @date 2022-09-14 11:02
 */
@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);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

3、编写dao层

接口的编写

package com.zcl.springcloud.dao;

import com.zcl.springcloud.entities.Payment;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

/**
 * 描述：支付接口
 *
 * @author zhong
 * @date 2022-09-14 11:03
 */
@Mapper
public interface PaymentDao {
    /**
     * 写操作
     * @param payment
     * @return
     */
    int create(Payment payment);

    /**
     * 根据id读取
     * @param id
     * @return
     */
    Payment getPaymentById(@Param("id") Long id);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

映射文件的编写

注意：映射文件的位置在【src/main/resources/mapper/PaymentDao.xml】文件下

如果安装了MyBatisX插件的话，映射接口与映射文件之间是可以跳过点击实现跳转的

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zcl.springcloud.dao.PaymentDao">

    
    <insert id="create" parameterType="Payment" useGeneratedKeys="true" keyProperty="id">
        insert into payment (serial)
        values (#{serial});
    insert>

    
    <resultMap id="BaseResultMap" type="com.zcl.springcloud.entities.Payment">
        
        <id column="id" property="id"/>
        <result column="serial" property="serial"/>
    resultMap>

    
    <select id="getPaymentById" parameterType="long" resultMap="BaseResultMap">
        select *
        from payment
        where id = #{id};
    select>
mapper>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

4、创建业务层

业务层的接口与dao层的接口是一样的

package com.zcl.springcloud.service;

import com.zcl.springcloud.entities.Payment;
import org.apache.ibatis.annotations.Param;

/**
 * 描述：支付业务接口
 *
 * @author zhong
 * @date 2022-09-14 11:50
 */
public interface PaymentService {
    /**
     * 写操作
     * @param payment
     * @return
     */
    int create(Payment payment);

    /**
     * 根据id读取
     * @param id
     * @return
     */
    Payment getPaymentById(@Param("id") Long id);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

在同级包下创建impl包并在里面创建业务接口的实现类,所有的业务内容都是在实现类里面完成，并且需要注入业务层来与数据层进行访问

package com.zcl.springcloud.service.impl;

import com.zcl.springcloud.dao.PaymentDao;
import com.zcl.springcloud.entities.Payment;
import com.zcl.springcloud.service.PaymentService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * 描述：支付接口实现类
 *
 * @author zhong
 * @date 2022-09-14 11:52
 */
@Service
public class PaymentServiceImpl implements PaymentService {

    /**
     * 注入数据访问层接口
     */
    @Resource
    private PaymentDao paymentDao;

    @Override
    public int create(Payment payment) {
        return paymentDao.create(payment);
    }

    @Override
    public Payment getPaymentById(Long id) {
        return paymentDao.getPaymentById(id);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

3.6、控制器的编写

由于是模拟的是前后端项目，控制器只需要返回json格式给前端处理，所以通过@RestController来指定返回的数据都是json格式

package com.zcl.springcloud.controller;

import com.zcl.springcloud.entities.CommonResult;
import com.zcl.springcloud.entities.Payment;
import com.zcl.springcloud.service.PaymentService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;

/**
 * 描述：支付控制器
 *
 * @author zhong
 * @date 2022-09-14 11:56
 */
@Slf4j
@RestController
@RequestMapping("/payment")
public class PaymentController {

    /**
     * 注入业务接口
     */
    @Resource
    private PaymentService paymentService;

    /**
     * 根据id查询支付信息
     * @param id
     * @return
     */
    @GetMapping("/get/{id}")
    public CommonResult getPaymentById(@PathVariable("id") Long id)
    {
        Payment payment = paymentService.getPaymentById(id);
        log.info("查询操作返回结果:" + payment);

        if(payment != null)
        {
            return new CommonResult(200,"查询成功",payment);
        }else{
            return new CommonResult(444,"查询失败",null);
        }
    }

    /**
     * 插入支付信息
     * @param payment
     * @return
     */
    @PostMapping("/create")
    public CommonResult create(@RequestBody Payment payment)
    {
        int result = paymentService.create(payment);
        log.info("插入操作返回结果:" + result);

        if(result > 0)
        {
            return new CommonResult(200,"插入数据库成功",result);
        }else{
            return new CommonResult(444,"插入数据库失败",null);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

3.7、启动项目测试

项目测试的途径使用postman

4、热部署Devtools的使用【开发阶段使用、生产阶段关闭】

为什么需要热部署，因为没一次修改代码如果都需要进行项目的重启就会显得很繁琐，所以通过下面的方式可以简化手动重启的过程

4.1、在需要热部署的项目中引入依赖

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-devtoolsartifactId>
    <scope>runtimescope>
    <optional>trueoptional>
dependency>
1
2
3
4
5
6

4.2、在聚合的父工程下配置热部署插件

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-maven-pluginartifactId>
            <configuration>
                <fork>truefork>
                <addResources>trueaddResources>
            configuration>
        plugin>
    plugins>
build>
1
2
3
4
5
6
7
8
9
10
11
12

4.3、修改IDEA配置

4.4、开启自动更新

4.5、当项目代码发生改变时，5秒后就会进行重新启动

5、消费者订单模块

5.1、创建消费者模块cloud-consumer-order80

5.2、修改pom.xml文件

<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>springcloud2022artifactId>
        <groupId>com.zcl.springcloudgroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>cloud-consumer-order80artifactId>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <scope>runtimescope>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
    dependencies>
project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

5.3、编写YAML配置

server:
  port: 80
1
2

5.4、编写启动类

package com.zcl.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * 描述：消费者启动类
 *
 * @author zhong
 * @date 2022-09-14 13:15
 */
@SpringBootApplication
public class MainApp80 {
    public static void main(String[] args) {
        SpringApplication.run(MainApp80.class, args);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

5.5、创建实体

该模块也会使用到支付模块中相同的实体和返回前端的实体，所以将支付模块的entities包下的内容复制到当前的项目使用，后面会作整合重构

5.6、创建项目控制器

package com.zcl.springcloud.controller;

import com.zcl.springcloud.entities.CommonResult;
import com.zcl.springcloud.entities.Payment;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;

/**
 * 描述：订单控制器
 *
 * @author zhong
 * @date 2022-09-14 13:21
 */
@Slf4j
@RestController
@RequestMapping("/consumer/payment")
public class OrderController {

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

5.7、需要完善后面的控制器代码需要了解【步骤6】

由于消费者模块80与支付模块8081是两个不同的模块并且暴露的端口也是不一致的，那么需要两个模块之间的连接目前使用最简单的方式就是RestTemplate,下面的代码必须完成【步骤6】中的配置才能使用，通过RestTemplate就可以实现服务间的访问了

package com.zcl.springcloud.controller;

import com.zcl.springcloud.entities.CommonResult;
import com.zcl.springcloud.entities.Payment;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;

/**
 * 描述：订单控制器
 *
 * @author zhong
 * @date 2022-09-14 13:21
 */
@Slf4j
@RestController
@RequestMapping("/consumer/payment")
public class OrderController {
    public static final String PaymentSrv_URL = "http://localhost:8081/payment";

    /**
     * 注入远程调用方法
     */
    @Resource
    private RestTemplate restTemplate;

    /**
     * 更根据id查询支付订单
     * @param id
     * @return
     */
    @GetMapping("/get/{id}")
    private CommonResult<Payment> getPayment(@PathVariable("id") Long id) {
        return restTemplate.getForObject(PaymentSrv_URL + "/get/"+id, CommonResult.class, id);

    }

    /**
     * 消费支付请求
     * @param payment
     * @return
     */
    @PostMapping("/create")
    private CommonResult<Payment> create(@RequestBody Payment payment) {
        return restTemplate.postForObject(PaymentSrv_URL+"/create",payment, CommonResult.class);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

5.8、启动项目测试

由于当前有了两个服务，IDEA会默认的提示我们开启新的运行方式，通过下图的方式就可以更方便的启动多服务工程了

通过postman进行测试80端口的服务是否可以访问到8081端口内容

默认的http端口就是80，所以不需要指定端口号

http://localhost/consumer/payment/get/3

http://localhost/consumer/payment/create
1
2
3

6、什么是RestTemplate

RestTemplate提供了多种便捷访问远程Http服务的方法， 是一种简单便捷的访问restful服务模板类，是Spring提供的用于访问Rest服务的客户端模板工具集

官方地址：https://docs.spring.io/spring-framework/docs/5.2.2.RELEASE/javadoc-api/org/springframework/web/client/RestTemplate.html

6.1、使用方式

使用restTemplate访问restful接口非常的简单粗暴无脑。(url, requestMap, ResponseBean.class)这三个参数分别代表 REST请求地址、请求参数、HTTP响应转换被转换成的对象类型。

在消费者模块添加config配置类

package com.zcl.springcloud.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

/**
 * 描述：RestTemplate配置类
 *
 * @author zhong
 * @date 2022-09-14 13:29
 */
@Configuration
public class ApplicationContextConfig {
    @Bean
    public RestTemplate restTemplate()
    {
        return new RestTemplate();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

7、重构项目结构

为什么需要重构项目，在消费模块以及支付模块都有一个共同的实体类包entities，里面的内容也是一直的，那么我们就可以把该实体类抽取出来作为一个单独的模块，并将其打包为jar包的方式被其他模块引入使用，简化开发

7.1、创建公共模块cloud-api-commons

7.2、修改pom.xml文件

<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>springcloud2022artifactId>
        <groupId>com.zcl.springcloudgroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>
    <packaging>jarpackaging>
    <artifactId>cloud-api-commonsartifactId>

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

    <dependencies>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <scope>runtimescope>
            <optional>trueoptional>
        dependency>
        
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>
        
        <dependency>
            <groupId>cn.hutoolgroupId>
            <artifactId>hutool-allartifactId>
            <version>5.1.0version>
        dependency>
    dependencies>

project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

7.3、创建实体包和类

把支付模块的entities包复制到当前的公共模块中，后面通过打包就可以被其他模块使用了

7.4、将公共模块打包

7.5、模块引入jar包

在需要的模块(消费模块、支付模块)中通过下面的方式引入打包后的公共模块即可使用里面的实体类内容了

<dependency>
    <groupId>com.zcl.springcloudgroupId>
    <artifactId>cloud-api-commonsartifactId>
    <version>${project.version}version>
dependency>
1
2
3
4
5
6

7.6、移除原来模块的entities实体

7.7、项目启动原来的功能是否正常

说明：该内容是第二次编写，第一次是修改名称被覆盖为空白内容了，如果上面的内容运行有上面错误的可以直接留言，后面也会将开发放上