AI 助理
备案控制台
开发者社区 云原生 微服务 文章 正文

分布式微服务系统的跨库查询/操作的解决思路（关系型数据库）

2023-01-16 4415
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
服务治理 MSE Sentinel/OpenSergo，Agent数量 不受限
云原生网关 MSE Higress，422元/月
注册配置 MSE Nacos/ZooKeeper，118元/月
简介： 分布式微服务系统的跨库查询/操作的解决思路（关系型数据库）

在后端开发过程中，我们绕不开的就是数据结构设计以及关联的问题。

然而在传统的单体架构的开发中，解决数据关联的问题并不难，通过关系型数据库中的关联查询功能，以及MyBatis的级联功能即可实现。

但是在分布式微服务中，整个系统都被拆分成了一个个单独的模块，每个模块也都是使用的单独的数据库。这种情况下，又如何解决不同模块之间数据关联问题呢？

事实上，分布式微服务是非常复杂的，无论是系统架构，还是数据结构设计，都没有一个统一的方案，因此根据实际情况进行确定即可，对于数据关联的跨库查询，事实上也有很多方法，在网上有如下思路：

  • 数据冗余法
  • 远程连接表
  • 数据复制
  • 使用非关系型数据库
  • ...

今天，我就来分享一个简单的分布式微服务跨库查询操作，大家可以参考一下。

我们还是从一对多，多对多的角度来解决这个问题。

1，学习前需要了解

在继续往下看之前，我想先介绍一下这次的示例中所使用的组件：

  • Spring Cloud 2022.0.0和Spring Cloud Alibaba 2022.0.0.0-RC1
  • MyBatis-Plus作为ORM框架
  • Dynamic Datasource作为多数据源切换组件
  • Nacos作为注册中心
  • MySQL数据库
  • OpenFeign远程调用

因此，在往下看之前，需要先掌握上述这些组件的使用，本文不再赘述。

之前都是使用MyBatis作为ORM框架，而MyBatis-Plus可以视作其升级版，省去了我们写繁杂的Mapper.xml文件的步骤，上手特别简单。

将上述所有前置内容掌握之后，再来往下看最好。

2，跨库操作解决思路

我们从数据的联系形式，即一对多和多对多这两个角度依次进行分析。

(1) 一对多

一对多事实上比较好解决，这里我使用字段冗余 + 远程调用的方式解决。

这里以订单(Order)和用户(User)为例，订单对象中通常要包含用户关系，一个用户会产生多个订单，因此用户和订单构成了一对多的关系。

在单体架构中，我们很容易想到设计成这样：

image.png

这样，在查询订单的时候，可以通过关联查询的方式得到用户字段信息。

但是在分布式微服务中，用户和订单模块被拆分开来，两者的数据库也分开了，无法使用关联查询了，怎么办呢？

这时，我们可以在订单类中，冗余一个userId字段，可以直接从数据库取出，再通过远程调用的方式调用用户模块，用这个userId去得到用户对象，最后组装即可。

image.png

这样，订单服务查询订单对象，可以分为如下几步：

  1. 先直接从数据库取出订单对象，这样上述Order类中的id、name和userId都可以直接从数据库取出
  2. 然后拿着这个userId的值去远程调用用户服务得到用户对象，填充到user字段

与此同时，我们还可以注意一下细节：

  • 将Order对象返回给前端时，可以过滤掉冗余字段userId，节省流量，通过Jackson注解可以实现
  • 前端若要将Order对象作为参数传递给后端，则无需带着user字段内容，这样前端传来后可以直接丢进数据库，并且更加简洁

(2) 多对多

我们知道，多对多通常是以搭桥表方式实现关联。

在此我们增加一个商品类(Product)，和订单类构成多对多关系，即需要查询一个订单中包含的所有商品，还需要查询这个商品被哪些订单包含。

在传统单体架构中，我们如下设计：

image.png

那么在分布式微服务中，数据库分开的情况下，这个搭桥表order_product放在哪呢？

可以将其单独放在一个数据库中，这个数据库在这里称之为搭桥表数据库。

image.png

这样，比如说订单服务查询订单的时候，可以分为如下几步：

  1. 先直接从订单数据库查询出订单信息，这样Order类中的id、name和userId就得到了
  2. 然后从搭桥表数据库去查询和这个订单关联的商品id，这样就得到了一个商品id列表
  3. 用这个商品id列表去远程调用商品服务，查询到每个id对应的商品对象得到一个商品对象列表
  4. 将商品列表组装到Order中的products字段中

