第01篇_SpringCloud_Netflix

第01章_微服务概述

第一节 系统架构演变

1. 传统的单体架构

单体架构指将一个应用的全部功能都整合在一起，以减少部署节点和成本，对于小型应用来说非常适用。缺点是其不同模块间代码高度耦合，也无法进行水平扩展。

2. 垂直应用架构

当传统的单体架构无法满足日益增长的业务需求时，于是将应用按照不同的模块进行拆分，实现流量分担，并支持对不同的模块进行优化和水平扩展。缺点是系统间相互独立，会有很多的重复开发工作，影响开发效率。

3. 分布式架构

当垂直应用越来越多，应用之间交互不可避免，将核心业务或基础业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使应用能更快速的响应多变的市场需求。缺点是系统间耦合度变高，调用关系错综复杂，难以维护。

4. 面向服务的架构(SOA)

在分布式架构下，当部署的服务越来越多，需要增加一个统一的调度中心来对集群进行实时管理。此时，系统就会演变为面向服务的架构(SOA)。缺点是服务间关系复杂，相互依赖，一旦某个环节出错可能造成服务雪崩，而且运维、测试部署困难，不符合DevOps思想。

5. 微服务架构

微服务一词源于Martin Fowler的博文Microservices。简单地说，微服务是系统架构上的一种设计风格，它的主旨是将一个原本独立的系统拆分为多个小型服务，这些小型服务都在各自独立的进程中运行，服务之间通过基于HTTP的RESTful API进行通信协作。被拆分成的每一个小型服务都围绕着系统中的某一项或一些耦合度较高的业务功能进行构建，并且每个服务都维护着自身的数据存储、业务开发、自动化测试案例以及独立的部署机制。由于有了轻量级的通信协作基础，所以这些微服务可以使用不同的语言来编写。

第二节 微服务技术选型

1. SpringCloud简介

微服务是一种架构设计思想，需要具体的技术进行落地。SpringColud是一个分布式微服务架构的一站式解决方案，是多种微服务架构技术落地的集合体，俗称微服务全家桶。

• Eureka：服务治理组件，包含服务注册与发现机制的实现。

• Zuul：网关组件，提供智能路由，访问过滤等功能。

• Ribbon：负载均衡组件，进行客户端负载均衡。

• Feign：服务调用组件，进行服务间远程调用。

• Hystrix：容错管理组件，实现断路器模式，在服务出现故障时进行熔断或降级。

2. 新的微服务组件

随着技术的不断迭代，出现了一些更优秀的微服务组件，将会在后续的章节中进行介绍。

3. 版本选择

打开SpringCloud官方文档，选择最新的一个稳定版本。

然后点击Reference Doc，查看推荐的SpringBoot版本。

第三节 微服务父工程搭建(聚合工程)

1. 创建Maven工程

2. 选择Maven版本

3. 设置字符编码

4. 开启注解处理器

5. 选择编译版本

6. POM文件配置

​x
1
<?xml version="1.0" encoding="UTF-8"?>
2
<project xmlns="http://maven.apache.org/POM/4.0.0"
3
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5
    <modelVersion>4.0.0</modelVersion>
6

7
    <!-- GAV坐标 -->
8
    <groupId>com.huangyuanxin.SpringCloud</groupId>
9
    <artifactId>SpringCloud-demo</artifactId>
10
    <version>1.0-SNAPSHOT</version>
11
    <!-- 父工程(聚合工程)的打包方式一般为POM -->
12
    <packaging>pom</packaging>
13

14
    <!-- 定义一些属性 -->
15
    <properties>
16
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
17
        <maven.compiler.source>1.8</maven.compiler.source>
18
        <maven.compiler.target>1.8</maven.compiler.target>
19
        <junit.version>4.12</junit.version>
20
        <log4j.version>1.2.17</log4j.version>
21
        <lombok.version>1.16.18</lombok.version>
22
        <mysql.version>5.1.47</mysql.version>
23
        <druid.version>1.1.16</druid.version>
24
        <mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
25
    </properties>
26

27
    <!-- 依赖版本管理  -->
28
    <dependencyManagement>
29
        <dependencies>
30
            <dependency>
31
                <groupId>org.springframework.boot</groupId>
32
                <artifactId>spring-boot-dependencies</artifactId>
33
                <version>2.2.2.RELEASE</version>
