分布式事务

最新推荐文章于 2025-05-16 13:16:48 发布
最新推荐文章于 2025-05-16 13:16:48 发布
阅读量150 收藏
点赞数
分类专栏： springclound 文章标签： 分布式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_48483101/article/details/108335884
版权

1.分布式事务的概念

一次业务操作需要跨多个数据源或需要跨多个系统进行远程调用，就会产生分布式事务问题

2.如何解决分布式事务！ seata (阿里巴巴提供的分布式解决方案)

Seata是一款开源的分布式事务解决方案，致力于在微服务架构下提供高性能和简单易用的分布式事务服务

3.Seata的流程

在这里插入图片描述

4.下载seata. 0.9

https://github.com/seata/seata/releases

5.安装

5.1下载并解压：
在这里插入图片描述
5.2要修改的地方：file.conf
在这里插入图片描述
在这里插入图片描述
Registry.conf
在这里插入图片描述
5.3.在数据库中创建一个数据库名称为seata的数据库。 并且创建相应的表。
建表语句

-- the table to store GlobalSession data
drop table if exists `global_table`;
create table `global_table` (
  `xid` varchar(128)  not null,
  `transaction_id` bigint,
  `status` tinyint not null,
  `application_id` varchar(32),
  `transaction_service_group` varchar(32),
  `transaction_name` varchar(128),
  `timeout` int,
  `begin_time` bigint,
  `application_data` varchar(2000),
  `gmt_create` datetime,
  `gmt_modified` datetime,
  primary key (`xid`),
  key `idx_gmt_modified_status` (`gmt_modified`, `status`),
  key `idx_transaction_id` (`transaction_id`)
);

-- the table to store BranchSession data
drop table if exists `branch_table`;
create table `branch_table` (
  `branch_id` bigint not null,
  `xid` varchar(128) not null,
  `transaction_id` bigint ,
  `resource_group_id` varchar(32),
  `resource_id` varchar(256) ,
  `lock_key` varchar(128) ,
  `branch_type` varchar(8) ,
  `status` tinyint,
  `client_id` varchar(64),
  `application_data` varchar(2000),
  `gmt_create` datetime,
  `gmt_modified` datetime,
  primary key (`branch_id`),
  key `idx_xid` (`xid`)
);

-- the table to store lock data
drop table if exists `lock_table`;
create table `lock_table` (
  `row_key` varchar(128) not null,
  `xid` varchar(96),
  `transaction_id` long ,
  `branch_id` long,
  `resource_id` varchar(256) ,
  `table_name` varchar(32) ,
  `pk` varchar(36) ,
  `gmt_create` datetime ,
  `gmt_modified` datetime,
  primary key(`row_key`)
);

5.4先启动nacos 在启动 seata
seata启动界面
在这里插入图片描述
5.5看到nacos中存在如下的内容
在这里插入图片描述

6.编写数据库代码

1.先完成数据库。

CREATE DATABASE seata_order；
 
CREATE DATABASE seata_storage；
 
CREATE DATABASE seata_account；

2.在相应数据库中创建相应的表。

Use seata_order;
CREATE TABLE t_order(
    `id` BIGINT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY,
    `user_id` BIGINT(11) DEFAULT NULL COMMENT '用户id',
    `product_id` BIGINT(11) DEFAULT NULL COMMENT '产品id',
    `count` INT(11) DEFAULT NULL COMMENT '数量',
    `money` DECIMAL(11,0) DEFAULT NULL COMMENT '金额',
    `status` INT(1) DEFAULT NULL COMMENT '订单状态：0：创建中; 1：已完结'
) ENGINE=INNODB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
 
SELECT * FROM t_order;
Use seata_storage;
CREATE TABLE t_storage(
    `id` BIGINT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY,
    `product_id` BIGINT(11) DEFAULT NULL COMMENT '产品id',
   `'total` INT(11) DEFAULT NULL COMMENT '总库存',
    `used` INT(11) DEFAULT NULL COMMENT '已用库存',
    `residue` INT(11) DEFAULT NULL COMMENT '剩余库存'
) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
 
INSERT INTO seata_storage.t_storage(`id`,`product_id`,`total`,`used`,`residue`)
VALUES('1','1','100','0','100'); 
SELECT * FROM t_storage;