那么反过来，商品服务也是通过一样的方式得到订单列表并组装。

可见，这两个多对多模块，有下列细节：

  • 需要用到两个数据库，因此需要配置多数据源
  • 两者需要暴露批量id查询的接口，但是批量id查询的时候，要注意死循环问题，这个我们在下面代码中具体来看

(3) 总结

可见上述解决数据关联的方式，都是要通过远程调用的方式来实现，这样符合微服务中职责单一原则，不过缺点是网络性能不是很好。

但是，这种方式解决规模不是特别复杂的项目已经足够了。

整体的类图和数据库如下：

image.png

image.png

那么下面，我们就来实现一下。

3，代码实现

(1) 环境配置

在写代码之前，我们先要在本地搭建并运行好MySQL和Nacos注册中心，这里我已经在本地通过Docker的方式部署好了，大家可以先自行部署。

image.png

然后在这里，整个工程模块组织如下：

image.png

  1. 存放全部实体类的模块，是普通Maven项目，被其它模块依赖
  2. 远程调用层，是普通Maven项目，其它服务模块依赖这个模块进行远程调用
  3. 订单服务模块，是Spring Boot项目
  4. 商品服务模块，是Spring Boot项目
  5. 用户服务模块，是Spring Boot项目
我们知道服务提供者和服务消费者在整个分布式微服务中是非常相对的概念，而服务消费者是需要进行远程调用的，这样每个服务消费者都要引入OpenFeign依赖并注入等等，因此我们可以 单独把所有的消费者的远程调用层feignclient抽离出来，作为这个远程调用模块。

在最后我会给出项目的仓库的地址，大家可以在示例仓库中自行查看每个模块的配置文件和依赖配置。

(2) 数据库的初始化

在MySQL中通过以下命令，创建如下数据库：

create database `db_order`;
create database `db_product`;
create database `db_user`;
create database `db_bridge`;

上述db_bridge就是专门存放搭桥表的数据库。

然后依次初始化三个数据库。

db_order数据库：

-- 订单数据库
drop table if exists `order_info`;

create table `order_info`
(
    `id`      int unsigned auto_increment,
    `name`    varchar(16)  not null,
    `user_id` int unsigned not null,
    primary key (`id`)
) engine = InnoDB
  default charset = utf8mb4;

-- 测试数据
insert into `order_info` (`name`, `user_id`)
values ('订单1', 1), -- id:1~4
       ('订单2', 1),
       ('订单3', 2),
       ('订单4', 3);

db_product数据库：

-- 商品数据库
drop table if exists `product`;

create table `product`
(
    `id`   int unsigned auto_increment,
    `name` varchar(32) not null,
    primary key (`id`)
) engine = InnoDB
  default charset = utf8mb4;

-- 初始化测试数据
insert into `product` (`name`)
values ('商品1'), -- id:1~3
       ('商品2'),
       ('商品3');

db_user数据库：

-- 用户数据库
drop table if exists `user`;

create table `user`
(
    `id`       int unsigned auto_increment,
    `username` varchar(16) not null,
    primary key (`id`)
) engine = InnoDB
  default charset = utf8mb4;

-- 初始化数据
insert into `user` (`username`)
values ('dev'), -- id:1~3
       ('test'),
       ('admin');

db_bridge数据库：

-- 多对多关联记录数据库
drop table if exists `order_product`;

-- 订单-商品多对多关联表
create table `order_product`
(
    `order_id`   int unsigned,
    `product_id` int unsigned,
    primary key (`order_id`, `product_id`)
) engine = InnoDB
  default charset = utf8mb4;

-- 初始化测试数据
insert into `order_product`
values (1, 1),
       (1, 2),
       (2, 1),
       (2, 2),
       (3, 2),
       (3, 3),
       (4, 1),
       (4, 2),
       (4, 3);

(3) 实体类的定义

所有的实体类存放在db-entity模块中。

首先我们还是定义一个结果类Result<T>专用于返回给前端：

package com.gitee.swsk33.dbentity.model;

import lombok.Data;

import java.io.Serializable;

/**
 * 返回给前端的结果对象
 */
