SpringCloud学习笔记(一)微服务介绍、服务拆分和RestTemplate远程调用、Eureka注册中心

1 认识微服务

1.1 单体架构

单体架构即将业务的所有功能集中在一个项目中开发，打成一个包进行部署。

单体架构的优缺点如下：

优点：

• 架构简单
• 部署成本低

缺点：

• 耦合度高（维护困难、升级困难）

1.2 分布式架构

分布式架构即根据业务功能对系统做拆分，每个业务功能模块作为独立项目开发，称为一个服务。

分布式架构的优缺点：

优点：

• 降低服务耦合
• 有利于服务升级和拓展

缺点：

• 服务调用关系错综复杂
• 要考虑的问题多：服务拆分的粒度如何界定？服务之间如何调用？服务的调用关系如何管理？

为此，我们需要制定一套行之有效的标准来规范分布式框架。

1.3 微服务

微服务的架构特征：

• 单一职责：微服务拆分粒度更小，每一个服务都对应唯一的业务能力，做到单一职责
• 自治：团队独立、技术独立、数据独立，独立部署和交付
• 面向服务：服务提供统一标准的接口，与语言和技术无关
• 隔离性强：服务调用做好隔离、容错、降级，避免出现级联问题

微服务的上述特性其实是在给分布式架构制定一个标准，进一步降低服务之间的耦合度，提供服务的独立性和灵活性，做到高内聚、低耦合。

因此，可以认为微服务是一种经过良好架构设计的分布式架构方案 。

但方案该怎么落地？选用什么样的技术栈？全球的互联网公司都在积极尝试自己的微服务落地方案。

其中在Java领域最引人注目的就是SpringCloud提供的方案了。

1.4 SpringCloud

SpringCloud是目前国内使用最广泛的微服务框架，其官网地址：https://spring.io/projects/spring-cloud。

SpringCloud集成了各种微服务功能组件，并基于SpringBoot实现了这些组件的自动装配，从而提供了良好的开箱即用体验。

其中常见的组件包括：

另外，SpringCloud底层是依赖于SpringBoot的，并且有版本的兼容关系，如下：

该学习笔记使用的版本是 Hoxton.SR10，对应的SpringBoot版本是2.3.x版本。

1.5 总结

• 单体架构：简单方便，高度耦合，扩展性差，适合小型项目。例如：学生管理系统

• 分布式架构：松耦合，扩展性好，但架构复杂，难度大。适合大型互联网项目，例如：京东、淘宝

• 微服务：一种良好的分布式架构方案

  • 优点：拆分粒度更小、服务更独立、耦合度更低
  • 缺点：架构非常复杂，运维、监控、部署难度提高
  • SpringCloud是微服务架构的一站式解决方案，集成了各种优秀微服务功能组件

2 服务拆分与远程调用

2.1 服务拆分原则

微服务进行服务时应遵循以下几个原则：

• 不同微服务，不要重复开发相同业务
• 微服务数据独立，不要访问其它微服务的数据库
• 微服务可以将自己的业务暴露为接口，供其它微服务调用

2.2 服务拆分示例

2.2.1 搭建项目

下面创建一个示例项目，项目结构如下：

• sc-demo：父工程，管理依赖
• order-service：订单微服务，负责订单相关业务（8080端口）
• user-service：用户微服务，负责用户相关业务（8081端口）

项目代码下载：https://gitee.com/weidag/springcloud_learning.git

要求：

• 订单微服务和用户微服务都必须有各自的数据库，相互独立
• 订单服务和用户服务都对外暴露Restful的接口
• 订单服务如果需要查询用户信息，只能调用用户服务的Restful接口，不能查询用户数据库

2.2.2 创建数据库和表

• 创建用户微服务的数据库和表：

CREATE DATABASE sc_user_db;
USE sc_user_db;