Use seata_account;
CREATE TABLE t_account(
    `id` BIGINT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY COMMENT 'id',
    `user_id` BIGINT(11) DEFAULT NULL COMMENT '用户id',
    `total` DECIMAL(10,0) DEFAULT NULL COMMENT '总额度',
    `used` DECIMAL(10,0) DEFAULT NULL COMMENT '已用余额',
    `residue` DECIMAL(10,0) DEFAULT '0' COMMENT '剩余可用额度'
) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
 
INSERT INTO seata_account.t_account(`id`,`user_id`,`total`,`used`,`residue`) VALUES('1','1','1000','0','1000')
 
 
 
SELECT * FROM t_account;

3.在每一个数据库中创建回滚日志表! conf/db_undo_log.sql

-- the table to store seata xid data
-- 0.7.0+ add context
-- you must to init this sql for you business databese. the seata server not need it.
-- 此脚本必须初始化在你当前的业务数据库中，用于AT 模式XID记录。与server端无关（注：业务数据库）
-- 注意此处0.3.0+ 增加唯一索引 ux_undo_log
drop table `undo_log`;
CREATE TABLE `undo_log` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `branch_id` bigint(20) NOT NULL,
  `xid` varchar(100) NOT NULL,
  `context` varchar(128) NOT NULL,
  `rollback_info` longblob NOT NULL,
  `log_status` int(11) NOT NULL,
  `log_created` datetime NOT NULL,
  `log_modified` datetime NOT NULL,
  `ext` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

4.最终数据库结构：
在这里插入图片描述

7.编写业务代码(order，storage,account)

1.order业务
1 创建一个父工程。删除src文件。 修改为package为pom

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <junit.version>4.12</junit.version>
    <log4j.version>1.2.17</log4j.version>
    <lombok.version>1.18.0</lombok.version>
    <mysql.version>5.1.47</mysql.version>
    <mybatis.spring.boot.version>1.3.2</mybatis.spring.boot.version>
</properties>
<!-- 子模块继承之后，提供作用：锁定版本+子模块不用写groupId和version  -->
<dependencyManagement>
    <dependencies>
        <!--  springboot 2.2.2    -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.2.2.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <!--  spring cloud Hoxton.SR1   -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Hoxton.SR1</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <!--  spring cloud alibaba 2.1.0.RELEASE    -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>2.1.0.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.18</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis.spring.boot.version}</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <optional>true</optional>
        </dependency>
    </dependencies>
</dependencyManagement>

2.创建order_module.
在这里插入图片描述
Pom:

<dependencies>
    <!-- nacos -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <!-- nacos -->

    <!-- seata-->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
        <exclusions>
            <exclusion>
                <groupId>io.seata</groupId>
                <artifactId>seata-all</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>io.seata</groupId>
        <artifactId>seata-all</artifactId>
        <version>0.9.0</version>
    </dependency>
    <!-- seata-->
    <!--feign-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.1.18</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <!--jdbc-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

yml文件：

server:
  port: 8001
spring:
  application:
    name: seata-order-service
  cloud:
    alibaba:
      seata:
        # 自定义事务组名称需要与seata-server中的对应
        tx-service-group: fsp_tx_group
    nacos:
      discovery:
        server-addr: localhost:8848
  datasource:
    # 当前数据源操作类型
    type: com.alibaba.druid.pool.DruidDataSource
    # mysql驱动类
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.213.132:3306/seata_order?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8
    username: root
    password: root

logging:
  level:
    io:
      seata: info