@Data
public class Result<T> implements Serializable {

    /**
     * 是否操作成功
     */
    private boolean success;

    /**
     * 消息
     */
    private String message;

    /**
     * 数据
     */
    private T data;

    /**
     * 设定成功
     *
     * @param message 消息
     */
    public void setResultSuccess(String message) {
        this.success = true;
        this.message = message;
        this.data = null;
    }

    /**
     * 设定成功
     *
     * @param message 消息
     * @param data    数据
     */
    public void setResultSuccess(String message, T data) {
        this.success = true;
        this.message = message;
        this.data = data;
    }

    /**
     * 设定失败
     *
     * @param message 消息
     */
    public void setResultFailed(String message) {
        this.success = false;
        this.message = message;
        this.data = null;
    }

}

然后就是数据库对象了。

1. 用户类

package com.gitee.swsk33.dbentity.dataobject;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;

/**
 * 用户类
 */
@Data
public class User {

    /**
     * 用户id
     */
    @TableId(type = IdType.AUTO)
    private Integer id;

    /**
     * 用户名
     */
    private String username;

}

2. 商品类

package com.gitee.swsk33.dbentity.dataobject;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;

import java.util.List;

/**
 * 商品表
 */
@Data
public class Product {

    /**
     * 商品id
     */
    @TableId(type = IdType.AUTO)
    private Integer id;

    /**
     * 商品名
     */
    private String name;

    /**
     * 所有购买了这个商品的订单（需组装）
     */
    @TableField(exist = false)
    private List<Order> orders;

}

可见这里用了@TableField注解将orders字段标注为非数据库字段，因为这个字段是我们后续要手动组装的多对多字段。

3. 订单类

package com.gitee.swsk33.dbentity.dataobject;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.Data;

import java.util.List;

/**
 * 订单类
 */
@Data
@JsonIgnoreProperties(allowSetters = true, value = {"userId"})
@TableName("order_info")
public class Order {

    /**
     * 订单id
     */
    @TableId(type = IdType.AUTO)
    private Integer id;

    /**
     * 订单名
     */
    private String name;

    /**
     * 关联用户id（一对多冗余字段，不返回给前端，但是前端作为参数传递）
     */
    private Integer userId;

    /**
     * 关联用户（需组装）
     */
    @TableField(exist = false)
    private User user;

    /**
     * 这个订单中所包含的商品（需组装）
     */
    @TableField(exist = false)
    private List<Product> products;

}

可见这里使用了@JsonIgnoreProperties过滤掉了冗余字段userId不返回给前端。

(4) 各个服务模块

基本上每个服务模块仍然是Spring Boot的四层架构中的三层，即dao、service和api。因此这里只讲关键性的东西，其余细节可以在文末示例仓库中看代码。

来看订单模块，定义数据库操作层OrderDAO如下：

package com.gitee.swsk33.dborder.dao;

import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.gitee.swsk33.dbentity.dataobject.Order;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface OrderDAO extends BaseMapper<Order> {

    /**
     * 添加关联记录
     *
     * @param orderId   订单id
     * @param productId 商品id
     * @return 增加记录条数
     */
    @Insert("insert into `order_product` values (#{orderId}, #{productId})")
    @DS("bridge")
    int insertRecord(int orderId, int productId);

    /**
     * 根据订单id查询其对应的所有商品id列表
     *
     * @param orderId 订单id
     * @return 商品id列表
     */
    @Select("select `product_id` from `order_product` where `order_id` = #{orderId}")
    @DS("bridge")
    List<Integer> selectProductIds(int orderId);

    /**
     * 删除和某个订单关联的商品id记录
     *
     * @param orderId 订单id
     * @return 删除记录数
     */
    @Delete("delete from `order_product` where `order_id` = #{orderId}")
    @DS("bridge")
    int deleteProductIds(int orderId);

}

由于继承了MyBatis-Plus的BaseMapper，因此基本的增删改查这里不需要写了，所以这里只需要写对搭桥表数据库中的操作，比如说获取这个订单中包含的商品id列表等等，也可见这里只获取id或者是传入id为参数对搭桥表进行增删查操作，并且这些方法标注了@DS切换数据源查询。

再来看Service层代码：

package com.gitee.swsk33.dborder.service.impl;

