50 [十gmicro重构项目] :库存服务\dtm分布式事务框架

已于 2023-07-05 10:35:47 修改
阅读量584 收藏
点赞数
分类专栏： go 文章标签： 分布式 golang
于 2023-04-20 21:25:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qwrasdzcc/article/details/130231280
版权

目录

文章目录

一、库存服务

1、代码

在这里插入图片描述

2、sort包使用

在这里插入图片描述
sort是一个接口,使用的话需要实现三个方法:Len(),Less(),Swap()
切片不能定义方法,可以用别名定义方法

type GoodsDetail struct {
	Goods int32
	Num   int32
}

type GoodsDetailList []GoodsDetail

func (a GoodsDetailList) Len() int           { return len(a) }
func (a GoodsDetailList) Less(i, j int) bool { return a[i].Goods < a[j].Goods }
func (a GoodsDetailList) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }

在这里插入图片描述

3、库存扣减

func (is *inventoryService) Sell(ctx context.Context, ordersn string, details []do.GoodsDetail) error {
	log.Infof("订单%s扣减库存", ordersn)
	//解决了空悬挂的问题
	//先查询刚才插入的记录是否存在，如果存在则说明已经cancel就不能执行了

	rs := redsync.New(is.pool)
	//实际上批量扣减库存的时候， 我们经常会先按照商品的id排序，然后从小大小逐个扣减库存，这样可以减少锁的竞争
	//如果无序的话 那么就有可能订单a 扣减 1,3,4 订单B 扣减 3,2,1
	var detail = do.GoodsDetailList(details)
	sort.Sort(detail)

	txn := is.data.Begin()
	defer func() {
		if err := recover(); err != nil {
			_ = txn.Rollback()
			log.Error("事务进行中出现异常，回滚")
			return
		}
	}()

	sellDetail := do.StockSellDetailDO{
		OrderSn: ordersn,
		Status:  1,
		Detail:  detail,
	}

	for _, goodsInfo := range detail {
		mutex := rs.NewMutex(inventoryLockPrefix + ordersn)
		if err := mutex.Lock(); err != nil {
			log.Errorf("订单%s获取锁失败", ordersn)
		}

		inv, err := is.data.Inventorys().Get(ctx, uint64(goodsInfo.Goods))
		if err != nil {
			log.Errorf("订单%s获取库存失败", ordersn)
			return err
		}

		//判断库存是否充足
		if inv.Stocks < goodsInfo.Num {
			txn.Rollback() //回滚
			log.Errorf("商品%d库存%d不足, 现有库存: %d", goodsInfo.Goods, goodsInfo.Num, inv.Stocks)
			return errors.WithCode(code.ErrInvNotEnough, "库存不足")
		}
		inv.Stocks -= goodsInfo.Num

		err = is.data.Inventorys().Reduce(ctx, txn, uint64(goodsInfo.Goods), int(goodsInfo.Num))
		if err != nil {
			txn.Rollback() //回滚
			log.Errorf("订单%s扣减库存失败", ordersn)
			return err
		}

		//释放锁
		if _, err := mutex.Unlock(); err != nil {
			txn.Rollback() //回滚
			log.Errorf("订单%s释放锁出现异常", ordersn)
		}
	}

	err := is.data.Inventorys().CreateStockSellDetail(ctx, txn, &sellDetail)
	if err != nil {
		txn.Rollback() //回滚
		log.Errorf("订单%s创建扣减库存记录失败", ordersn)
		return err
	}

	txn.Commit()
	return nil
}

4、库存归还


