go并发之美·redis篇·接口幂等性设计实现

旧城等待， 2022-12-12 04:51 149阅读 0赞

**当你凝视深渊的时候，深渊也在凝视你。**

**go并发之美·干货好文合集：**

[go并发之美·redis篇·接口幂等性设计实现][go_redis]

[go并发之美·redis篇·实现实时排行榜][go_redis 1]

[go并发日记·多goroutine并发安全的操作共享变量][go_goroutine]

[go并发日记·常用并发场景中的并发控制思路与方案][go]

[go并发日记·避免goroutine泄漏/实现协程可控][go_goroutine 1]

[go并发日记·深入理解go语言channel与goroutine阻塞][go_go_channel_goroutine]

[go并发日记·基于channel优雅的进行并发控制][go_channel]

[go并发日记·WaitGroup并发控制探索及实际场景运用][go_WaitGroup]

[channel死锁的情况分析][channel]

[go并发之美·B操作伴随A操作(B和A同步)][go_B_A_B_A]

[go多函数并发通用工具的设计与实现][go 1]

简单说下幂等性背景：

1，支付页面有个支付按钮，用户本次订单是10元，点了支付后发现没反应，连续又点了3次有了反应(有反应不是因为需要点多次)，最后网络等因素干扰解除后支付完毕时发现支付了40元。

2，领奖页面，某某通过postman等工具频繁发起请求领奖尝试一次领多个奖励，如一次连续发送1000个请求给某个账号领取，实际上每个人只允许领一次。

在基于鉴权通过的情况下，我们要做的就是不论是什么手段发来的请求，只操作第一个有效请求，其它重复的操作不能让他进来，或不能走下面的流程，同一个人相同的操作只有第一次操作完了(第一次支付完了)，用户再次主观支付(认为用户第二次正常购买该产品)才是正常的，即接下来我才对待你的第二个请求。

一个订单支付三次都成功了跟下三次该产品的订单支付三次成功完全是两回事，幂等性要解决的问题就是前者，不让同一个人要做相同的操作重复提交数据，避免损失或数据不准确。

前端可以通过控制按钮等可视化操作来阻止用户多次重复操作，这里我们暂不论前端是否是什么措施。来模拟下请求进入后台并进行处理，保证同样的请求只处理第一个，把其他的挡在门外。

方案：第一个支付请求携带了数据：用户ID，订单ID，订单金额进行支付操作，在支付期间其他多次请求也想尝试支付该用户的该订单，这时候这些请求需要将用户ID、订单ID共同作key先去获取分布式锁，本次请求成功后自动释放该锁，订单状态改为已支付。

来实现下：