import com.gitee.swsk33.dbentity.dataobject.Order;
import com.gitee.swsk33.dbentity.dataobject.Product;
import com.gitee.swsk33.dbentity.dataobject.User;
import com.gitee.swsk33.dbentity.model.Result;
import com.gitee.swsk33.dbfeign.feignclient.ProductClient;
import com.gitee.swsk33.dbfeign.feignclient.UserClient;
import com.gitee.swsk33.dborder.dao.OrderDAO;
import com.gitee.swsk33.dborder.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class OrderServiceImpl implements OrderService {

    @Autowired
    private OrderDAO orderDAO;

    @Autowired
    private UserClient userClient;

    @Autowired
    private ProductClient productClient;

    @Override
    public Result<Void> add(Order order) {
        Result<Void> result = new Result<>();
        // 先直接插入
        if (orderDAO.insert(order) < 1) {
            result.setResultFailed("插入失败！");
            return result;
        }
        // 插入后，添加与之关联的商品多对多记录
        for (Product each : order.getProducts()) {
            orderDAO.insertRecord(order.getId(), each.getId());
        }
        result.setResultSuccess("插入完成！");
        return result;
    }

    @Override
    public Result<Void> delete(int id) {
        Result<Void> result = new Result<>();
        // 先直接删除
        if (orderDAO.deleteById(id) < 1) {
            result.setResultFailed("删除失败！");
            return result;
        }
        // 然后删除关联部分
        orderDAO.deleteProductIds(id);
        result.setResultSuccess("删除成功！");
        return result;
    }

    @Override
    public Result<Order> getById(int id) {
        Result<Order> result = new Result<>();
        // 先查询订单
        Order getOrder = orderDAO.selectById(id);
        if (getOrder == null) {
            result.setResultFailed("查询失败！");
            return result;
        }
        // 远程调用用户模块，组装订单中的用户对象字段（一对多关联查询）
        User getUser = userClient.getById(getOrder.getUserId()).getData();
        if (getUser == null) {
            result.setResultFailed("查询失败！");
            return result;
        }
        getOrder.setUser(getUser);
        // 远程调用商品模块，组装订单中关联的商品列表（多对多关联查询）
        List<Integer> productIds = orderDAO.selectProductIds(id);
        getOrder.setProducts(productClient.getByBatchId(productIds).getData());
        result.setResultSuccess("查询成功！", getOrder);
        return result;
    }

    @Override
    public Result<List<Order>> getByBatchId(List<Integer> ids) {
        Result<List<Order>> result = new Result<>();
        // 先批量查询
        List<Order> getOrders = orderDAO.selectBatchIds(ids);
        // 组装其中的用户对象字段
        for (Order each : getOrders) {
            each.setUser(userClient.getById(each.getUserId()).getData());
        }
        // 由于批量查询目前专门提供给内部模块作为多对多关联查询时远程调用，因此这里不再对每个对象进行多对多查询，否则会陷入死循环
        result.setResultSuccess("查询完成！", getOrders);
        return result;
    }

}

可以先看代码和注释，这里面已经写好了增删查记录的时候的流程和操作，包括查询多对多搭桥表中的id以及远程调用等等，远程调用代码这里不再赘述。

然后，将这些服务暴露为接口即可，反过来商品服务模块也是基本一样的思路。

上述有以下需要注意的地方：

  • 将搭桥表的操作，即增加、查询和删除这个订单包含的商品id的操作，定义在了OrderDAO中，反过来在商品服务中，ProductDAO中也需要定义增加、查询和删除和这个商品所有关联的订单id的操作，具体可以看项目源码
  • 在服务中编写了getByBatchId这个方法专用于模块远程调用查询多对多的对象，但是可见在这个方法中批量查询时，没有继续组装每个对象中包含的多对多对象，防止死循环

对于远程调用，需要注意的是远程调用层的代码和这些服务不在一个模块中，因此在模块主类上标注@EnableFeignClients注解启用远程调用功能时，还需要指定需要用到的远程调用的FeignClient类，否则会注入失败：

image.png

所有模块写完后，启动并测试接口，来看一下效果：

image.png

image.png

4，总结

事实上，解决分布式微服务的跨库增删改查操作，有很多的方式，这里只是提供一个思路，大家可以适当采纳，不能说这里的方案就是最优雅、性能最好的，还需要根据实际情况考虑。

