MP+Docker+SpringCloud+MQ+ES——5 微服务拆分-CSDN博客

本文链接：https://blog.csdn.net/kongbaidemumu/article/details/147730363

5 微服务拆分

5.1 熟悉商城项目

熟悉商城项目的基本结构：
- hm-common：通用工具模块；
- hm-service：业务模块；
需要修改数据库连接参数，在application-local.yaml中：

5.1.1 登录

登录业务流程：
登录入口在hm-service模块下的src/main/java/com/hmall/controller/UserController.java中的login方法：

5.1.2 搜索商品

在首页搜索框输入关键字，点击搜索即可进入搜索列表页面：
该页面会调用接口：/search/list，对应的服务端入口在hm-service模块下的com/hmall/controller/SearchController.java中的search方法：
这里目前是利用数据库实现了简单的分页查询。

5.1.3 购物车

在搜索到的商品列表中，点击按钮加入购物车，即可将商品加入购物车：
加入成功后会跳转到购物车列表页，可以查看自己购物车商品列表：
同时这里还可以对购物车实现修改、删除等操作；
相关功能全部在hm-service模块下的com/hmall/controller/CartController.java中：
其中，查询购物车列表时，由于要判断商品最新的价格和状态，所以还需要查询商品信息，业务流程如下：

5.1.4 下单

在购物车页面点击结算按钮，会进入订单结算页面：
点击提交订单，会提交请求到服务端，服务端做了 3 件事情：
- 创建一个新的订单
- 扣减商品库存
- 清理购物车中商品
业务入口在hm-service模块下的com/hmall/controller/OrderController.java中的createOrder方法：

5.1.5 支付

下单完成后会跳转到支付页面，目前只支持余额支付：
在选择余额支付这种方式后，会发起请求到服务端，服务端会立刻创建一个支付流水单，并返回支付流水单号到前端；
当用户输入用户密码，然后点击确认支付时，页面会发送请求到服务端，而服务端会做几件事情：
- 校验用户密码
- 扣减余额
- 修改支付流水状态
- 修改交易订单状态
请求入口在hm-service模块下的com/hmall/controller/PayController.java中：

5.2 服务拆分原则

5.2.1 什么时候拆

一般情况下，对于一个初创的项目，首先要做的是验证项目的可行性。因此这一阶段的首要任务是敏捷开发，快速产出生产可用的产品，投入市场做验证。为了达成这一目的，该阶段项目架构往往会比较简单，很多情况下会直接采用单体架构，这样开发成本比较低，可以快速产出结果，一旦发现项目不符合市场，损失较小；
如果这一阶段采用复杂的微服务架构，投入大量的人力和时间成本用于架构设计，最终发现产品不符合市场需求，等于全部做了无用功；
所以，对于大多数小型项目来说，一般是先采用单体架构，随着用户规模扩大、业务复杂后再逐渐拆分为微服务架构。这样初期成本会比较低，可以快速试错。但是，这么做的问题就在于后期做服务拆分时，可能会遇到很多代码耦合带来的问题，拆分比较困难（前易后难）；
而对于一些大型项目，在立项之初目的就很明确，为了长远考虑，在架构设计时就直接选择微服务架构。虽然前期投入较多，但后期就少了拆分服务的烦恼（前难后易）。

5.2.2 怎么拆

微服务拆分时粒度要小，这其实是拆分的目标。具体可以从两个角度来分析：
- 高内聚：每个微服务的职责要尽量单一（单一职责），包含的业务相互关联度高、完整度高；
  - 但不能说一个微服务就只有一个接口，而是要保证微服务内部业务的完整性为前提；
  - 目标是在未来维护系统的过程中，当我们要修改某个业务时，最好就只修改当前微服务，这样变更的成本更低；
  - 一旦微服务做到了高内聚，那么服务之间的耦合度自然就降低了；
