SpringCloud-3-基础工程构建

4 springcloud基础工程构建

4.1 Spring Cloud版本选择

• 在使用 Spring Boot + Spring Cloud 进行微服务开发时，我们需要根据项目中 Spring Boot 的版本来决定 Spring Cloud 版本，否则会出现许多意想不到的错误。

• Spring Boot 与 Spring Cloud 的版本对应关系如下表（参考自 Spring Cloud 官网）。

注意：Spring Cloud 官方已经停止对 Dalston、Edgware、Finchley 和 Greenwich 的版本更新。

• 除了上表中展示的版本对应关系之外，我们还可以使用浏览器访问 https://start.spring.io/actuator/info，获取 Spring Cloud 与 Spring Boot 的版本对应关系（JSON 版）。

{		
	...
    "bom-ranges": {
            ...
            "spring-cloud": {
                "Hoxton.SR12": "Spring Boot >=2.2.0.RELEASE and <2.4.0.M1",
                "2020.0.6": "Spring Boot >=2.4.0.M1 and <2.6.0-M1",
                "2021.0.0-M1": "Spring Boot >=2.6.0-M1 and <2.6.0-M3",
                "2021.0.0-M3": "Spring Boot >=2.6.0-M3 and <2.6.0-RC1",
                "2021.0.0-RC1": "Spring Boot >=2.6.0-RC1 and <2.6.1",
                "2021.0.3": "Spring Boot >=2.6.1 and <3.0.0-M1",
                "2022.0.0-M1": "Spring Boot >=3.0.0-M1 and <3.0.0-M2",
                "2022.0.0-M2": "Spring Boot >=3.0.0-M2 and <3.0.0-M3",
                "2022.0.0-M3": "Spring Boot >=3.0.0-M3 and <3.0.0-M4",
                "2022.0.0-M4": "Spring Boot >=3.0.0-M4 and <3.1.0-M1"
            },
            ....
     }
     ...
     }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

• spring-cloud实际开发版本与spring-boot版本关系

当前的spring-cloud-dependencies依赖版本采用年号版

4.2 DEMO整体介绍及创建

• 由 Spring Boot 创建的微服务，为了方便管理，这里我们采用 Maven 的多 Module 结构（即一个 Project 包含多个 Module）来构建工程。使用一个Dept部门模块做一个微服务通用案例Consumer消费者(Client)通过REST调用Provider提供者(Server)提供的服务。
• 回忆Spring,SpringMVC,MyBatis等以往学习的知识
• Maven的分包分模块架构复习

一个简单的Maven模块结构是这样的：
-app-parent:一个父项目(app-parent)聚合很多子项目(app-util,app-dao,app-web...)
	--pom.xm1

--app-core
	--pom.xml

--app-web
	--pom.xm1
 --
1
2
3
4
5
6
7
8
9
10

• 一个父工程带着多个子Module子模块
• spring-cloud-microservice父工程(Project)下初次带着3个子模块(Module)
• • microservicecloud-api【封装的整体entity/接口/公共配置等】
  • microservicecloud-provider-dept-8001【服务提供者】
  • microservicecloud-consumer-dept-80【服务消费者】

4.3 创建基础父工程（Maven Project）