mybatis:
  mapper-locations: classpath:mapper/*.xml

File.conf文件 《seata/conf/file.conf》复制到resources文件夹下
在这里插入图片描述
在这里插入图片描述
Register.conf文件<seata/conf/register.conf>复制到resources文件夹下
在这里插入图片描述
Dao:


@Mapper
public interface OrderDao {

    //1.下单的方法
    public void create(Order order);

    //2.修改订单的状态。
    public void update(@Param("userId")Long userId,@Param("status")Integer status);
}

xml：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ykq.dao.OrderDao">

    <resultMap id="BaseResultMap" type="com.ykq.entity.Order">
        <result property="id" column="id" jdbcType="BIGINT"/>
        <result property="userId" column="user_id" jdbcType="BIGINT"/>
        <result property="productId" column="product_id" jdbcType="BIGINT"/>
        <result property="count" column="count" jdbcType="INTEGER"/>
        <result property="money" column="money" jdbcType="BIGINT"/>
        <result property="status" column="status" jdbcType="INTEGER"/>
    </resultMap>


    <insert id="create">
        insert into t_order(id,user_id,product_id,count,money,status)
        value (null,#{userId},#{productId},#{count},#{money},0)
    </insert>

    <update id="update">
        update t_order set status = 1 where user_id = #{userId} and status = 0

Entity:
CommonResult实体

package com.ykq.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommonResult<T> { 
    private Integer code;
    private String message;
    private T data;
    public CommonResult(Integer code, String message) {
        this(code, message, null);
    }
}

Order实体

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Order {
    private Long id;
    private Long userId;
    private Long productId;
    private Integer count;
    private BigDecimal money;
    private Integer status; //订单状态：0：未付款，1：付款结束
}

Feign：
AccountFeign:

package com.ykq.feign;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import java.math.BigDecimal;

@FeignClient(value = "seata-account-service")
public interface AccountFeign {

    @RequestMapping("account/decrease")
    public void decrease(@RequestParam("userId")Long userId, @RequestParam("money")BigDecimal money);
}

StorageFeign:

package com.ykq.feign;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

@FeignClient(value = "seata-storage-service")
public interface StorageFeign {
    @RequestMapping("/storage/decrease")
    public void decrease(@RequestParam("productId")Long productId,@RequestParam("count")Integer count);
}

orderService:

package com.ykq.service.impl;

import com.ykq.dao.OrderDao;
import com.ykq.entity.Order;
import com.ykq.feign.AccountFeign;
import com.ykq.feign.StorageFeign;
import com.ykq.service.OrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
@Slf4j
public class OrderServiceImpl implements OrderService {
    @Autowired
    private OrderDao orderDao;

    @Autowired
    private StorageFeign storageFeign;

    @Autowired
    private AccountFeign accountFeign;

    @Override
    public void create(Order order) {
        log.info("下单开始---------------------->");
        orderDao.create(order);
        log.info("下单结束---------------------->");

        log.info("开始扣减库存微服务----------->");
        storageFeign.decrease(order.getProductId(),order.getCount());
        log.info("结束扣减库存微服务----------->");

        log.info("开始扣减账户微服务的余额----------->");
        accountFeign.decrease(order.getUserId(),order.getMoney());
        log.info("结束扣减账户微服务的余额----------->");

        orderDao.update(order.getUserId(),1);

        log.info("哈哈，下单成功----------->");
    }
}

Controller:

@RestController
public class OrderController {
    @Autowired
    private OrderService orderService;

    @RequestMapping("/order/create")
    public CommonResult create(Order order){
        orderService.create(order);
        return new CommonResult(200,"下单成功");
    }
}

Config:
DataSourceProxyConfig：

package com.myl.config;

import com.alibaba.druid.pool.DruidDataSource;
import io.seata.rm.datasource.DataSourceProxy;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;

import javax.sql.DataSource;

/**
 * @Author EiletXie
 * @Since 2020/3/18 21:51
 * 使用Seata对数据源进行代理
 */
@Configuration
public class DataSourceProxyConfig {

    @Value("${mybatis.mapper-locations}")
    private String mapperLocations;

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource druidDataSource() {
        return new DruidDataSource();
    }

    @Bean
    public DataSourceProxy dataSourceProxy(DataSource druidDataSource) {
        return new DataSourceProxy(druidDataSource);
    }

    @Bean
    public SqlSessionFactory sqlSessionFactoryBean(DataSourceProxy dataSourceProxy) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSourceProxy);
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        bean.setMapperLocations(resolver.getResources(mapperLocations));
        return bean.getObject();
    }
}

MyBatisConfig：

package com.myl.config;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Configuration;

/**
 * @Author EiletXie
 * @Since 2020/3/18 21:13
 */
@Configuration
@MapperScan({"com.myl.dao"})
public class MyBatisConfig {


}

主启动类：