- 低耦合：每个微服务的功能要相对独立，尽量减少对其它微服务的依赖，或者依赖接口的稳定性要强；
  - 当然，微服务之间不可避免的会有或多或少的业务交互；
  - 比如下单时需要查询商品数据。这个时候我们不能在订单服务直接查询商品数据库，否则就导致了数据耦合；
  - 而应该由商品服务对应暴露接口，并且一定要保证微服务对外接口的稳定性（即：尽量保证接口外观不变），由订单服务去调用商品服务暴露的接口；
  - 虽然出现了服务间调用，但此时无论你如何在商品服务做内部修改，都不会影响到订单微服务，服务间的耦合度就降低了；
明确了拆分目标，接下来就是拆分方式了。在做服务拆分时一般有两种方式：
- 纵向拆分：按照项目的功能模块来拆分；
  - 商城项目中，就有用户管理功能、订单管理功能、购物车功能、商品管理功能、支付功能等；
  - 那么按照功能模块将他们拆分为一个个服务，就属于纵向拆分；
  - 这种拆分模式可以尽可能提高服务的内聚性；
- 横向拆分：看各个功能模块之间有没有公共的业务部分，如果有将其抽取出来作为通用服务；
  - 例如用户登录是需要发送消息通知，记录风控数据、下单时也要发送短信，记录风控数据；
  - 因此消息发送、风控数据记录就是通用的业务功能，因此可以将他们分别抽取为公共服务：消息中心服务、风控管理服务；
  - 这样可以提高业务的复用性，避免重复开发；
  - 同时通用业务一般接口稳定性较强，也不会使服务之间过分耦合；
当然，由于商城项目并不是一个完整的项目，其中的短信发送、风控管理并没有实现，这里就不再考虑了。而其它的业务按照纵向拆分，可以分为以下几个微服务：
- 用户服务
- 商品服务
- 订单服务
- 购物车服务
- 支付服务

5.3 拆分购物车、商品服务

接下来，先把商品管理功能、购物车功能抽取为两个独立服务；
- 将hm-service中与商品管理相关功能拆分到一个微服务module中，命名为item-service；
- 将hm-service中与购物车有关的功能拆分到一个微服务module中，命名为cart-service；
一般微服务项目有两种不同的工程结构：
- 完全解耦：每一个微服务都创建为一个独立的工程，甚至可以使用不同的开发语言来开发，项目完全解耦
  - 优点：服务之间耦合度低
  - 缺点：每个项目都有自己的独立仓库，管理起来比较麻烦
- Maven聚合：整个项目为一个Project，然后每个微服务是其中的一个Module（此处采用这种方式）
  - 优点：项目代码集中，管理和运维方便
  - 缺点：服务之间耦合，编译时间较长
在hmall父工程之中，已经提前定义了SpringBoot、SpringCloud的依赖版本，所以为了方便起见，直接在这个项目中创建微服务module。

5.3.1 商品服务

在hmall中创建module：
配置模块：

引入依赖：

<?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>hmall</artifactId>
        <groupId>com.heima</groupId>
        <version>1.0.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>item-service</artifactId>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>
    <dependencies>
        <!--common-->
        <dependency>
            <groupId>com.heima</groupId>
            <artifactId>hm-common</artifactId>
            <version>1.0.0</version>
        </dependency>
        <!--web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--数据库-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
        </dependency>
    </dependencies>
    <build>
        <finalName>${project.artifactId}</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

新建一些必要的包，并编写启动类：

下面包名有误，将hamll改成hmall；

在这里插入图片描述

package com.hamll.item;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

注意：为了保证服务之间的数据隔离，需要新建一个hm-item数据库（一般来说是一个新的MySQL实例，但是此处为了方便，就在同一个架构下创建多个数据库）；

从hm-service中拷贝下面三个文件过来：

在这里插入图片描述

其中，application.yaml内容如下：

server:
  port: 8081
spring:
  application:
    name: item-service
  profiles:
    active: dev
  datasource:
    url: jdbc:mysql://${hm.db.host}:3306/hm-item?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: ${hm.db.pw}
mybatis-plus:
  configuration:
    default-enum-type-handler: com.baomidou.mybatisplus.core.handlers.MybatisEnumTypeHandler
  global-config:
    db-config:
      update-strategy: not_null
      id-type: auto
logging:
  level:
    com.hmall: debug
  pattern:
    dateformat: HH:mm:ss:SSS
  file:
    path: "logs/${spring.application.name}"