文章标签：
云原生数据库 PolarDB
Java
前端开发
微服务
关系型数据库
MySQL
Spring
Maven
mybatis
数据库
数据库连接
关键词：
微服务数据库
微服务系统
分布式数据库
微服务分布式
分布式系统
相关实践学习
使用PolarDB和ECS搭建门户网站
本场景主要介绍基于PolarDB和ECS实现搭建门户网站。
阿里云数据库产品家族及特性
阿里云智能数据库产品团队一直致力于不断健全产品体系，提升产品性能，打磨产品功能，从而帮助客户实现更加极致的弹性能力、具备更强的扩展能力、并利用云设施进一步降低企业成本。以云原生+分布式为核心技术抓手，打造以自研的在线事务型(OLTP)数据库Polar DB和在线分析型(OLAP)数据库Analytic DB为代表的新一代企业级云原生数据库产品体系， 结合NoSQL数据库、数据库生态工具、云原生智能化数据库管控平台，为阿里巴巴经济体以及各个行业的企业客户和开发者提供从公共云到混合云再到私有云的完整解决方案，提供基于云基础设施进行数据从处理、到存储、再到计算与分析的一体化解决方案。本节课带你了解阿里云数据库产品家族及特性。
守望时空33
目录
相关文章
Star时光
|
19天前
|
监控 持续交付 API
深入理解微服务架构：构建高效、可扩展的系统
【10月更文挑战第14天】深入理解微服务架构：构建高效、可扩展的系统
Star时光
69 0
1176112968452250
|
2月前
|
安全 应用服务中间件 API
微服务分布式系统架构之zookeeper与dubbo-2
微服务分布式系统架构之zookeeper与dubbo-2
1176112968452250
61 1
1176112968452250
|
2月前
|
负载均衡 Java 应用服务中间件
微服务分布式系统架构之zookeeper与dubbor-1
微服务分布式系统架构之zookeeper与dubbor-1
1176112968452250
73 1
叫个什么名字
|
2月前
|
NoSQL 关系型数据库 MySQL
微服务架构下的数据库选择：MySQL、PostgreSQL 还是 NoSQL？
在微服务架构中，数据库的选择至关重要。不同类型的数据库适用于不同的需求和场景。在本文章中，我们将深入探讨传统的关系型数据库（如 MySQL 和 PostgreSQL）与现代 NoSQL 数据库的优劣势，并分析在微服务架构下的最佳实践。
叫个什么名字
327 9
叫个什么名字
|
2月前
|
设计模式 缓存 关系型数据库
探索微服务架构中的数据库设计挑战
微服务架构因其模块化和高扩展性被广泛应用于现代软件开发。然而，这种架构模式也带来了数据库设计上的独特挑战。本文探讨了在微服务架构中实现数据库设计时面临的问题，如数据一致性、服务间的数据共享和分布式事务处理。通过分析实际案例和提出解决方案，旨在为开发人员提供有效的数据库设计策略，以应对微服务架构下的复杂性。
叫个什么名字
63 7
游客762btuqu5wybw666
|
2月前
|
消息中间件 缓存 监控
优化微服务架构中的数据库访问：策略与最佳实践
在微服务架构中，数据库访问的效率直接影响到系统的性能和可扩展性。本文探讨了优化微服务架构中数据库访问的策略与最佳实践，包括数据分片、缓存策略、异步处理和服务间通信优化。通过具体的技术方案和实例分析，提供了一系列实用的建议，以帮助开发团队提升微服务系统的响应速度和稳定性。
游客762btuqu5wybw666
90 6
龙大吉
|
1天前
|
安全 Nacos 数据库
Nacos是一款流行的微服务注册与配置中心，但直接暴露在公网中可能导致非法访问和数据库篡改
Nacos是一款流行的微服务注册与配置中心，但直接暴露在公网中可能导致非法访问和数据库篡改。本文详细探讨了这一问题的原因及解决方案，包括限制公网访问、使用HTTPS、强化数据库安全、启用访问控制、监控和审计等步骤，帮助开发者确保服务的安全运行。
龙大吉
11 3
最好zzz
|
21天前
|
消息中间件 存储 负载均衡
微服务与分布式系统设计看这篇就够了！
【10月更文挑战第12天】 在现代软件架构中，微服务和分布式系统设计已经成为构建可扩展、灵活和可靠应用程序的主流方法。本文将深入探讨微服务架构的核心概念、设计原则和挑战，并提供一些关于如何在分布式系统中实现微服务的实用指导。
最好zzz
42 2
游客r43put2rqnbp4
|
21天前
|
人工智能 文字识别 Java
SpringCloud+Python 混合微服务，如何打造AI分布式业务应用的技术底层？
尼恩，一位拥有20年架构经验的老架构师，通过其深厚的架构功力，成功指导了一位9年经验的网易工程师转型为大模型架构师，薪资逆涨50%，年薪近80W。尼恩的指导不仅帮助这位工程师在一年内成为大模型架构师，还让他管理起了10人团队，产品成功应用于多家大中型企业。尼恩因此决定编写《LLM大模型学习圣经》系列，帮助更多人掌握大模型架构，实现职业跃迁。该系列包括《从0到1吃透Transformer技术底座》、《从0到1精通RAG架构》等，旨在系统化、体系化地讲解大模型技术，助力读者实现“offer直提”。此外，尼恩还分享了多个技术圣经，如《NIO圣经》、《Docker圣经》等，帮助读者深入理解核心技术。
游客r43put2rqnbp4
25 0
SpringCloud+Python 混合微服务，如何打造AI分布式业务应用的技术底层？
何雨晨
|
1月前
|
Java 数据库 数据安全/隐私保护
Spring 微服务提示：使用环境变量抽象数据库主机名
Spring 微服务提示：使用环境变量抽象数据库主机名
何雨晨
38 1
云原生