func (is *inventoryService) Reback(ctx context.Context, ordersn string, details []do.GoodsDetail) error {
	log.Infof("订单%s归还库存", ordersn)

	rs := redsync.New(is.pool)

	txn := is.data.Begin()
	defer func() {
		if err := recover(); err != nil {
			_ = txn.Rollback()
			log.Error("事务进行中出现异常，回滚")
			return
		}
	}()

	//库存归还的时候有不少细节
	//1. 主动取消 2. 网络问题引起的重试 3. 超时取消 4. 退款取消
	mutex := rs.NewMutex(orderLockPrefix + ordersn)
	if err := mutex.Lock(); err != nil {
		txn.Rollback() //回滚
		log.Errorf("订单%s获取锁失败", ordersn)
		return err
	}
	sellDetail, err := is.data.Inventorys().GetSellDetail(ctx, txn, ordersn)
	if err != nil {
		txn.Rollback()
		_, err := mutex.Unlock()
		if err != nil {
			log.Errorf("订单%s释放锁出现异常", ordersn)
			return err
		}
		if errors.IsCode(err, code.ErrInvSellDetailNotFound) {
			//空回滚
			log.Errorf("订单%s扣减库存记录不存在, 忽略", ordersn)
			//我应该记录一条数据去记录，说 ordersn已经被cancel了
			return nil
		}
		log.Errorf("订单%s获取扣减库存记录失败", ordersn)
		return err
	}

	if sellDetail.Status == 2 {
		log.Infof("订单%s扣减库存记录已经归还, 忽略", ordersn)
		return nil
	}

	var detail = do.GoodsDetailList(details)
	sort.Sort(detail)

	for _, goodsInfo := range detail {
		inv, err := is.data.Inventorys().Get(ctx, uint64(goodsInfo.Goods))
		if err != nil {
			txn.Rollback() //回滚
			log.Errorf("订单%s获取库存失败", ordersn)
			return err
		}
		inv.Stocks += goodsInfo.Num

		err = is.data.Inventorys().Increase(ctx, txn, uint64(goodsInfo.Goods), int(goodsInfo.Num))
		if err != nil {
			txn.Rollback() //回滚
			log.Errorf("订单%s归还库存失败", ordersn)
			return err
		}
	}

	err = is.data.Inventorys().UpdateStockSellDetailStatus(ctx, txn, ordersn, 2)
	if err != nil {
		txn.Rollback() //回滚
		log.Errorf("订单%s更新扣减库存记录失败", ordersn)
		return err
	}

	txn.Commit()
	return nil
}

二、dtm分布式事务框架之SAGA

1、github官网和文档

文档

官网
10分钟说透saga分布式事务
与tcc(try,commit,cancel)不同,saga取消了commit阶段.可以出现中间状态.例如saga分布式事务(saga是dtm框架一部分):
1.从前往后执行事务,执行出错,向前补偿(回滚)
2.没有configm阶段,B可以看见中间状态
在这里插入图片描述

2、各种分布式事务应用场景

在这里插入图片描述
秒杀、缓存等不用回滚的适合二阶段消息。订单服务需要回滚适合saga分布式事务。转账服务一致性高，不能让用户看到中间余额变动适合TCC。

3、dtm的安装

运行dtm-main就行

4、HTTP事务-SAGA转账

1.转入失败归还

package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
	"sync"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/lithammer/shortuuid/v3"

	"github.com/dtm-labs/client/dtmcli"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	glog "gorm.io/gorm/logger"
)

type UserAccount struct {
	ID             int     `gorm:"column:id;primary_key"`
	UserId         int     `gorm:"user_id"`
	Balance        float64 `gorm:"balance"`
	TradingBalance float64 `gorm:"trading_balance"`
}

func (UserAccount) TableName() string {
	return "user_account"
}

var lock sync.Mutex

// 转入和转出的时候，都要加锁，否则会出现并发问题
func SagaAdjustBalance(db *gorm.DB, uid int, amount float64) error {
	lock.Lock()
	defer lock.Unlock()

	if amount < 0 {
		var userAccount = UserAccount{}
		db.First(&userAccount, "user_id = ?", uid)
		if userAccount.Balance < -amount {
			return fmt.Errorf("余额不足")
		}
	}
	t := db.Exec("update dtm.user_account set balance = balance + ? where user_id = ?", amount, uid)
	if t.Error != nil {
		return t.Error
	}
	return nil
}