package com.ykq;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.cloud.openfeign.EnableFeignClients;
//DataSourceAutoConfiguration:排除？ 使用seata来连接数据库。自己配置。
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
@EnableFeignClients  //开启feign的注解
@EnableDiscoveryClient  //把微服务注册到nacos注册中心
public class OrderMainApp8001 {
    public static void main(String[] args) {
        SpringApplication.run(OrderMainApp8001.class,args);
    }
}

2.storage微服务和account微服务步骤和order微服务一样，
完成上面三个微服务！

测试：

1.正常测试.
http://localhost:8001/order/create?userId=1&productId=1&count=10&money=100
2.有异常，但是不使用GlobalTransactional
1.账户微服务异常，超时，关闭。
3.有异常，使用GlobalTransactional
在这里插入图片描述

分布式事务之Seata.pdf
12-04
分布式事务是指在分布式系统中，由多个节点共同参与的一系列操作，以保证数据的一致性和完整性。它通常出现于微服务架构的环境中，其中不同的服务节点需要协调处理跨服务的业务逻辑。分布式事务具有复杂性，主要由于...
分布式事务若依框架文档
04-11
### 分布式事务若依框架文档 #### 一、分布式事务基本概念 在理解分布式事务之前，我们首先需要了解数据库事务的基本属性，即ACID特性。 - **原子性（Atomicity）**：事务中的所有操作要么全部成功，要么全部失败...
什么是分布式事务？
在技术的广袤天地里，本博客如精准罗盘。剖析前沿科技，深掘代码奥秘，以精炼笔触，带您穿越复杂技术迷宫，速达知识彼岸。
08-09 993
XA 事务适合与符合 XA 的系统集成，以实现标准化协调；自定义方法提供灵活性和性能优化。
RocketMQ分布式事务
极客专栏
04-15 678
业务场景：用户A转账100元给用户B，这个业务比较简单，具体的步骤：1、用户A的账户先扣除100元2、再把用户B的账户加100元如果在同一个数据库中进行，事务可以保证这两步操作，要么同时成功，要么同时不成功。这样就保证了转账的数据一致性。但是在微服务架构中，因为各个服务都是独立的模块，都是远程调用，都没法在同一个事务中，都会遇到分布式事务问题。
RocketMQ分布式事务消息
Flying_Fish_roe的博客
11-17 1242
在分布式系统中，实现跨多个服务或数据库的事务一致性是一个具有挑战性的问题。传统的本地事务只能保证单个服务或数据库操作的原子性，而在分布式环境中，涉及多个独立系统的事务操作，需要通过分布式事务来保证数据的一致性。RocketMQ 提供了分布式事务消息机制，能够有效地解决分布式事务中操作一致性的问题。RocketMQ 的分布式事务消息基于二阶段提交（Two-phase Commit）协议实现，允许开发者在分布式环境中保证多个操作的原子性和一致性。
分布式事务及Seata
weixin_47654264的博客
01-17 1188
分布式事务及Seata
MySQL分布式事务
不思考会变草履虫哦
09-23 840
分布式事务是一种在分布式系统中确保数据一致性的机制，主要通过两阶段提交、三阶段提交、补偿事务等技术来实现。XA 事务是其中一种具体的实现方式，广泛应用于需要跨多个资源管理器的事务处理场景。
详谈分布式事务
BugMan的博客
03-20 2041
一文深入浅出详细聊一下分布式事务。
【07】分布式事务解决方案
XQ_898878888的博客
07-14 1569
事务()是访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。在关系数据库中，一个事务由一组SQL语句组成。原子性一致性隔离性持久性。任何事务机制在实现时，都应该考虑事务的ACID特性，包括：本地事务、分布式事务。
Seata:分布式事务
03-27 1337
Seata 中有三大模块，分别是 TM、RM 和 TC。其中 TM 和 RM 是作为 Seata 的客户端与业务系统集成在一起，TC 作为 Seata 的服务端独立部署。事务协调器（Transaction Coordinator）：负责协调全局事务并驱动事务参与者提交或回滚事务。事务参与者（Transaction Participant）：即业务系统，负责执行分支事务的提交和回滚操作。事务管理器（Transaction Manager）：提供全局事务的管理和协调。
Seata分布式事务详解
m0_48038376的博客
08-15 974
分布式事务在电商购物流程中的用途是确保多个服务或系统之间的数据一致性和事务的原子性，从而提升用户体验和系统性能。这个例子展示了分布式事务在复杂分布式系统中的重要性。答案SEATA是一款开源的分布式事务解决方案，旨在解决分布式系统中的数据一致性问题。它提供了ACID事务的支持，包括原子性、一致性、隔离性和持久性，特别适用于微服务架构和云原生应用。分布式事务是指涉及多个服务或数据库的操作，需要保证这些操作要么全部成功，要么全部失败，以确保数据的一致性。
基于Hyperf框架的TCC分布式事务组件.zip
02-02
TCC（Try-Confirm-Cancel）模式是一种著名的分布式事务解决方案，它适用于大型微服务架构。本资料"基于Hyperf框架的TCC分布式事务组件"旨在帮助开发者理解如何在Hyperf这个高性能、轻量级的PHP微服务框架中实现TCC...
若依框架分布式事务配置和项目启动手册
04-11
《若依框架分布式事务配置与项目启动指南》 在当今的互联网时代，高并发、大数据量的业务场景对系统的性能和稳定性提出了更高要求，而分布式事务则是解决这些问题的关键技术之一。若依框架作为一款广受欢迎的Java...
java分布式事务demo
04-06
Java分布式事务是大型分布式系统中不可或缺的一个重要组成部分，它确保在多个网络节点间的数据操作能够保持一致性和完整性。在分布式环境中，由于多个服务之间可能存在数据交互，因此需要一种机制来处理跨服务的数据...
分布式 ID 生成的五种方法：优缺点与适用场景
qq_40529346的博客
05-16 459
在分布式系统中，生成全局唯一的id是一个常见的需求。由于分布式系统的特性（多节点，网络分区，时钟不同步等），传统的单机ID生成方式不再适用，所以一些分布式生成方式应运而生，本文将对常见的几种分布式ID生成方法的原理和应用进行介绍。
特斯拉虚拟电厂：能源互联网时代的分布式革命
beige888的博客
05-16 575
特斯拉虚拟电厂的实践表明，数字孪生技术正在重塑能源系统的运行逻辑与价值创造模式。随着IEEE 2030.2标准的推进，虚拟电厂将与交通网、天然气网深度耦合，构建起多能互补的智慧能源生态系统。在双碳目标与能源转型的双重驱动下，特斯拉虚拟电厂（Virtual Power Plant, VPP）通过数字孪生技术与能源系统的深度融合，重构了传统电力系统的运行范式。特斯拉虚拟电厂采用"云-边-端"三层架构，构建起覆盖能源生产、存储、消费的全链路数字孪生体，实现物理世界与信息世界的实时映射与闭环控制。
基于Mongodb的分布式文件存储实现
最新发布
m0_69632475的博客
05-16 372
基于 MongoDB GridFS 的分布式文件存储方案，凭借其独特的文件分块存储原理和与 MongoDB 分布式架构的紧密结合，为我们提供了一种高效、可靠的文件存储方式。通过 Spring Boot 的集成，我们能够快速在项目中实现文件的上传、下载、查询和删除等功能。在实际应用过程中，我们需要关注内存管理、数据类型转换、时间类型处理等常见问题，并采用合适的解决方案。随着技术的不断发展，GridFS 也在持续优化和完善，将为更多的分布式文件存储场景提供强大的支持。
【C++】深入理解 unordered 容器、布隆过滤器与分布式一致性哈希
jokerMingge的博客
05-13 1101
本文深入探讨了C++中的unordered容器、布隆过滤器和分布式一致性哈希的原理、实现及应用场景。unordered容器基于哈希表，提供O(1)的查询、插入和删除操作，通过链表法或开放寻址法处理哈希冲突。布隆过滤器是一种概率型数据结构，用于判断元素是否存在，具有高效和节省空间的特点，但存在误判且不支持删除。一致性哈希则用于解决分布式系统中的数据迁移问题，通过虚拟节点优化负载均衡。这些技术在数据结构优化、缓存设计和分布式架构中发挥着重要作用。
分布式事务原理与应用
"分布式事务是IT开发中处理多数据库或服务间一致性的重要技术。本文将介绍分布式事务的基本概念、产生原因、ACID特性，并通过电商系统中的支付场景来阐述其应用。" 分布式事务是一个关键的概念，它涉及到在分布式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值