34
                <type>pom</type>
35
                <scope>import</scope>
36
            </dependency>
37
            <dependency>
38
                <groupId>org.springframework.cloud</groupId>
39
                <artifactId>spring-cloud-dependencies</artifactId>
40
                <version>Hoxton.SR1</version>
41
                <type>pom</type>
42
                <scope>import</scope>
43
            </dependency>
44
            <dependency>
45
                <groupId>com.alibaba.cloud</groupId>
46
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
47
                <version>2.1.0.RELEASE</version>
48
                <type>pom</type>
49
                <scope>import</scope>
50
            </dependency>
51
            <dependency>
52
                <groupId>mysql</groupId>
53
                <artifactId>mysql-connector-java</artifactId>
54
                <version>${mysql.version}</version>
55
            </dependency>
56
            <dependency>
57
                <groupId>com.alibaba</groupId>
58
                <artifactId>druid</artifactId>
59
                <version>${druid.version}</version>
60
            </dependency>
61
            <dependency>
62
                <groupId>org.mybatis.spring.boot</groupId>
63
                <artifactId>mybatis-spring-boot-starter</artifactId>
64
                <version>${mybatis.spring.boot.version}</version>
65
            </dependency>
66
            <dependency>
67
                <groupId>junit</groupId>
68
                <artifactId>junit</artifactId>
69
                <version>${junit.version}</version>
70
            </dependency>
71
            <dependency>
72
                <groupId>log4j</groupId>
73
                <artifactId>log4j</artifactId>
74
                <version>${log4j.version}</version>
75
            </dependency>
76
            <dependency>
77
                <groupId>org.projectlombok</groupId>
78
                <artifactId>lombok</artifactId>
79
                <version>${lombok.version}</version>
80
                <optional>true</optional>
81
            </dependency>
82
        </dependencies>
83
    </dependencyManagement>
84

85
    <!-- 编译插件  -->
86
    <build>
87
        <plugins>
88
            <plugin>
89
                <groupId>org.springframework.boot</groupId>
90
                <artifactId>spring-boot-maven-plugin</artifactId>
91
                <configuration>
92
                    <fork>true</fork>
93
                    <addResources>true</addResources>
94
                </configuration>
95
            </plugin>
96
        </plugins>
97
    </build>
98

99
</project>

7. 安装到本地仓库

8. 注意事项

• 如果依赖无法下载或下载缓慢，请修改Maven的setting.xml文件，添加阿里云的镜像。

  24
  1
  <!--添加阿里云的镜像-->
  2
  <profiles>
  3
      <profile>
  4
          <id>aliyun</id> 
  5
          <repositories>
  6
              <repository>
  7
                  <id>aliyun</id> 
  8
                  <url>http://maven.aliyun.com/nexus/content/repositories/central/</url> 
  9
                  <releases>
  10
                      <enabled>true</enabled>
  11
                  </releases> 
  12
                  <snapshots>
  13
                      <enabled>true</enabled> 
  14
                      <updatePolicy>always</updatePolicy>
  15
                  </snapshots>
  16
              </repository>
  17
          </repositories>
  18
      </profile> 
  19
  </profiles>
  20
  
  21
  <!--进行激活-->
  22
  <activeProfiles>
  23
      <activeProfile>aliyun</activeProfile>
  24
  </activeProfiles>
  

• 如果出现Command line is too long. Shorten command line for xxx or also for Application default configuration错误，请修改.idea/workspace.xml文件，添加如下属性。

  4
  1
    <component name="PropertiesComponent">
  2
      <property name="dynamic.classpath" value="true" />
  3
    </component>
  4
      
  

第四节 业务工程搭建

1. 通用模块搭建

通用模块提供多个微服务共用的实体、工具和一些基础功能等。

1) 新建SpringCloud-common模块

• 打开左侧Project窗口(默认打开)。

• 右击父工程名称->New->Module，进入New Module窗口。

• 选择合适的Module SDK->Next。

• 检查Parent是否为预期的父工程名称。

• 配置name为SpringCloud-common。

• 检查Location、GAV等是否正确。

2) 修改pom.xml文件

33
1
<?xml version="1.0" encoding="UTF-8"?>
2
<project xmlns="http://maven.apache.org/POM/4.0.0"
3
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5
    <parent>
6
        <artifactId>SpringCloud-demo</artifactId>