var db *gorm.DB

func initDB() error {
	dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local",
		"root",
		"root",
		"192.168.2.13",
		"3306",
		"dtm")
	newLogger := glog.New(
		log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer（日志输出的目标，前缀和日志包含的内容——译者注）
		glog.Config{
			SlowThreshold:             time.Second, // 慢 SQL 阈值
			LogLevel:                  glog.Info,   // 日志级别
			IgnoreRecordNotFoundError: true,        // 忽略ErrRecordNotFound（记录未找到）错误
			Colorful:                  false,       // 禁用彩色打印
		},
	)

	var err error
	db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{
		Logger: newLogger,
	})
	if err != nil {
		return err
	}
	return nil
}

// MustBarrierFromGin 1
func MustBarrierFromGin(c *gin.Context) *dtmcli.BranchBarrier {
	ti, err := dtmcli.BarrierFromQuery(c.Request.URL.Query())
	fmt.Println(err)
	return ti
}

// 服务发现， 库存服务有5个
func main() {
	err := initDB()
	if err != nil {
		panic(err)
	}

	r := gin.Default()
	r.POST("/SagaBTransIn", func(c *gin.Context) {
		fmt.Println("开始转入")
		userID := 1
		err := SagaAdjustBalance(db, userID, 100)
		if err != nil {
			fmt.Printf("转入失败:%s\r\n", err.Error())
			return
		}
		fmt.Println("转入失败")
		c.JSON(http.StatusConflict, gin.H{})
		return

	})

	r.POST("/SagaBTransInCom", func(c *gin.Context) {
		fmt.Println("转入失败， 开始补偿")
		userID := 1
		err := SagaAdjustBalance(db, userID, -100)
		if err != nil {
			fmt.Printf("转入补偿失败:%s\r\n", err.Error())
			return
		}
		fmt.Println("转入补偿成功")
	})

	r.POST("/SagaBTransOut", func(c *gin.Context) {
		fmt.Println("开始转出")
		userID := 3
		err := SagaAdjustBalance(db, userID, -100)
		if err != nil {
			if err.Error() == "余额不足" {
				c.JSON(http.StatusConflict, gin.H{})
				return
			}
			fmt.Printf("转出失败:%s\r\n", err.Error())
			c.JSON(500, gin.H{"msg": err.Error()})
			return
		}
		fmt.Println("转出成功")
	})

	r.POST("/SagaBTransOutCom", func(c *gin.Context) {
		fmt.Println("转出失败， 开始补偿")
		userID := 3
		err := SagaAdjustBalance(db, userID, 100)
		if err != nil {
			fmt.Printf("转出补偿失败:%s\r\n", err.Error())
			return
		}
		fmt.Println("转出补偿成功")
	})

	r.GET("start", func(c *gin.Context) {
		req := gin.H{}
		dmtServer := "http://127.0.0.1:36789/api/dtmsvr"
		qsBusi := "http://127.0.0.1:8089"
		saga := dtmcli.NewSaga(dmtServer, shortuuid.New()).
			// 添加一个TransOut的子事务，正向操作为url: qsBusi+"/TransOut"， 逆向操作为url: qsBusi+"/TransOutCom"
			Add(qsBusi+"/SagaBTransOut", qsBusi+"/SagaBTransOutCom", req).
			// 添加一个TransIn的子事务，正向操作为url: qsBusi+"/TransOut"， 逆向操作为url: qsBusi+"/TransInCom"
			Add(qsBusi+"/SagaBTransIn", qsBusi+"/SagaBTransInCom", req)
		// 提交saga事务，dtm会完成所有的子事务/回滚所有的子事务
		saga.WaitResult = true
		err := saga.Submit()
		if err != nil {
			c.JSON(500, gin.H{"message": err.Error()})
		}
		c.JSON(200, gin.H{"message": "ok"})
	})

	r.Run(":8089")
}