type Order struct {
    	ID     int     // 订单ID
    	State  string  // 订单状态
    	UserID int     // 谁的订单
    	Price  float64 // 订单金额
    }
    
    type OperateKey struct {
    	UserID  int `json:"user_id"`
    	OrderID int `json:"order_id"`
    }
    
    var orderM map[OperateKey]Order
    var orderMap sync.Map
    
    func InitOrder() {
    	orderM = make(map[OperateKey]Order)
    	userID := 1234567
    	orderList := []Order{
       {
    		ID:     101,
    		State:  "待支付",
    		UserID: userID,
    		Price:  99.5,
    	}, {
    		ID:     100,
    		State:  "待支付",
    		UserID: userID,
    		Price:  66,
    	}}
    	for _, order := range orderList {
    		key := OperateKey{UserID: order.UserID, OrderID: order.ID}
    		orderMap.Store(key,order)
    		orderM[key] = order
    	}
    }
    
    var jsonStr = `
    {"user_id":%v,"order_id":%v}
    `
    
    func ExecPay(signCh, complete chan struct{}) {
    	key := fmt.Sprintf(jsonStr, 1234567, 101)
    	value := "A"
    	defer func() {
    		fmt.Println("[ExecPay-", value, "]结束。")
    	}()
    	err, _ := GetLock("[ExecPay-"+value+"]", key)
    	if err != nil && err.Error() == "redis: nil" {
    		// 目前没有人持有锁,开始枷锁
    		err, flag := Lock("ExecPay-"+value, key, value)
    		if err != nil {
    			fmt.Println(fmt.Printf("[ExecPay]设置锁value=%v失败, error: %v", value, err))
    			complete <- struct{}{}
    			close(signCh)
    			return
    		}
    		fmt.Println(fmt.Printf("[ExecPay-%v]设置锁value=%v成功,flag=%v。", value, value, flag))
    		close(signCh) // ExecPay函数枷锁后再让后面的多个重复性请求开始请求
    		k := OperateKey{UserID: 1234567, OrderID: 101}
    		order := orderM[k]
    		if pay(k.OrderID, order.Price) {
    			order.State = "已支付"
    			if data, ok := orderMap.Load(key); ok {
    				obj := data.(Order)
    				obj = order
    				orderMap.Store(key, obj)
    			}
    			fmt.Println("支付操作完成。")
    		}
    		UnLock(key, value)
    		complete <- struct{}{}
    		return
    	} else if err != nil {
    		return
    	}
    }
    
    // 其他手段，一直发请求支付
    func ExecPayExtra(value string, signCh, completeCh chan struct{}) {
    	complete := false
    	for !complete {
    		select {
    		case <-signCh:
    			/* A支付完这个订单并将状态置为已支付后，即使B、C甚至其他都想尝试支付这个订单即使成功获取了分布式锁已经没有意义了
    			k := OperateKey{UserID: 1234567, OrderID: 101}
    			if order, ok := orderMap.Load(k); ok&& order.(Order).State == "已支付" {
    				fmt.Println("ExecPayExtra-",value,":不尝试了.")
    				complete = true
    			}*/
    			key := fmt.Sprintf(jsonStr, 1234567, 101)
    			// 拿出用户第一个订单进行支付,将key设置为value
    			err, _ := GetLock("[ExecPayExtra-]"+value, key)
    			if err != nil && err.Error() == "redis: nil" {
    				err, flag := Lock("ExecPayExtra-"+value, key, value)
    				if err != nil {
    					fmt.Println(fmt.Printf("[ExecPayExtra-%v]设置锁value=%v失败, error: %v", value, value, err))
    					return
    				}
    				fmt.Println(fmt.Printf("[ExecPayExtra-%v]设置锁value=%v成功,flag=%v。", value, value, flag))
    				//pay()
    			} else if err != nil {
    				return
    			}
    			fmt.Println("[ExecPayExtra-", value, "]:锁已被持有,这个订单不能支付了,撤吧...")
    			completeCh <- struct{}{}
    			complete = true
    		}
    	}
    	fmt.Println("[ExecPayExtra-", value, "]结束。")
    	return
    }
    
    func pay(orderID int, price float64) bool {
    	time.Sleep(time.Second * 3)
    	fmt.Println("订单[", orderID, "]支付成功,支付了", price, "元。")
    	return true
    }
    
    func GetLock(fun, key string) (error, string) {
    	ret := utils.Rdb.Get(context.TODO(), key)
    	if err := ret.Err(); err != nil {
    		fmt.Println("[GetLock]-", fun, "获取锁失败: ", err)
    		return err, ""
    	}
    	rt, _ := ret.Bytes()
    	return nil, string(rt)
    }
    
    func Lock(fun, key, value string) (error, bool) {
    	res := utils.Rdb.SetNX(context.TODO(), key, value, time.Second*20)
    	if err := res.Err(); err != nil {
    		fmt.Println(fmt.Printf("[Lock]-%v设置锁value=%v失败: %v", fun, value, err))
    		return err, false
    	}
    	return nil, res.Val()
    }
    
    func UnLock(key, value string) bool {
    	res := utils.Rdb.Del(context.TODO(), key)
    	if err := res.Err(); err != nil {
    		fmt.Println("[UnLock]释放锁失败: ", err)
    		return false
    	}
    	fmt.Println("[UnLock]释放锁成功：", value)
    	return true
    }
    
    func TestRedisLock(t *testing.T) {
    	utils.InitClient()
    	InitOrder()
    	signCh, completeCh := make(chan struct{}), make(chan struct{})
    	go ExecPay(signCh, completeCh)
    	go ExecPayExtra("B", signCh, completeCh) // A已经在支付了，B想试试，那试一下？
    	go ExecPayExtra("C", signCh, completeCh) // A已经在支付了，C想试试，那试一下？
    	<-completeCh
    	<-completeCh
    	<-completeCh
    	close(completeCh)
    	// B、C都进行尝试后抢不到支付权 & A支付完毕后， 程序结束。
    }

（注意，代码中的A、B意思是指第二次第三次支付，或者说和第一次一样对相同的目标进行相同的操作）

speed running：

=== RUN   TestRedisLock
    [GetLock]- [ExecPay-A] 获取锁失败:  redis: nil
    [ExecPay-A]设置锁value=A成功,flag=true。46 <nil>
    [ExecPayExtra- C ]:锁已被持有,这个订单不能支付了,撤吧...
    [ExecPayExtra- C ]结束。
    [ExecPayExtra- B ]:锁已被持有,这个订单不能支付了,撤吧...
    [ExecPayExtra- B ]结束。
    订单[ 101 ]支付成功,支付了 99.5 元。
    支付操作完成。
    [UnLock]释放锁成功： A
    [ExecPay- A ]结束。
    --- PASS: TestRedisLock (3.33s)
    PASS

验证ok，over。

个人原创，如有发现不对的地方敬请指出，感谢阅读，有缘再会~

[go_redis]: https://lan6193.blog.csdn.net/article/details/108938119
[go_redis 1]: https://lan6193.blog.csdn.net/article/details/108931188
[go_goroutine]: https://lan6193.blog.csdn.net/article/details/105715373
[go]: https://lan6193.blog.csdn.net/article/details/108670428
[go_goroutine 1]: https://lan6193.blog.csdn.net/article/details/105559568
[go_go_channel_goroutine]: https://lan6193.blog.csdn.net/article/details/97528721
[go_channel]: https://lan6193.blog.csdn.net/article/details/101201408
[go_WaitGroup]: https://lan6193.blog.csdn.net/article/details/100887891
[channel]: https://lan6193.blog.csdn.net/article/details/97656420
[go_B_A_B_A]: https://lan6193.blog.csdn.net/article/details/108901339
[go 1]: https://lan6193.blog.csdn.net/article/details/103298105