7
        <groupId>com.huangyuanxin.SpringCloud</groupId>
8
        <version>1.0-SNAPSHOT</version>
9
    </parent>
10
    <modelVersion>4.0.0</modelVersion>
11

12
    <artifactId>SpringCloud-common</artifactId>
13

14
    <dependencies>
15
        <dependency>
16
            <groupId>org.springframework.boot</groupId>
17
            <artifactId>spring-boot-devtools</artifactId>
18
            <scope>runtime</scope>
19
            <optional>true</optional>
20
        </dependency>
21
        <dependency>
22
            <groupId>org.projectlombok</groupId>
23
            <artifactId>lombok</artifactId>
24
            <optional>true</optional>
25
        </dependency>
26
        <dependency>
27
            <groupId>cn.hutool</groupId>
28
            <artifactId>hutool-all</artifactId>
29
            <version>5.1.0</version>
30
        </dependency>
31
    </dependencies>
32

33
</project>

3) 编写实体类

• DAO层Payment实体

22
1
package com.huangyuanxin.springcloud.common.model;
2

3
import lombok.AllArgsConstructor;
4
import lombok.Data;
5
import lombok.NoArgsConstructor;
6
import lombok.ToString;
7

8
import java.io.Serializable;
9

10
/**
11
 * @Author: huangyuanxin
12
 * @Date: 2022/5/9
13
 */
14
@Data
15
@ToString
16
@AllArgsConstructor
17
@NoArgsConstructor
18
public class Payment implements Serializable {
19
    private Long id;
20
    private String serial;
21
}
22

• Controller层CommonResult实体

25
1
package com.huangyuanxin.springcloud.common.model;
2

3
import lombok.AllArgsConstructor;
4
import lombok.Data;
5
import lombok.NoArgsConstructor;
6
import lombok.ToString;
7

8
/**
9
 * @Author: huangyuanxin
10
 * @Date: 2022/5/9
11
 */
12
@Data
13
@ToString
14
@AllArgsConstructor
15
@NoArgsConstructor
16
public class CommonResult<T> {
17
    private Integer code;
18
    private String message;
19
    private T data;
20

21
    public CommonResult(Integer code, String message) {
22
        this(code, message, null);
23
    }
24
}
25

4) 安装到本地仓库

• 打开右侧Maven窗口。

• 展开SpringCloud-common工程。

• 点击Lifecycle下的install进行安装。

• 等待片刻，当run窗口打印出"BUILD SUCCESS"字样即表示安装成功。

5) SQL脚本

9
1
CREATE TABLE `payment`
2
(
3
    `id`     bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'ID',
4
    `serial` varchar(200) DEFAULT '',
5
    PRIMARY KEY (`id`)
6
) ENGINE = InnoDB
7
  AUTO_INCREMENT = 1
8
  DEFAULT CHARSET = utf8
9

2. 服务提供者-支付服务搭建

1) 新建SpringCloud-service-pay模块

• 打开左侧Project窗口(默认打开)。

• 右击父工程名称->New->Module，进入New Module窗口。

• 选择合适的Module SDK->Next。

• 检查Parent是否为预期的父工程名称。

• 配置name为SpringCloud-service-pay。

• 检查Location、GAV等是否正确。

2) 修改pom.xml文件

65
1
<?xml version="1.0" encoding="UTF-8"?>
2
<project xmlns="http://maven.apache.org/POM/4.0.0"
3
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5
    <parent>
6
        <artifactId>SpringCloud-demo</artifactId>
7
        <groupId>com.huangyuanxin.SpringCloud</groupId>
8
        <version>1.0-SNAPSHOT</version>
9
    </parent>
10
    <modelVersion>4.0.0</modelVersion>
11

12
    <artifactId>SpringCloud-service-pay</artifactId>
13

14
    <dependencies>
15
        <!-- 引入通用模块 -->
16
        <dependency>
17
            <groupId>com.huangyuanxin.SpringCloud</groupId>
18
            <artifactId>SpringCloud-common</artifactId>
19
            <version>1.0-SNAPSHOT</version>
20
        </dependency>
21
        <dependency>
22
            <groupId>org.springframework.boot</groupId>
23
            <artifactId>spring-boot-starter-web</artifactId>
24
        </dependency>
25
        <dependency>
26
            <groupId>org.springframework.boot</groupId>
27
            <artifactId>spring-boot-starter-actuator</artifactId>