开始转出
2023/04/19 22:53:36 D:/xuexi/resources/resources/GoStart/dtm/main.go:40
[11.015ms] [rows:1] SELECT * FROM user_account WHERE user_id = 3 ORDER BY user_account.id LIMMIT 1

2023/04/19 22:53:36 D:/xuexi/resources/resources/GoStart/dtm/main.go:45
[5.692ms] [rows:1] update dtm.user_account set balance = balance + -100.000000 where user_id = 3
转出成功
[GIN] 2023/04/19 - 22:53:36 | 200 | 17.8382ms | 127.0.0.1 | POST “/SagaBTransOut?branch_id=01&gid=vms3zDQmnwo2Lj5MBMbtMn&op=action&trans_type=saga”
开始转入

2023/04/19 22:53:36 D:/xuexi/resources/resources/GoStart/dtm/main.go:45
[3.855ms] [rows:1] update dtm.user_account set balance = balance + 100.000000 where user_id = 1
转入失败
[GIN] 2023/04/19 - 22:53:36 | 409 | 3.855ms | 127.0.0.1 | POST “/SagaBTransIn?branch_id=02&gid=vms3zDQmnwo2Lj5MBMbtMn&op=action&trans_type=saga”
转入失败， 开始补偿

2023/04/19 22:53:36 D:/xuexi/resources/resources/GoStart/dtm/main.go:40
[1.950ms] [rows:1] SELECT * FROM user_account WHERE user_id = 1 ORDER BY user_account.id LIMIT 1

2023/04/19 22:53:36 D:/xuexi/resources/resources/GoStart/dtm/main.go:45
[3.109ms] [rows:1] update dtm.user_account set balance = balance + -100.000000 where user_id = 1
转入补偿成功
[GIN] 2023/04/19 - 22:53:36 | 200 | 5.0594ms | 127.0.0.1 | POST “/SagaBTransInCom?branch_id=02&gid=vms3zDQmnwo2Lj5MBMbtMn&op=compensate&trans_type=saga”
转出失败， 开始补偿

2023/04/19 22:53:36 D:/xuexi/resources/resources/GoStart/dtm/main.go:45
[3.262ms] [rows:1] update dtm.user_account set balance = balance + 100.000000 where user_id = 3
转出补偿成功
[GIN] 2023/04/19 - 22:53:36 | 200 | 3.2617ms | 127.0.0.1 | POST “/SagaBTransOutCom?branch_id=01&gid=vms3zDQmnwo2Lj5MBMbtMn&op=compensate&trans_type=saga”
[GIN-debug] [WARNING] Headers were already written. Wanted to override status code 500 with 200
[GIN] 2023/04/19 - 22:53:36 | 200 | 43.1154ms | 127.0.0.1 | GET “/start”

2.转入成功情况

取消故意失败return

	r.POST("/SagaBTransIn", func(c *gin.Context) {
		fmt.Println("开始转入")
		userID := 1
		err := SagaAdjustBalance(db, userID, 100)
		if err != nil {
			fmt.Printf("转入失败:%s\r\n", err.Error())
			return
		}
		fmt.Println("转入成功")
	})

[GIN-debug] Listening and serving HTTP on :8089
开始转出

2023/04/19 22:56:43 D:/xuexi/resources/resources/GoStart/dtm/main.go:40
[12.626ms] [rows:1] SELECT * FROM user_account WHERE user_id = 3 ORDER BY user_account.id LIMIT 1

2023/04/19 22:56:43 D:/xuexi/resources/resources/GoStart/dtm/main.go:45
[2.035ms] [rows:1] update dtm.user_account set balance = balance + -100.000000 where user_id = 3
转出成功
[GIN] 2023/04/19 - 22:56:43 | 200 | 14.6617ms | 127.0.0.1 | POST “/SagaBTransOut?branch_id=01&gid=3L8mGzu4iyAi6L3Rczqk3j&op=action&trans_type=saga”
开始转入

2023/04/19 22:56:43 D:/xuexi/resources/resources/GoStart/dtm/main.go:45
[2.727ms] [rows:1] update dtm.user_account set balance = balance + 100.000000 where user_id = 1
转入成功