微服务

热门文章

最新文章

  • 1
    微服务架构的理论基础 - 康威定律
  • 2
    微服务（Microservice）那点事
  • 3
    .NET Core微服务之路：（纯干货）基于gRPC服务发现与服务治理的方案
  • 4
    10道面试官喜欢问的微服务面试题Spring Cloud+Spring Boot
  • 5
    老司机的微服务架构实现，照亮你的人生 | 朱攀
  • 6
    微服务实战之春云与刀客（五）—— spring cloud与docker swarm集群
  • 7
    微服务分布式企业框架 Springmvc+mybatis+shiro+Dubbo+ZooKeeper+Redis+KafKa
  • 8
    阿里云微服务引擎（MSE） 1.4.0 重磅发布：增加 Nacos、Eureka 引擎支持
  • 9
    基于统一开发平台的微服务架构转型升级之路 | 某国有大型银行案例
  • 10
    Docker & Consul & Fabio & ASP.NET Core 2.0 微服务跨平台实践
  • 1
    java.util的Collections类
    32
  • 2
    JVM进阶调优系列(8)如何手把手，逐行教她看懂GC日志？| IT男的专属浪漫
    33
  • 3
    无障碍工具条本地化安装部署
    26
  • 4
    服务器磁盘爆满？别慌，教你轻松清理！
    59
  • 5
    JVM进阶调优系列(6)一文详解JVM参数与大厂实战调优模板推荐
    73
  • 6
    JVM进阶调优系列(5)CMS回收器通俗演义一文讲透FullGC
    39
  • 7
    免费的CMS系统有哪些？
    116
  • 8
    如何选择适合自己搭建网站的CMS？
    24
  • 9
    JVM进阶调优系列(4)年轻代和老年代采用什么GC算法回收?
    75
  • 10
    什么叫CMS？如何使用CMS来制作网站？
    78

    • 相关课程

    更多
  • 微服务实战-Service Mesh与Istio
  • 微服务实战-分布式配置中心 - Config
  • 微服务实战-服务注册与发现 - Nacos Discovery
  • 分布式文件存储系统技术及实现
  • 分布式协调系统 Zookeeper 快速入门
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 微服务治理技术白皮书
  • 微服务与Serverless
  • EDAS4.0 助力企业一站实现微服务架构转型与 K8s 容器化升级

    • 相关实验场景

    更多
  • 使用ECS和RDS搭建个人博客
  • 体验PolarDB-X透明分布式
  • PolarDB for AI：在数据库中通过SQL实现AI能力
  • 云原生HTAP数据库，让你的交易和分析一库搞定
  • 快速体验PolarDB开源数据库
  • 通过EDAS实现K8s微服务应用的金丝雀发布
    • 下一篇
    DataWorks智能数据建模全面公测开始啦！