• 创建一个普通的maven项目名为 spring-cloud-microservice的 Maven 主工程 ，然后在该主工程的 pom.xml 中使用 dependencyManagement 来管理 Spring Cloud 的版本，切记Packageing是pom模式.内容如下。
• 主要是定义POM文件，将后续各个子模块公用的jar包等统一提取出来，类似一个抽象父类。
• 后续服务提供者、消费者，分布式组件基于此基础工程使用

    4.0.0

    org.example
    spring-cloud-microservice
    1.0-SNAPSHOT
    
        microservice-cloud-api
        microservice-cloud-provider-dept-8001
    

    
    pom

    
        8
        8
        1.8
        @
        ${java.version}
        ${java.version}
        UTF-8
        UTF-8
        4.13.2
        2.0.0-alpha7
        2.17.2
        1.18.24
        1.2.11
    
    
        
            
                
                org.springframework.cloud
                spring-cloud-dependencies
                2021.0.3
                pom
                import
            
            
            
                org.springframework.boot
                spring-boot-dependencies
                2.7.2
                pom
                import
            
            
            
                mysql
                mysql-connector-java
                8.0.29
            
            
            
                com.alibaba
                druid
                1.2.11
            
            
            
                org.mybatis.spring.boot
                mybatis-spring-boot-starter
                2.2.2
            
            
                org.projectlombok
                lombok
                ${lombok.version}
            
            
            
                junit
                junit
                ${junit.version}
            
            
            
                ch.qos.logback
                logback-core
                ${logback-core.version}
            
            
                org.apache.logging.log4j
                log4j-core
                ${log4j.version}
            
        
    
    
        spring-cloud-microservice
        
        
            
                src/main/resources
                
                    **/*.yml
                    **/*.properties
                    **/*.xml
                
                true
            
            
                src/main/java
                
                    **/*.yml
                    **/*.properties
                    **/*.xml
                
                true
            
        
        
            
                org.apache.maven.plugins
                maven-resources-plugin
                
                
                    
                        $
                    
                
            
        
    

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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

4.4 创建公共子模块（Maven Module）

• 在父工程下，创建一个名为 microservice-cloud-api 的 Maven Module：microservice-cloud-api，其 pom.xml 配置如下。

    
        spring-cloud-microservice
        org.example
        1.0-SNAPSHOT
    
    4.0.0

    microservice-cloud-api

    
        8
        8
    

    
        
            org.projectlombok
            lombok
        
    

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

注：microservice-cloud-api 是整个工程的公共子模块，它包含了一些其他子模块共有的内容，例如实体类、公共工具类、公共依赖项等。当其他子模块需要使用公共子模块中的内容时，只需要在其 pom.xml 引入公共子模块的依赖即可。

• idea链接mysql数据库，注意设置时区serverTimezone=UTC

• 创建一个数据库springcloud_db_core,并在数据库中创建一张部门表dept

CREATE DATABASE springcloud_db_core DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
DROP TABLE IF EXISTS `dept`;
CREATE TABLE `dept` (
  `dept_no` int NOT NULL AUTO_INCREMENT,
  `dept_name` varchar(255) DEFAULT NULL,
  `db_source` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`dept_no`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;


-- DATABASE()当前数据库名字
INSERT INTO `dept` VALUES ('1', '开发部', DATABASE());
INSERT INTO `dept` VALUES ('2', '人事部', DATABASE());
INSERT INTO `dept` VALUES ('3', '财务部', DATABASE());
INSERT INTO `dept` VALUES ('4', '市场部', DATABASE());
INSERT INTO `dept` VALUES ('5', '运维部', DATABASE());
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• 在microservice-cloud-api的 com.zk.springcloud.entity 包下，创建一个名为 Dept 的实体类，代码如下。

序列化就是为了防止用户访问量过多 服务器内存多度消耗

package com.zk.springcloud.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.io.Serializable;

@Data
@NoArgsConstructor
@Accessors(chain = true) //链式编程 true 如果为 true，setter 将返回this对象而不是void
public class Dept implements Serializable {
    private Integer deptNo;
    private String deptName;
    //这个数据数是存在哪个数据库的宇段
    //微服务，一个服务对应一个数据库，同一个信息可能存在不同的数据库
    private String dbSource;

    public Dept(String deptName) {
        this.deptName = deptName;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

链式编程只是简化了写法，没有什么影响，有些时候代码中需要new对象插入，正常情况下需要命名，链式可以直接new 对象.set直接插入，避免了想命名的麻烦

下一篇：SpringCloud-4-基础工程-创建服务提供者