5、GRPC事务-SAGA转账

1.接入consul

在这里插入图片描述

consul接入类似kratos
1.复制一份conf.sample.yml 改名为conf.yaml
内容如下:

在这里插入图片描述

MicroService: # gRPC/HTTP based microservice config
 Driver: 'dtm-driver-kratos' # name of the driver to handle register/discover
 Target: 'consul://127.0.0.1:8500/dtmservice' # register dtm server to this url
 EndPoint: 'grpc://127.0.0.1:36790'

2.运行dtm的main.go启动dtm,将dtm也作为微服务注册进consul

3.rpc\main.go 通过gin添加访问grpc服务的start接口

在这里插入图片描述
具体grpc方法如下:
在这里插入图片描述

6、事务屏障达到通过gin集成转入转出功能

1.建表

在这里插入图片描述
在这里插入图片描述
先建立dtm_barrier库和表

create database if not exists dtm_barrier
/*!40100 DEFAULT CHARACTER SET utf8mb4 */
;
drop table if exists dtm_barrier.barrier;
create table if not exists dtm_barrier.barrier(
  id bigint(22) PRIMARY KEY AUTO_INCREMENT,
  trans_type varchar(45) default '',
  gid varchar(128) default '',
  branch_id varchar(128) default '',
  op varchar(45) default '',
  barrier_id varchar(45) default '',
  reason varchar(45) default '' comment 'the branch type who insert this record',
  create_time datetime DEFAULT now(),
  update_time datetime DEFAULT now(),
  key(create_time),
  key(update_time),
  UNIQUE key(gid, branch_id, op, barrier_id)
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;

2.下载dmt.example做参考

example

3.gin集成转入转出功能

package main

import (
	"database/sql"
	"fmt"
	"log"
	"net/http"
	"os"
	"sync"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/lithammer/shortuuid/v3"

	"github.com/dtm-labs/client/dtmcli"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	glog "gorm.io/gorm/logger"
)

type UserAccount struct {
	ID             int     `gorm:"column:id;primary_key"`
	UserId         int     `gorm:"user_id"`
	Balance        float64 `gorm:"balance"`
	TradingBalance float64 `gorm:"trading_balance"`
}

func (UserAccount) TableName() string {
	return "user_account"
}

var lock sync.Mutex

// 转入和转出的时候，都要加锁，否则会出现并发问题
func SagaAdjustBalance(db *sql.Tx, uid int, amount float64) error {
	lock.Lock()
	defer lock.Unlock()

	if amount < 0 {
		var balance float64
		db.QueryRow("select balance from dtm.user_account where user_id = ?", uid).Scan(&balance)
		if balance < -amount {
			return fmt.Errorf("余额不足")
		}
	}
	_, err := db.Exec("update dtm.user_account set balance = balance + ? where user_id = ?", amount, uid)
	if err != nil {
		return err
	}
	return nil
}

var db *gorm.DB

func initDB() error {
	dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local",
		"root",
		"root",
		"192.168.2.13",
		"3306",
		"dtm")
	newLogger := glog.New(
		log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer（日志输出的目标，前缀和日志包含的内容——译者注）
		glog.Config{
			SlowThreshold:             time.Second, // 慢 SQL 阈值
			LogLevel:                  glog.Info,   // 日志级别
			IgnoreRecordNotFoundError: true,        // 忽略ErrRecordNotFound（记录未找到）错误
			Colorful:                  false,       // 禁用彩色打印
		},
	)

	var err error
	db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{
		Logger: newLogger,
	})
	if err != nil {
		return err
	}
	return nil
}

// 获取屏障
// MustBarrierFromGin 1
func MustBarrierFromGin(c *gin.Context) *dtmcli.BranchBarrier {
	ti, err := dtmcli.BarrierFromQuery(c.Request.URL.Query())
	fmt.Println(err)
	return ti
}