28
        </dependency>
29
        <dependency>
30
            <groupId>org.mybatis.spring.boot</groupId>
31
            <artifactId>mybatis-spring-boot-starter</artifactId>
32
        </dependency>
33
        <dependency>
34
            <groupId>com.alibaba</groupId>
35
            <artifactId>druid-spring-boot-starter</artifactId>
36
            <version>1.1.10</version>
37
        </dependency>
38
        <dependency>
39
            <groupId>mysql</groupId>
40
            <artifactId>mysql-connector-java</artifactId>
41
        </dependency>
42
        <dependency>
43
            <groupId>org.springframework.boot</groupId>
44
            <artifactId>spring-boot-starter-jdbc</artifactId>
45
        </dependency>
46
        <dependency>
47
            <groupId>org.springframework.boot</groupId>
48
            <artifactId>spring-boot-devtools</artifactId>
49
            <scope>runtime</scope>
50
            <optional>true</optional>
51
        </dependency>
52
        <dependency>
53
            <groupId>org.projectlombok</groupId>
54
            <artifactId>lombok</artifactId>
55
            <optional>true</optional>
56
        </dependency>
57
        <dependency>
58
            <groupId>org.springframework.boot</groupId>
59
            <artifactId>spring-boot-starter-test</artifactId>
60
            <scope>test</scope>
61
        </dependency>
62
    </dependencies>
63

64
</project>
65

3) 配置application.yml

18
1
# 支付服务单机版端口为8100，集群版依次为8101、8102、8103...
2
server:
3
  port: 8100
4

5
spring:
6
  application:
7
    name: cloud-payment-service
8
  datasource:
9
    type: com.alibaba.druid.pool.DruidDataSource
10
    driver-class-name: org.gjt.mm.mysql.Driver
11
    url: jdbc:mysql://106.53.120.230:3306/atguigu?useUnicode=true&characterEncoding=utf-8&useSSL=false
12
    username: root
13
    password: Hyx147741
14