knife4j:
  enable: true
  openapi:
    title: 商城商品管理接口文档
    description: "商城项目接口文档"
    email: zhanghuyi@itcast.cn
    concat: 失散
    url: https://www.itcast.cn
    version: v1.0.0
    group:
      default:
        group-name: default
        api-rule: package
        api-rule-resources:
          - com.hmall.item.controller

拷贝hm-service中与商品管理有关的代码到item-service，如图：
- 下面包名有误，将hamll改成hmall；
- 这里有一个地方的代码需要改动，就是ItemServiceImpl中的deductStock方法：
```
String sqlStatement = "com.hmall.item.mapper.ItemMapper.updateStock";
```
接下来，就可以启动测试了，在启动前要配置一下启动项，让默认激活的配置为local而不是dev：
接着，启动item-service，访问商品微服务的swagger接口文档：http://localhost:8081/doc.html。然后测试其中的根据id批量查询商品这个接口：
微服务抽取成功。

5.3.2 购物车服务

在hmall下创建一个新的module，起名为cart-service：

引入依赖：

<?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>hmall</artifactId>
        <groupId>com.heima</groupId>
        <version>1.0.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cart-service</artifactId>

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

    <dependencies>
        <!--common-->
        <dependency>
            <groupId>com.heima</groupId>
            <artifactId>hm-common</artifactId>
            <version>1.0.0</version>
        </dependency>
        <!--web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--数据库-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
        </dependency>
    </dependencies>
    <build>
        <finalName>${project.artifactId}</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

同样新建数据库：

把hm-service中的与购物车有关功能拷贝过来，最终的项目结构如下：

在这里插入图片描述

修改application.yml文件：应用名称、服务端口、数据库名、Swagger文档映射路径

server:
  port: 8082
spring:
  application:
    name: cart-service
  profiles:
    active: dev
  datasource:
    url: jdbc:mysql://${hm.db.host}:3306/hm-cart?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: ${hm.db.pw}
mybatis-plus:
  configuration:
    default-enum-type-handler: com.baomidou.mybatisplus.core.handlers.MybatisEnumTypeHandler
  global-config:
    db-config:
      update-strategy: not_null
      id-type: auto
logging:
  level:
    com.hmall: debug
  pattern:
    dateformat: HH:mm:ss:SSS
  file:
    path: "logs/${spring.application.name}"
knife4j:
  enable: true
  openapi:
    title: 商城购物车接口文档
    description: "商城项目接口文档"
    email: zhanghuyi@itcast.cn
    concat: 失散
    url: https://www.itcast.cn
    version: v1.0.0
    group:
      default:
        group-name: default
        api-rule: package
        api-rule-resources:
          - com.hmall.cart.controller

特别注意的是com.hmall.cart.service.impl.CartServiceImpl，其中有两个地方需要处理：

需要获取登录用户信息，但登录校验功能目前没有复制过来，先写死固定用户id；
查询购物车时需要查询商品信息，而商品信息不在当前服务，需要先将这部分代码注释；

修改后的最终代码如下：

package com.hmall.cart.service.impl;

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmall.cart.domain.dto.CartFormDTO;
import com.hmall.cart.domain.dto.ItemDTO;
import com.hmall.cart.domain.po.Cart;
import com.hmall.cart.domain.vo.CartVO;
import com.hmall.cart.mapper.CartMapper;
import com.hmall.cart.service.ICartService;
import com.hmall.common.exception.BizIllegalException;
import com.hmall.common.utils.BeanUtils;
import com.hmall.common.utils.CollUtils;
import com.hmall.common.utils.UserContext;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 订单详情表 服务实现类
 */
@Service
@RequiredArgsConstructor
public class CartServiceImpl extends ServiceImpl<CartMapper, Cart> implements ICartService {