// 服务发现， 库存服务有5个
func main() {
	err := initDB()
	if err != nil {
		panic(err)
	}

	r := gin.Default()
	r.POST("/SagaBTransIn", func(c *gin.Context) {
		barrier := MustBarrierFromGin(c) //1.生成一个屏障
		tx := db.Begin()                 //2.开启事务
		sourceTx := tx.Statement.ConnPool.(*sql.Tx)
		err := barrier.Call(sourceTx, func(tx1 *sql.Tx) error { //3.将业务逻辑翻到Call方法执行
			fmt.Println("开始转入")
			userID := 1
			err := SagaAdjustBalance(sourceTx, userID, 100) //4.修改gorm为 sql.Tx并使用原生sql查询(gorm支持不全)
			if err != nil {
				fmt.Printf("转入失败:%s\r\n", err.Error())
				return err
			}
			return nil
		})
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 1, "msg": err.Error()})
			return
		}

		return
	})

	r.POST("/SagaBTransInCom", func(c *gin.Context) {
		fmt.Println("转入失败， 开始补偿")
		//userID := 1
		//err := SagaAdjustBalance(db, userID, -100)
		//if err != nil {
		//	fmt.Printf("转入补偿失败:%s\r\n", err.Error())
		//	return
		//}
		fmt.Println("转入补偿成功")
	})

	r.POST("/SagaBTransOut", func(c *gin.Context) {
		barrier := MustBarrierFromGin(c)
		tx := db.Begin()
		sourceTx := tx.Statement.ConnPool.(*sql.Tx)

		err := barrier.Call(sourceTx, func(tx1 *sql.Tx) error {
			fmt.Println("开始转出")
			userID := 3
			err := SagaAdjustBalance(sourceTx, userID, -100)
			if err != nil {
				if err.Error() == "余额不足" {
					c.JSON(http.StatusConflict, gin.H{})
				}
				fmt.Printf("转出失败:%s\r\n", err.Error())
				c.JSON(500, gin.H{"msg": err.Error()})
			}
			fmt.Println("转出成功")
			return nil
		})
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 1, "msg": err.Error()})
			return
		}
		return
	})

	r.POST("/SagaBTransOutCom", func(c *gin.Context) {
		fmt.Println("转出失败， 开始补偿")
		//userID := 3
		//err := SagaAdjustBalance(db, userID, 100)
		//if err != nil {
		//	fmt.Printf("转出补偿失败:%s\r\n", err.Error())
		//	return
		//}
		fmt.Println("转出补偿成功")
	})

	r.GET("start", func(c *gin.Context) {
		req := gin.H{}
		dmtServer := "http://127.0.0.1:36789/api/dtmsvr"
		qsBusi := "http://127.0.0.1:8089"
		saga := dtmcli.NewSaga(dmtServer, shortuuid.New()).
			// 添加一个TransOut的子事务，正向操作为url: qsBusi+"/TransOut"， 逆向操作为url: qsBusi+"/TransOutCom"
			Add(qsBusi+"/SagaBTransOut", qsBusi+"/SagaBTransOutCom", req).
			// 添加一个TransIn的子事务，正向操作为url: qsBusi+"/TransOut"， 逆向操作为url: qsBusi+"/TransInCom"
			Add(qsBusi+"/SagaBTransIn", qsBusi+"/SagaBTransInCom", req)
		// 提交saga事务，dtm会完成所有的子事务/回滚所有的子事务
		saga.WaitResult = true
		err := saga.Submit()
		if err != nil {
			c.JSON(500, gin.H{"message": err.Error()})
		}
		c.JSON(200, gin.H{"message": "ok"})
	})

	r.Run(":8089")
}
qwrasdzcc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
每秒1w+分布式事务--dtm的Redis存储性能测试分析
weixin_54556126的博客
12-29 525
概述 之前dtm给出了Mysql作为存储引擎的性能测试报告，在一个普通配置的机器上，2.68w IOPS，4核8G机器上，能够支持大约每秒900+分布式事务，能够满足大部分公司的业务需求。 此次带来的是Redis存储引擎的测试报告，在一个普通配置的机器上，能够达到大约10800每秒的分布式事务能力，对比Mysql存储，有10倍左右的性能提升，满足绝大部分公司的业务需求。 下面我们来详细说明测试的步骤，并分析其中影影响性能的各个因素。 测试环境 下面的服务器都来自阿里云，地区为东京（外网访问比.
dtm-demo:dtm的demo集合：包括dtm原生demo，dubbo框架的dtm演示，servicecomb框架的dtm演示，springcloud华为框架的dtm演示
03-16
介绍 dtm演示，包括dtm起源，dtm-servicecomb，dtm-springcloud-hw dtm来源 dtm来源演示，包括无创交易和TCC交易 dtm-servicecomb 基于ServiceComb的dtm演示，包括无创交易 dtm-springcloud-hw 基于springcloud-huawei的dtm演示，包括无创交易 dtm-dubbo-servicecomb（正在更新） 基于Dubbo的dtm演示，包括无创交易
dtm分布式事务
走向CTO的路上...
05-16 675
相对于传统的数据库事务，DTM提供了更强大和灵活的分布式事务管理能力。分布式事务支持：DTM提供了对分布式事务的全面支持。DTM（Distributed Transaction Manager）是一种分布式事务管理器，用于处理跨多个服务的分布式事务。范围：传统的数据库事务是在单个数据库内进行的，而DTM可以跨多个服务进行事务操作。多数据库支持：DTM可以支持不同类型的数据库，甚至可以支持不同的数据库引擎。异步补偿：DTM还支持异步补偿机制，可以在事务失败或异常的情况下执行事务的回滚或补偿操作。
【学习笔记】DTM分布式事务
Left_Zzzz的博客
10-13 656
分布式事务是什么 **本文的分布式事务指的是DTM下的分布式事务。** 分布式事务有两类，这里指的是跨数据库、跨服务的分布式事务。 分布式事务指事务的发起者、资源及资源管理器和事务协调者分别位于分布式系统的不同节点之上。
php 分布式事务 DTM (TCC模式和Saga模式的区别)
Kobe__Bryant__的博客
10-18 1194
分布式事务 DTM (TCC和Saga的区别)
基于PLC的校园智能照明系统的控制与实现.pdf
09-06
在软件设计方面，该系统采用西门子公司开发的STEP７ＧMicro/WIN V４０编程软件进行相关程序编程。STEP７ＧMicro/WIN V４０不仅为用户开发控制程序，而且也在实时监控用户程序的执行状态。用户所需程序的生成主要是...
分布式事务框架 DTM 对比 SEATA
qq798280904的博客
04-15 725
分布式系统最大的敌人可能就是NPC了，在这里它是Network Delay, Process Pause, Clock Drift的首字母缩写。我们先看看具体的NPC问题是什么：Network Delay，网络延迟。虽然网络在多数情况下工作的还可以，虽然TCP保证传输顺序和不会丢失，但它无法消除网络延迟问题。Process Pause，进程暂停。有很多种原因可以导致进程暂停：比如编程语言中的GC（垃圾回收机制）会暂停所有正在运行的线程；
分布式事务 | 使用DTM 的Saga 模式
dotNET跨平台
02-10 413
❝分布式事务系列文章分布式事务| 使用 dotnetcore/CAP 的本地消息表模式分布式事务 | 基于MassTransit的StateMachine实现Saga编排式分布式事务分布式事务 | 基于MassTransit Courier 实现 Saga 编排式分布式事务DTM 简介前面章节提及的MassTransit、dotnetcore/CAP都提供了分布式事务的处理能力，但也仅局限于S...
go-zero学习 第六章 分布式事务dtm
Mr_XiMu的博客
07-25 867
go-zero学习 第六章 分布式事务dtm
学习笔记：带你十天轻松完成 Go 微服务系列大结局（十）- 分布式事务
皮埃尔的博客
03-18 638
学习笔记：带你十天轻松搞定 Go 微服务系列大结局（十）- 分布式事务
那些用Go实现的分布式事务框架之DTM
kevin_tech的博客，微信搜「网管叨bi叨」
12-22 3405
图片拍摄于2021年12月04日 山东青岛 我爱这座城市开篇上一篇那些用Go实现的分布式事务框架我们主要介绍的是seata-golang。一个对标seata的go语言实现，当然版本还是落后...
实现分布式追踪系统Jaeger 从php API Gateway 到go-micro微服务
zhanglu0302的博客
03-04 1680
分布式调用链跟踪系统，属于监控系统的一类。系统架构逐步演进时，后期形态往往是一个平台由很多不同的服务、组件构成，用户请求过来后，可能会经过其中多个服务。 不过，出问题时往往很难排查，如整个请求变慢、偶尔报错、不可用等，我们很难得知具体是由哪一个或哪些服务引起的，通常开发同学都会互相甩锅，最后不得不花大量时间人肉 tracing Jaeger是Uber Technologies用GO语言开发的分布式...
Go开源说第十七期 分布式事务DTM
Go中国
10-09 5309
大家好，很高兴到“Go开源说”跟大家分享DTM，我是叶东富，DTM作者，github：https://github.com/yedf内容提纲本次分享分为以下四个部分：DTM是什么产生的背景...
DTM分布式事务
最新发布
qq_45366447的博客
01-08 1099
DTM，Distributed Transaction Manager， 其是一个分布式事务管理器，解决跨数据库、跨服务、跨语言更新数据的一致性问题。 ​ DTM提供了Saga、TCC、XA和二阶段消息模式以满足不同应用场景的需求，同时首创的**子事务屏障**技术有效解决`幂等`、`悬挂`和`空补偿`等异常问题。 ​ DTM的优点： - 提供简单易用的接口，拆分具体业务接入分布式事务 - 支持多语言栈 - 核心技术**子事务屏蔽**，降低处理子事务乱的难度
dtm分布式事务框架之SAGA 实战
lisus2007的专栏
12-07 1327
dtm分布式事务框架之SAGA
分布式事务【SAGA事务模式】
sleep的博客
05-27 1106
SAGA事务模式是DTM中最常用的模式，主要是因为SAGA模式简单易用，工作量少，并且能够解决绝大部分业务的需求。dtm 的SAGA模式与Seata的SAGA在设计理念上是不一样的，整体使用难度大幅度降低，非常容易上手SAGA最初出现在1987年Hector Garcaa-Molrna & Kenneth Sale...
gRPC 的错误处理
qq_46457076的博客
02-15 2162
关于 gRPC 的错误处理介绍！
go-micro介绍及环境搭建和使用
wang11876的博客
07-08 2153
Micro是一个简化分布式开发的微服务生态系统，该系统为开发分布式应用程序提供了高效，便捷的模块构建。主要目的是简化分布式系统的开发。学习完该框架以后，可以方便开发者们非常简单的开发出微服务架构的项目，并且随着业务模块的增加和功能的增加，Micro还能够提供管理微服务环境的工具和功能。启用API作为一个网关或代理，来作为微服务访问的单一入口。它应该在您的基础架构的边缘运行。它将HTTP请求转换为RPC并转发给相应的服务。
.NetCore中使用分布式事务DTM的二阶段消息
dotNET跨平台
04-06 324
一、概述二阶段消息是DTM新提出的，可以完美代替现有的事务消息和本地消息表架构。无论从复杂度、性能、便利性还是代码量都是完胜现有的方案。相比现有的消息架构借助于各种消息中间件比如RocketMQ等，DTM自己实现了无需额外的学习成本。它能够保证本地事务的提交和全局事务提交是“原子的”，适合解决不需要回滚的分布式事务场景。二阶段消息保证提交的原子性和如何保证业务成功执行如下时序图：二阶段消息主要是...
gRPC 一揽子方案
gsdgsdfs的博客
06-17 4204
gRPC 一揽子方案

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值