15
mybatis:
16
  mapperLocations: classpath:mapper/*.xml
17
  type-aliases-package: com.huangyuanxin.springcloud.pay.model,com.huangyuanxin.springcloud.common.model
18
  

4) 编写启动类PayApplication

12
1
package com.huangyuanxin.springcloud.pay;
2

3
import org.springframework.boot.SpringApplication;
4
import org.springframework.boot.autoconfigure.SpringBootApplication;
5

6
@SpringBootApplication
7
public class PayApplication {
8
    public static void main(String[] args) {
9
        SpringApplication.run(PayApplication.class, args);
10
    }
11
}
12

5) DAO层

13
1
package com.huangyuanxin.springcloud.pay.dao;
2

3
import com.huangyuanxin.springcloud.common.model.Payment;
4
import org.apache.ibatis.annotations.Mapper;
5
import org.apache.ibatis.annotations.Param;
6

7
@Mapper
8
public interface PaymentDao {
9
    int create(Payment payment);
10

11
    Payment getPaymentById(@Param("id") Long id);
12
}
13

6) Mapper文件

14
1
<?xml version="1.0" encoding="UTF-8" ?>
2
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
3

4
<mapper namespace="com.huangyuanxin.springcloud.pay.dao.PaymentDao">
5
    <insert id="create" useGeneratedKeys="true" keyProperty="id">
6
        INSERT INTO payment(SERIAL) VALUES(#{serial});
7
    </insert>
8

9
    <select id="getPaymentById" resultType="Payment">
10
        SELECT * FROM payment WHERE id=#{id};
11
    </select>
12

13
</mapper>
14

注意：Mapper文件必须放在mybatis.mapperLocations属性配置的路径下，默认值为Mapper接口的同级目录。

8) Service层

• 接口

10
1
package com.huangyuanxin.springcloud.pay.service;
2

3
import com.huangyuanxin.springcloud.common.model.Payment;
4

5
public interface PaymentService {
6
    int create(Payment payment);
7

8
    Payment getPaymentById(Long id);
9
}
10

• 实现

26
1
package com.huangyuanxin.springcloud.pay.service.impl;
2

3
import com.huangyuanxin.springcloud.common.model.Payment;
4
import com.huangyuanxin.springcloud.pay.dao.PaymentDao;
5
import com.huangyuanxin.springcloud.pay.service.PaymentService;
6
import org.springframework.stereotype.Service;
7

8
import javax.annotation.Resource;
9

10
@Service
11
public class PaymentServiceImpl implements PaymentService {
12
    @Resource
13
    private PaymentDao paymentDao;
14

15

16
    @Override
17
    public int create(Payment payment) {
18
        return paymentDao.create(payment);
19
    }
20

21
    @Override
22
    public Payment getPaymentById(Long id) {
23
        return paymentDao.getPaymentById(id);
24
    }
25
}
26
 

9) Controller层

41
1
package com.huangyuanxin.springcloud.pay.controller;
2

3
import com.huangyuanxin.springcloud.common.model.CommonResult;
4
import com.huangyuanxin.springcloud.common.model.Payment;
5
import com.huangyuanxin.springcloud.pay.service.PaymentService;
6
import lombok.extern.slf4j.Slf4j;
7
import org.springframework.beans.factory.annotation.Value;
8
import org.springframework.web.bind.annotation.*;
9

10
import javax.annotation.Resource;
11

12
@RestController
13
@Slf4j
14
public class PaymentController {
15
    @Resource
16
    private PaymentService paymentService;
17

18
    @Value("${server.port}")
19
    private String serverPort;
20

21
    @PostMapping(value = "/payment/create")
22
    public CommonResult create(@RequestBody Payment payment) {
23
        int result = paymentService.create(payment);
24
        if (result > 0) {
25
            return new CommonResult(200, "端口[" + serverPort + "]插入数据库成功", result);
26
        } else {
27
            return new CommonResult(444, "端口[" + serverPort + "]插入数据库失败", null);
28
        }
29
    }
30

31
    @GetMapping(value = "/payment/get/{id}")
32
    public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id) {
33
        Payment payment = paymentService.getPaymentById(id);
34
        if (payment != null) {
35
            return new CommonResult(200, "端口[" + serverPort + "]查询成功", payment);
36
        } else {
37
            return new CommonResult(444, "端口[" + serverPort + "]没有对应记录,查询ID: " + id, null);
38
        }
39
    }
40
}
41

10) 测试支付服务

启动支付微服务，点击http://localhost:8100/payment/get/1进行测试！

3. 服务消费者-订单服务搭建

1) 新建SpringCloud-service-order模块

• 打开左侧Project窗口(默认打开)。

• 右击父工程名称->New->Module，进入New Module窗口。

• 选择合适的Module SDK->Next。

• 检查Parent是否为预期的父工程名称。

• 配置name为SpringCloud-service-order。

• 检查Location、GAV等是否正确。

2) 修改pom.xml文件

48
1
<?xml version="1.0" encoding="UTF-8"?>
2
<project xmlns="http://maven.apache.org/POM/4.0.0"
3
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5
    <parent>
6
        <artifactId>SpringCloud-demo</artifactId>
7
        <groupId>com.huangyuanxin.SpringCloud</groupId>
8
        <version>1.0-SNAPSHOT</version>
9
    </parent>
10
    <modelVersion>4.0.0</modelVersion>
11

12
    <artifactId>SpringCloud-service-order</artifactId>
13

14
    <dependencies>
15
        <!--引入通用模块-->
16
        <dependency>
17
            <groupId>com.huangyuanxin.SpringCloud</groupId>
18
            <artifactId>SpringCloud-common</artifactId>
19
            <version>1.0-SNAPSHOT</version>
20
        </dependency>
21
        <dependency>
22
            <groupId>org.springframework.boot</groupId>
23
            <artifactId>spring-boot-starter-web</artifactId>
24
        </dependency>
25
        <dependency>
26
            <groupId>org.springframework.boot</groupId>
27
            <artifactId>spring-boot-starter-actuator</artifactId>
28
        </dependency>
29
        <dependency>
30
            <groupId>org.springframework.boot</groupId>
31
            <artifactId>spring-boot-devtools</artifactId>
32
            <scope>runtime</scope>
33
            <optional>true</optional>
34
        </dependency>
35
        <dependency>
36
            <groupId>org.projectlombok</groupId>
37
            <artifactId>lombok</artifactId>
38
            <optional>true</optional>
39
        </dependency>
40
        <dependency>
41
            <groupId>org.springframework.boot</groupId>
42
            <artifactId>spring-boot-starter-test</artifactId>
43
            <scope>test</scope>
44
        </dependency>
45
    </dependencies>
46

47
</project>
48

3) 配置application.yml

12
1
# 订单服务单机版端口为8200，集群版依次为8201、8202、8203...
2
server:
3
  port: 8200
4

5
spring:
6
  application:
7
    name: cloud-order-service
8

9
order:
10
  # 订单服务地址和端口
11
  PaymentSrv_URL: "http://127.0.0.1:8100"
12
  

4) 编写启动类OrderApplication

12
1
package com.huangyuanxin.springcloud.order;
2

3
import org.springframework.boot.SpringApplication;
4
import org.springframework.boot.autoconfigure.SpringBootApplication;
5

6
@SpringBootApplication
7
public class OrderApplication {
8
    public static void main(String[] args) {
9
        SpringApplication.run(OrderApplication.class, args);
10
    }
11
}
12

5) 配置RestTemplate

16
1
package com.huangyuanxin.springcloud.order.config;
2

3
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
4
import org.springframework.context.annotation.Bean;
5
import org.springframework.context.annotation.Configuration;
6
import org.springframework.web.client.RestTemplate;
7

8
@Configuration
9
public class ApplicationContextConfig {
10
    @Bean
11
    @LoadBalanced
12
    public RestTemplate restTemplate() {
13
        return new RestTemplate();
14
    }
15
}
16

6) Controller层调支付

31
1
package com.huangyuanxin.springcloud.order.controller;
2

3
import com.huangyuanxin.springcloud.common.model.CommonResult;
4
import com.huangyuanxin.springcloud.common.model.Payment;
5
import org.springframework.beans.factory.annotation.Autowired;
6
import org.springframework.beans.factory.annotation.Value;
7
import org.springframework.web.bind.annotation.GetMapping;
8
import org.springframework.web.bind.annotation.PathVariable;
9
import org.springframework.web.bind.annotation.RestController;
10
import org.springframework.web.client.RestTemplate;
11

12
@RestController
13
public class OrderController {
14
    @Value("${order.PaymentSrv_URL}")
15
    private String PaymentSrv_URL;
16

17
    @Autowired
18
    private RestTemplate restTemplate;
19

20
    @GetMapping("/consumer/payment/create") //客户端用浏览器是get请求，但是底层实质发送post调用服务端8001
21
    public CommonResult create(Payment payment) {
22
        return restTemplate.postForObject(PaymentSrv_URL + "/payment/create", payment, CommonResult.class);
23
    }
24

25

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

7) 测试订单调支付

启动支付和订单微服务，访问http://127.0.0.1:8200进行测试！

4. 补充说明

1) 开启Run DashBoard

默认情况下，IDEA会在你启动多个微服务时自动打开Run DashBoard面板，也可以修改.idea/workspace.xml手动打开。

7
1
<component name="RunDashboard">
2
    <option name="configurationTypes">
3
      <set>
4
        <option value="SpringBootApplicationConfigurationType" />
5
      </set>
6
    </option>
7
</component>

2) 开启热部署

• 修改pom.xml文件，添加依赖和插件

23
1
<!--SpringBoot开发工具-->
2
<dependency>
3
    <groupId>org.springframework.boot</groupId>
4
    <artifactId>spring-boot-devtools</artifactId>
5
    <scope>runtime</scope>
6
    <optional>true</optional>
7
</dependency>
8

9
<!--Maven编译插件-->
10
<build>
11
    <finalName>工程名字</finalName>
12
    <plugins>
13
        <plugin>
14
            <groupId>org.springframework.boot</groupId>
15
            <artifactId>spring-boot-maven-plugin</artifactId>
16
            <configuration>
17
                <fork>true</fork>
18
                <addResources>true</addResources>
19
            </configuration>
20
        </plugin>
21
    </plugins>
22
</build>
23

• 修改工程配置

• 修改IDEA配置

3) mysql驱动说明

• com.mysql.jdbc.Driver：在mysql-connector-java 5及以前版本驱动使用，也可以使用org.gjt.mm.mysql.Driver替代。

• com.mysql.cj.jdbc.Driver：在mysql-connector-java 6及以后版本驱动使用，相比上述驱动多了一个时区连接属性：serverTimezone=Asia/Shanghai。

第02章_服务注册发现

服务治理指的对服务生命周期中一系列操作进行统筹管理，包括服务注册、服务发现、服务监测、服务下线及`服务之间的调用与负载均衡等，是一种分布式架构的解决方案。

第一节 Eureka

1. Eureka简介

Eureka是SpringCloud封装的一款服务治理组件，其采用了CS的设计架构，分为服务端(Eureka Server)和客户端(Eureka Client)，系统架构图如下：

图中Eureka Server是服务治理中心，集中管理所有的微服务。服务提供者使用Eureka Client向Eureka Server注册服务并维持心跳，而服务消费者使用Eureka Client向Eureka Server拉取服务地址，随后进行远程调用。

2. 搭建Eureka Server

1) 新建SpringCloud-eureka-server模块

2) 引入Eureka-Server启动器及其它依赖

51
1
<?xml version="1.0" encoding="UTF-8"?>
2
<project xmlns="http://maven.apache.org/POM/4.0.0"
3
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5
    <parent>
6
        <artifactId>SpringCloud-demo</artifactId>
7
        <groupId>com.huangyuanxin.SpringCloud</groupId>
8
        <version>1.0-SNAPSHOT</version>
9
    </parent>
10
    <modelVersion>4.0.0</modelVersion>
11

12
    <artifactId>SpringCloud-eureka-server</artifactId>
13

14
    <dependencies>
15
        <!-- eureka-server -->
16
        <dependency>
17
            <groupId>org.springframework.cloud</groupId>
18
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
19
        </dependency>
20
        <!--boot web actuator-->
21
        <dependency>
22
            <groupId>org.springframework.boot</groupId>
23
            <artifactId>spring-boot-starter-web</artifactId>
24
        </dependency>
25
        <dependency>
26
            <groupId>org.springframework.boot</groupId>
27
            <artifactId>spring-boot-starter-actuator</artifactId>
28
        </dependency>
29
        <!--一般通用配置-->
30
        <dependency>
31
            <groupId>org.springframework.boot</groupId>
32
            <artifactId>spring-boot-devtools</artifactId>
33
            <scope>runtime</scope>
34
            <optional>true</optional>
35
        </dependency>
36
        <dependency>
37
            <groupId>org.projectlombok</groupId>
38
            <artifactId>lombok</artifactId>
39
        </dependency>
40
        <dependency>
41
            <groupId>org.springframework.boot</groupId>
42
            <artifactId>spring-boot-starter-test</artifactId>
43
            <scope>test</scope>
44
        </dependency>
45
        <dependency>
46
            <groupId>junit</groupId>
47
            <artifactId>junit</artifactId>
48
        </dependency>
49
    </dependencies>
50

51
</project>

注意：老版本Eureka服务端和客户端使用同一个启动器，如下。

4
1
<dependency>
2
     <groupId>org.springframework.cloud</groupId>
3
     <artifactId>spring-cloud-starter-eureka</artifactId>
4
</dependency>

3) 配置application.yml

15
1
server:
2
  port: 1000
3

4
eureka:
5
  instance:
6
    hostname: eureka-server #eureka服务端的实例名称
7
  client:
8
    #false表示不向注册中心注册自己。
9
    register-with-eureka: false
10
    #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
11
    fetch-registry: false
12
    service-url:
13
      #设置与Eureka Server交互的地址查询服务和注册服务都需要依赖这个地址。
14
      defaultZone: http://127.0.0.1:1000/eureka/
15
      

4) 编写启动程序EurekaServer.java

14
1
package com.huangyuanxin.springcloud.eureka;
2

3
import org.springframework.boot.SpringApplication;
4
import org.springframework.boot.autoconfigure.SpringBootApplication;
5
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
6

7
@SpringBootApplication
8
@EnableEurekaServer
9
public class EurekaServer {
10
    public static void main(String[] args) {
11
        SpringApplication.run(EurekaServer.class, args);
12
    }
13
}
14

5) 访问http://localhost:1000进行测试

3. 使用Eureka Client注册微服务

1) 改造支付服务，添加Eureka Client启动器

6
1
<!--eureka-client-->
2
<dependency>
3
    <groupId>org.springframework.cloud</groupId>
4
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
5
</dependency>
6
        

注意：老版本Eureka服务端和客户端使用同一个启动器，如下。

4
1
<dependency>
2
<groupId>org.springframework.cloud</groupId>
3
<artifactId>spring-cloud-starter-eureka</artifactId>
4
</dependency>