    @Override
    public void addItem2Cart(CartFormDTO cartFormDTO) {
        // 1.获取登录用户
        Long userId = UserContext.getUser();

        // 2.判断是否已经存在
        if(checkItemExists(cartFormDTO.getItemId(), userId)){
            // 2.1.存在，则更新数量
            baseMapper.updateNum(cartFormDTO.getItemId(), userId);
            return;
        }
        // 2.2.不存在，判断是否超过购物车数量
        checkCartsFull(userId);

        // 3.新增购物车条目
        // 3.1.转换PO
        Cart cart = BeanUtils.copyBean(cartFormDTO, Cart.class);
        // 3.2.保存当前用户
        cart.setUserId(userId);
        // 3.3.保存到数据库
        save(cart);
    }

    @Override
    public List<CartVO> queryMyCarts() {
        // 1.查询我的购物车列表
        List<Cart> carts = lambdaQuery().eq(Cart::getUserId, 1L /* TODO UserContext.getUser() */).list();
        if (CollUtils.isEmpty(carts)) {
            return CollUtils.emptyList();
        }

        // 2.转换VO
        List<CartVO> vos = BeanUtils.copyList(carts, CartVO.class);

        // 3.处理VO中的商品信息
        handleCartItems(vos);

        // 4.返回
        return vos;
    }

    private void handleCartItems(List<CartVO> vos) {
        // TODO
//        // 1.获取商品id
//        Set<Long> itemIds = vos.stream().map(CartVO::getItemId).collect(Collectors.toSet());
//        // 2.查询商品
//        List<ItemDTO> items = itemService.queryItemByIds(itemIds);
//        if (CollUtils.isEmpty(items)) {
//            return;
//        }
//        // 3.转为 id 到 item的map
//        Map<Long, ItemDTO> itemMap = items.stream().collect(Collectors.toMap(ItemDTO::getId, Function.identity()));
//        // 4.写入vo
//        for (CartVO v : vos) {
//            ItemDTO item = itemMap.get(v.getItemId());
//            if (item == null) {
//                continue;
//            }
//            v.setNewPrice(item.getPrice());
//            v.setStatus(item.getStatus());
//            v.setStock(item.getStock());
//        }
    }

    @Override
    public void removeByItemIds(Collection<Long> itemIds) {
        // 1.构建删除条件，userId和itemId
        QueryWrapper<Cart> queryWrapper = new QueryWrapper<Cart>();
        queryWrapper.lambda()
                .eq(Cart::getUserId, UserContext.getUser())
                .in(Cart::getItemId, itemIds);
        // 2.删除
        remove(queryWrapper);
    }

    private void checkCartsFull(Long userId) {
        int count = lambdaQuery().eq(Cart::getUserId, userId).count();
        if (count >= 10) {
            throw new BizIllegalException(StrUtil.format("用户购物车课程不能超过{}", 10));
        }
    }

    private boolean checkItemExists(Long itemId, Long userId) {
        int count = lambdaQuery()
                .eq(Cart::getUserId, userId)
                .eq(Cart::getItemId, itemId)
                .count();
        return count > 0;
    }
}

接下来，就可以测试了。不过在启动前，同样要配置启动项的active profile为local：
然后启动CartApplication，访问swagger文档页面：http://localhost:8082/doc.html。测试其中的查询我的购物车列表接口，无需填写参数，直接访问：
可以注意到，其中与商品有关的几个字段值都为空！这就是因为刚才注释掉了查询购物车时，查询商品信息的相关代码。那么，该如何在cart-service服务中实现对item-service服务的查询呢？

5.4 服务调用

5.4.1 问题引出

在拆分的时候，发现一个问题：购物车业务中需要查询商品信息，但商品信息查询的逻辑全部迁移到了item-service服务，导致无法查询；
最终结果就是查询到的购物车数据不完整，因此要想解决这个问题，就必须改造其中的代码，把原本的本地方法调用，改造成跨微服务的远程调用（RPC，即Remote Produce Call）；
因此，现在查询购物车列表的流程变成了这样：
代码中需要变化的就是这一步：将这里本地方法的调用改造为远程服务调用
那么问题来了：该如何跨服务调用，准确的说，如何在cart-service中获取item-service服务中的提供的商品数据呢？
- 前端向服务端查询数据，其实就是从浏览器远程查询服务端数据。比如刚才通过 Swagger 测试商品查询接口，就是向http://localhost:8081/items这个接口发起的请求。而这种查询就是通过http请求的方式来完成的，不仅仅可以实现远程查询，还可以实现新增、删除等各种远程请求；
- 假如在cart-service中能模拟浏览器，发送http请求到item-service，是不是就实现了跨微服务的远程调用了呢？
- 那么：我们该如何用 Java 代码发送 Http 的请求呢？