CREATE TABLE `tb_user` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `username` varchar(100) CHARACTER SET utf8mb3 COLLATE utf8mb3_general_ci DEFAULT NULL COMMENT '收件人',
  `address` varchar(255) CHARACTER SET utf8mb3 COLLATE utf8mb3_general_ci DEFAULT NULL COMMENT '地址',
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE KEY `username` (`username`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=109 DEFAULT CHARSET=utf8mb3 ROW_FORMAT=COMPACT;

INSERT INTO `tb_user` VALUES (1, '孙悟空', '湖南省衡阳市');
INSERT INTO `tb_user` VALUES (2, '猪八戒', '陕西省西安市');
INSERT INTO `tb_user` VALUES (3, '沙悟净', '湖北省十堰市');
INSERT INTO `tb_user` VALUES (4, '唐三藏', '天津市');
INSERT INTO `tb_user` VALUES (5, '白龙马', '辽宁省沈阳市大东区');
INSERT INTO `tb_user` VALUES (6, '唐太宗', '山东省青岛市');
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• 创建订单微服务的数据库和表：

CREATE DATABASE sc_order_db;
USE sc_order_db;

CREATE TABLE `tb_order` (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '订单id',
  `user_id` bigint NOT NULL COMMENT '用户id',
  `name` varchar(100) CHARACTER SET utf8mb3 COLLATE utf8mb3_general_ci DEFAULT NULL COMMENT '商品名称',
  `price` bigint NOT NULL COMMENT '商品价格',
  `num` int DEFAULT '0' COMMENT '商品数量',
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE KEY `username` (`name`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=109 DEFAULT CHARSET=utf8mb3 ROW_FORMAT=COMPACT;

INSERT INTO `tb_order` VALUES (101, 1, 'Apple 苹果 iPhone 12 ', 699900, 1);
INSERT INTO `tb_order` VALUES (102, 2, '雅迪 yadea 新国标电动车', 209900, 1);
INSERT INTO `tb_order` VALUES (103, 3, '骆驼（CAMEL）休闲运动鞋女', 43900, 1);
INSERT INTO `tb_order` VALUES (104, 4, '小米10 双模5G 骁龙865', 359900, 1);
INSERT INTO `tb_order` VALUES (105, 5, 'OPPO Reno3 Pro 双模5G 视频双防抖', 299900, 1);
INSERT INTO `tb_order` VALUES (106, 6, '美的（Midea) 新能效 冷静星II ', 544900, 1);
INSERT INTO `tb_order` VALUES (107, 2, '西昊/SIHOO 人体工学电脑椅子', 79900, 1);
INSERT INTO `tb_order` VALUES (108, 3, '梵班（FAMDBANN）休闲男鞋', 31900, 1);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

订单表tb_order持有用户表tb_user的user_id字段。

2.2.3 实现远程调用

在user-service中，实现了一个根据id查询用户信息的接口：

启动user-service服务，调用该接口可以查询出对应的用户信息：

同样，在order-service中，实现了一个根据id查询订单信息的接口：

启动order-service服务，调用该接口可以查询出对应的订单信息：

可以发现，返回的订单信息中user字段为空。

2.2.3.1 需求描述

现有如下需求：在order-service服务中，根据id查询订单信息的同时，根据订单中包含的userId字段查询出用户信息，一起返回。

为此，我们需要在order-service服务中 向user-service服务发起一个http的请求，调用http://localhost:8090/user/{userId}这个接口根据id查询用户信息。

而要实现服务之间的调用，可以通过RestTemplate工具来实现。RestTemplate是从Spring3.0开始支持的一个HTTP请求工具，它提供了常见的REST请求方案的模版，例如GET请求、POST请求、PUT请求、DELETE请求等。

2.2.3.2 注册RestTemplate

在order-service服务的OrderApplication启动类中，注册RestTemplate：

// com.star.order.OrderApplication

@MapperScan("com.star.order.mapper")
@SpringBootApplication
public class OrderApplication {

    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }

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

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

2.2.3.3 实现远程调用

修改OrderService类的queryOrderById()方法，使用RestTemplate实现远程调用：

// com.star.order.service.OrderService

@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private RestTemplate restTemplate;

    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);
        // 2.远程查询用户信息
        String url = "http://127.0.0.1:8090/user/" + order.getUserId();
        User user = restTemplate.getForObject(url, User.class);
        order.setUser(user);
        // 3.返回
        return order;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

再次调用/order/{orderId}接口，查询对应的订单信息：

可以发现，返回的订单信息中user字段也一并被查询了出来，RestTemplate实现远程调用成功。

2.2.4 提供者与消费者

在本次服务调用关系中，有两个不同的角色：

服务提供者：一次业务中，被其它微服务调用的服务，即user-service服务。（提供接口给其它微服务）
服务消费者：一次业务中，调用其它微服务的服务，即order-service服务。

但是，服务提供者与服务消费者的角色并不是绝对的，而是相对于业务而言，例如order-service服务既可以是服务消费者，也可以是服务提供者给user-service服务调用。

3 Eureka注册中心

假如user-service服务部署了多个实例，如图：

那么这就产生了几个问题：

• order-service服务在发起远程调用的时候，该如何得知user-service实例的ip地址和端口？
• 有多个user-service实例地址，order-service调用时该如何选择？
• order-service如何得知某个user-service实例是否依然健康，是不是已经宕机？

3.1 Eureka的结构和作用

这些问题都需要利用SpringCloud中的注册中心来解决，也就是Eureka，其结构如下：

问题1：order-service服务在发起远程调用的时候，该如何得知user-service实例的ip地址和端口？

• 1）user-service服务实例启动后，将自己的信息注册到eureka-server（Eureka服务端），即服务注册；
• 2）eureka-server保存服务名称到服务实例地址列表的映射关系；
• 3）order-service根据服务名称，拉取实例地址列表，即服务发现或服务拉取。

问题2：有多个user-service实例地址，order-service调用时该如何选择？

• 1）order-service从实例列表中利用负载均衡算法选中一个实例地址；
• 2）向该实例地址发起远程调用。

问题3：order-service如何得知某个user-service实例是否依然健康，是不是已经宕机？

• 1）user-service会每隔一段时间（默认30秒）向eureka-server发起请求，报告自己状态，称为心跳；
• 2）当超过一定时间没有发送心跳时，eureka-server会认为微服务实例故障，将该实例从服务列表中剔除；
• 3）order-service拉取服务时，就能将故障实例排除了。

3.2 搭建eureka-server服务

3.2.1 创建eureka-server模块

注册中心eureka-server服务，必须是一个独立的微服务，因此在父工程sc_demo下创建一个子模块：

3.2.2 引入eureka-server依赖

// sc_demo\eureka-server\pom.xml

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

3.2.3 编写启动类

和普通的SpringBoot启动类不同的是，该启动类需要添加@EnableEurekaServer注解，以开启eureka的注册中心功能：

// com.star.eureka.EurekaApplication

@SpringBootApplication
@EnableEurekaServer
public class EurekaApplication {

    public static void main(String[] args) {
        SpringApplication.run(EurekaApplication.class, args);
    }
}
1
2
3
4
5
6
7
8
9
10

3.2.4 编写配置文件

在sc_demo\eureka-server\src\main\resources目录下创建一个application.yml文件，内容如下：

server:
  port: 10086
spring:
  application:
    name: eureka-server
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka
1
2
3
4
5
6
7
8
9

3.2.5 启动服务

启动微服务，然后在浏览器访问：http://127.0.0.1:10086，出现以下界面就说明注册中心eureka-server服务创建成功了。

3.3 注册user-service服务

接下来将user-service服务注册到eureka-server服务中。

3.3.1 引入eureka-client依赖

在user-service服务中，引入eureka-client依赖：

// sc_demo\user-service\pom.xml

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

3.3.2 修改配置文件

在user-service服务中，修改application.yml文件，添加服务名称、eureka-server地址：

// sc_demo\user-service\src\main\resources\application.yml

spring:
  application:
    name: user-service
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka
1
2
3
4
5
6
7
8
9

3.3.3 启动服务

启动user-service服务，查看eureka-server管理页面，可以发现user-service服务已经注册到了eureka-server服务中：

3.3.4 启动多个user-service实例

在IDEA上再启动一个user-service实例，配置其端口为8082。启动后查看eureka-server管理页面，可以发现此时有2个user-service服务（端口分别是8081和8082）注册到了eureka-server服务中：

3.4 服务发现

接下来，修改order-service的逻辑：向eureka-server拉取user-service的信息，实现服务发现。

3.4.1 引入eureka-client依赖

在order-service服务中，引入eureka-client依赖：

// sc_demo\order-service\pom.xml

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

3.4.2 修改配置文件

在order-service服务中，修改application.yml文件，添加服务名称、eureka-server地址：

// sc_demo\order-service\src\main\resources\application.yml

spring:
  application:
    name: order-service
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka
1
2
3
4
5
6
7
8
9

3.4.3 服务拉取和负载均衡

在order-service的OrderApplication启动类中，给RestTemplate这个Bean添加一个@LoadBalanced注解，以启用负载均衡：

// com.star.order.OrderApplication

@Bean
@LoadBalanced
public RestTemplate restTemplate() {
    return new RestTemplate();
}
1
2
3
4
5
6
7

修改order-service的OrderService类中的queryOrderById()方法，修改访问的url路径，用服务名代替ip、端口：

// order-service#com.star.order.service.OrderService#queryOrderById()

// 2.远程查询用户信息
// String url = "http://127.0.0.1:8081/user/" + order.getUserId();
// 使用服务名代替ip和端口
String url = "http://user-service/user/" + order.getUserId();
1
2
3
4
5
6

这样配置之后，会根据user-service这个服务名称，从erueka-server中获取实例列表，而后完成负载均衡。

3.4.4 功能测试

重启order-service服务，会发现该服务也注册到了erueka-server中：

调用/order/102接口，查询用户信息的请求分发到了8081端口的user-service：

调用/order/101接口，查询用户信息的请求分发到了8082端口的user-service：

…

本节完，更多内容请查阅分类专栏：SpringCloud学习笔记

本文涉及代码下载地址：https://gitee.com/weidag/springcloud_learning.git

感兴趣的读者还可以查阅我的另外几个专栏：

• SpringBoot源码解读与原理分析(已完结)
• MyBatis3源码深度解析(已完结)
• Redis从入门到精通(已完结)
• MyBatisPlus详解(已完结)
• 再探Java为面试赋能(持续更新中…)