5.4.2 RestTemplate

Spring提供了一个RestTemplate的API，可以方便的实现Http请求的发送，其中提供了大量的方法，方便我们发送Http请求，例如：
- 可以看到常见的Get、Post、Put、Delete请求都支持，如果请求参数比较复杂，还可以使用exchange方法来构造请求；

将RestTemplate注册为一个Bean：

在这里插入图片描述

package com.hmall.cart;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

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

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

5.4.3 远程调用

修改cart-service中的com.hmall.cart.service.impl.CartServiceImpl的handleCartItems方法，发送http请求到item-service：

private void handleCartItems(List<CartVO> vos) {
    // 1.获取商品id
    Set<Long> itemIds = vos.stream().map(CartVO::getItemId).collect(Collectors.toSet());
    // 2.查询商品
    // 2.1.利用 RestTemplate 发送请求，查询商品，得到http响应
    ResponseEntity<List<ItemDTO>> response = restTemplate.exchange(
            "http://localhost:8081/items?ids={ids}", // 请求路径
            HttpMethod.GET, // 请求方式
            null, // 请求实体
            new ParameterizedTypeReference<List<ItemDTO>>() {}, // 返回值类型
            Map.of("ids", CollUtils.join(itemIds, ",")) //请求参数
    );
    // 2.2.解析响应
    if (!response.getStatusCode().is2xxSuccessful()) {
        // 查询失败。直接结束
        return;
    }
    List<ItemDTO> items = response.getBody();
    if (CollUtils.isEmpty(items)) {
        // 查询成功，获取相应结果
        return;
    }
    // 3. 转为 id 到 item 的map
    Map<Long, ItemDTO> itemMap = items.stream().collect(Collectors.toMap(ItemDTO::getId, Function.identity()));
    // 4.写入vo
    for (CartVO v : vos) {
        ItemDTO item = itemMap.get(v.getItemId());
        if (item == null) {
            continue;
        }
        v.setNewPrice(item.getPrice());
        v.setStatus(item.getStatus());
        v.setStock(item.getStock());
    }
}

启动cart-service和item-service，再次测试查询我的购物车列表接口：
可以发现，所有商品相关数据都已经查询到了；
- 在这个过程中，item-service提供了查询接口，cart-service利用Http请求调用该接口；
- 因此item-service可以称为服务的提供者，而cart-service则称为服务的消费者或服务调用者。

5.5 总结

什么时候需要拆分微服务？
- 如果是创业型公司，最好先用单体架构快速迭代开发，验证市场运作模型，快速试错。当业务跑通以后，随着业务规模扩大、人员规模增加，再考虑拆分微服务；
- 如果是大型企业，有充足的资源，可以在项目开始之初就搭建微服务架构；
如何拆分？
- 首先要做到高内聚、低耦合；
- 从拆分方式来说，有横向拆分和纵向拆分两种。纵向就是按照业务功能模块，横向则是拆分通用性业务，提高复用性；
服务拆分之后，不可避免的会出现跨微服务的业务，此时微服务之间就需要进行远程调用。微服务之间的远程调用被称为RPC，即远程过程调用。RPC的实现方式有很多，比如：
- 基于Http协议；这种方式不关心服务提供者的具体技术实现，只要对外暴露Http接口即可，更符合微服务的需要。
- 基于Dubbo协议；
Java发送http请求可以使用Spring提供的RestTemplate，使用的基本步骤如下：
- 注册RestTemplate到Spring容器
- 调用RestTemplate的API发送请求，常见方法有：
  - getForObject：发送Get请求并返回指定类型对象
  - PostForObject：发送Post请求并返回指定类型对象
  - put：发送PUT请求
  - delete：发送Delete请求
  - exchange：发送任意类型请求，返回ResponseEntity