计费服务一般都是跟资金相关,所以它在系统中是非常核心的模块,要保证服务的高可用、事务一致性、高性能。服务高可用需要集群部署,要保证事务一致性可以通过数据库来实现,但是只通过数据库却很难实现高性能的系统。
这篇文章通过使用 redis+消息队列+数据库 实现一套高性能的计费服务,接口请求扣费分为两步: 首先 使用redis扣减用户余额,扣费成功后将数据发送到消息队列,整个扣费的第一步就完成了,这时就可以返回成功给调用端; 第二步 数据持久化,由另外一个服务订阅消息队列,批量消费队列中的消息实现数据库持久化。
上面两个步骤完成后,整个扣费过程就结束了,这里最主要的就是扣费的第一步,业务流程图如下:
扣费流程图
通过上面的流程图可以知道,整个扣费的第一步主要分为两部分:redis扣费+kafka消费;单独使用redis扣费可以通过lua脚本实现事务,kafka消息队列也可以实现事务,但是如何将这两步操作实现事务就要通过编程来保障。
实现上面的处理流程打算使用一个demo项目来演示。项目使用 SpringBoot+redis+kafka+MySQL 的架构。

首先在MySQL数据库创建用到的几个表:

-- 用户信息
CREATE TABLE `t_user`  (
  `id` int NOT NULL AUTO_INCREMENT,
  `user_name` varchar(128) DEFAULT NULL,
  `create_time` datetime NULL DEFAULT NULL,
  `modify_time` datetime NULL DEFAULT NULL,
  `api_open` tinyint NULL DEFAULT 0,
  `deduct_type` varchar(16) DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE INDEX `user_name`(`user_name` ASC) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

-- 账户信息
CREATE TABLE `t_account`  (
  `user_id` int NOT NULL,
  `balance` decimal(20, 2) NULL DEFAULT NULL,
  `modify_time` datetime NULL DEFAULT NULL,
  `create_time` datetime NULL DEFAULT NULL,
  `version` bigint NULL DEFAULT 1,
  `threshold` decimal(20, 2) NULL DEFAULT NULL,
  PRIMARY KEY (`user_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = DYNAMIC;

-- 订单信息
CREATE TABLE `t_order`  (
  `id` bigint NOT NULL,
  `user_id` int NULL DEFAULT NULL,
  `amount` decimal(20, 2) NULL DEFAULT NULL,
  `balance` decimal(20, 2) NULL DEFAULT NULL,
  `modify_time` datetime NULL DEFAULT NULL,
  `create_time` datetime NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = DYNAMIC;

-- 支付信息
CREATE TABLE `t_pay`  (
  `id` bigint NOT NULL,
  `user_id` int NULL DEFAULT NULL,
  `pay` decimal(20, 2) NULL DEFAULT NULL,
  `create_time` datetime NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

用户信息表 t_user 有两个字段需要说明:
api_open 表示用户接口是否开启,如果用户账号余额不足可以把该字段设置为false拦截扣费请求;
deduct_type 这个字段表示扣费方式,ASYNC表示异步扣费,先通过redis扣减余额再异步扣减数据库,SYNC表示同步扣费,直接扣减数据库。

账户余额表 t_account 中也要说明两个字段:
version 表示余额扣减的版本号,这个版本号只能递增,每更新一次数据库版本号就增加1,在异步扣费时,可以比较redis中数据和db中数据的差异,正常来说redis中的版本号要大于等于db中的版本号;
threshold 是余额的一个阈值,由于redis中数据和db数据的差异,当异步扣费时redis中的余额小于该值时,避免有可能存在的超扣情况,要对用户的请求限流。

第一步在redis中扣减客户的余额时,需要处理三个数据:
(1)判断客户余额信息是否存在,如果存在并且余额充足,则扣减客户余额;
(2)生成订单信息缓存,由于数据库的订单和redis扣费订单存在时间差,这里的订单信息可以用于查询订单数据;redis如果发生主从切换,订单信息也可以用于判断该订单是否要重新加载历史数据;
(3)添加订单一致性集合数据,当kafka消息被消费后会把订单ID在这个集合中删除,它主要有两个用途:订单已经在redis中扣费但是由于某些原因没能在kafka中消费到,可以通过补偿逻辑将该订单入库;也可以通过这个集合中的订单条数判断redis处理数据与db处理数据的差异;

正常流程这三步的lua脚本:

local rs 
if redis.call('exists', KEYS[1]) > 0 then 
  local vals = redis.call('hmget', KEYS[1], 'balance', 'threshold', 'v') 
  local balance = tonumber(vals[1]) 
  local threshold = tonumber(vals[2]) 
  local v0 = tonumber(vals[3]) 
  if balance >= tonumber(ARGV[1]) and (balance - ARGV[1]) >= threshold then 
    local b = redis.call('hincrby', KEYS[1], 'balance', 0 - ARGV[1]) 
    redis.call('hset', KEYS[1], 'ts', ARGV[2]) 
    redis.call('set', KEYS[2], ARGV[1] .. ';' .. ARGV[2] .. ';' .. b, 'EX', 604800) 
    redis.call('zadd', KEYS[3], ARGV[2], ARGV[3]) 
    local v = redis.call('hincrby', KEYS[1], 'v', 1) 
    rs = 'ok;' .. b .. ';' .. v 
  else 
    rs = 'fail;' .. balance .. ';' .. v0 
  end 
else 
  rs = 'null' 
end 
return rs

最初redis中是不存在数据的,需要将db数据加载到redis中:

if redis.call('exists', KEYS[1]) > 0 then 
  redis.call('hget', KEYS[1], 'balance') 
else 
  redis.call('hmset', KEYS[1], 'balance', ARGV[1], 'v', ARGV[2], 'threshold', ARGV[3]) 
end 
return 'ok'

当redis扣费成功而后面操作出现异常时需要回滚redis的扣费:

local rs 
if redis.call('exists', KEYS[1]) > 0 then 
  local v = tonumber(redis.call('hget', KEYS[1], 'v')) 
  if v >= tonumber(ARGV[2]) then 
    rs = redis.call('hincrby', KEYS[1], 'balance', ARGV[1]) 
    redis.call('hincrby', KEYS[1], 'v', 1) 
    redis.call('del', KEYS[2]) 
    redis.call('zrem', KEYS[3], ARGV[3]) 
  else 
    rs = 'fail' 
  end 
else 
  rs = 'null' 
end 
return rs

上面的lua脚本涉及到多个键操作,要保证在集群模式下命令正确执行,要让所有的键落在一个hash槽,所以在键的设计时要保证计算hash的部分相同,使用用户ID包裹在{}内就能达到目的,所有涉及到的键封装成一个工具类:

/**
 * @Author xingo
 * @Date 2024/9/10
 */
public class RedisKeyUtils {

    /**
     * 用户余额键
     * @param userId    用户ID
     * @return
     */
    public static String userBalanceKey(int userId) {
        return ("user:balance:{" + userId + "}").intern();
    }

    /**
     * 用户订单键
     * @param userId    用户ID
     * @param orderId   订单ID
     * @return
     */
    public static String userOrderKey(int userId, long orderId) {
        return ("user:order:{" + userId + "}:" + orderId).intern();
    }

    /**
     * 保存用户订单一致性的订单集合
     * 保存可能已经在redis中但不在数据库中的订单ID集合
     * @param userId    用户ID
     * @return
     */
    public static String userOrderZsetKey(int userId) {
        return ("user:order:consistency:{" + userId + "}").intern();
    }

    /**
     * 用户分布式锁键
     * @param userId
     * @return
     */
    public static String userLockKey(int userId) {
        return ("user:lock:" + userId).intern();
    }
}

使用springboot开发还需要将lua脚本封装成工具类:

import org.springframework.data.redis.core.script.DefaultRedisScript;

/**
 * lua脚本工具类
 *
 * @Author xingo
 * @Date 2024/9/10
 */
public class LuaScriptUtils {

    /**
     * redis数据分隔符
     */
    public static final String SEPARATOR = ";";

    /**
     * 异步扣费lua脚本
     * 键1:用户余额键,hash结构
     * 键2:用户订单键,string结构
     * 参数1:扣减的金额,单位是分;
     * 参数2:扣减余额的时间戳
     */
    public static final String ASYNC_DEDUCT_BALANCE_STR =
            "local rs " +
            "if redis.call('exists', KEYS[1]) > 0 then " +
            "  local vals = redis.call('hmget', KEYS[1], 'balance', 'threshold', 'v') " +
            "  local balance = tonumber(vals[1]) " +
            "  local threshold = tonumber(vals[2]) " +
            "  local v0 = tonumber(vals[3]) " +
            "  if balance >= tonumber(ARGV[1]) and (balance - ARGV[1]) >= threshold then " +
            "    local b = redis.call('hincrby', KEYS[1], 'balance', 0 - ARGV[1]) " +
            "    redis.call('hset', KEYS[1], 'ts', ARGV[2]) " +
            "    redis.call('set', KEYS[2], ARGV[1] .. '" + SEPARATOR + "' .. ARGV[2] .. '" + SEPARATOR + "' .. b, 'EX', 604800) " +
            "    redis.call('zadd', KEYS[3], ARGV[2], ARGV[3]) " +
            "    local v = redis.call('hincrby', KEYS[1], 'v', 1) " +
            "    rs = 'ok" + SEPARATOR + "' .. b .. '" + SEPARATOR + "' .. v " +
            "  else " +
            "    rs = 'fail" + SEPARATOR + "' .. balance .. '" + SEPARATOR + "' .. v0 " +
            "  end " +
            "else " +
            "  rs = 'null' " +
            "end " +
            "return rs";

    /**
     * 同步余额数据lua脚本
     * 键:用户余额键,hash结构
     * 参数1:扣减的金额,单位是分
     * 参数2:扣减余额的时间戳
     * 参数3:余额的阈值,单位是分
     */
    public static final String SYNC_BALANCE_STR =
            "if redis.call('exists', KEYS[1]) > 0 then " +
            "  redis.call('hget', KEYS[1], 'balance') " +
            "else " +
            "  redis.call('hmset', KEYS[1], 'balance', ARGV[1], 'v', ARGV[2], 'threshold', ARGV[3]) " +
            "end " +
            "return 'ok'";

    /**
     * 回滚扣款lua脚本
     * 键1:用户余额键,hash结构
     * 键2:用户订单键,string结构
     * 参数1:回滚的金额,单位是分
     * 参数2:扣款时对应的版本号
     */
    public static final String ROLLBACK_DEDUCT_STR =
            "local rs " +
            "if redis.call('exists', KEYS[1]) > 0 then " +
            "  local v = tonumber(redis.call('hget', KEYS[1], 'v')) " +
            "  if v >= tonumber(ARGV[2]) then " +
            "    rs = redis.call('hincrby', KEYS[1], 'balance', ARGV[1]) " +
            "    redis.call('hincrby', KEYS[1], 'v', 1) " +
            "    redis.call('del', KEYS[2]) " +
            "    redis.call('zrem', KEYS[3], ARGV[3]) " +
            "  else " +
            "    rs = 'fail' " +
            "  end " +
            "else " +
            "  rs = 'null' " +
            "end " +
            "return rs";

    public static final DefaultRedisScript<String> ASYNC_DEDUCT_SCRIPT = new DefaultRedisScript<>(LuaScriptUtils.ASYNC_DEDUCT_BALANCE_STR, String.class);

    public static final DefaultRedisScript<String> SYNC_BALANCE_SCRIPT = new DefaultRedisScript<>(LuaScriptUtils.SYNC_BALANCE_STR, String.class);

    public static final DefaultRedisScript<String> ROLLBACK_DEDUCT_SCRIPT = new DefaultRedisScript<>(LuaScriptUtils.ROLLBACK_DEDUCT_STR, String.class);
}

所有基础组件都已经准备好了,接下来就是编写义务代码:

处理请求接口:

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.xingo.domain.ApiResult;
import org.xingo.front.service.DeductService;

import java.math.BigDecimal;

/**
 * @Author xingo
 * @Date 2024/9/9
 */
@Slf4j
@RestController
public class DeductController {

    @Autowired
    private DeductService deductService;

    /**
     * 异步扣减余额
     * @param userId    用户ID
     * @param amount    扣减金额
     * @return
     */
    @GetMapping("/async/dudect")
    public ApiResult asyncDeduct(int userId, BigDecimal amount) {
        return deductService.asyncDeduct(userId, amount);
    }

}

扣费处理服务:

import org.xingo.domain.ApiResult;

import java.math.BigDecimal;

/**
 * @Author xingo
 * @Date 2024/9/13
 */
public interface DeductService {

    /**
     * 异步扣减余额
     * @param userId
     * @param amount
     * @return
     */
    ApiResult asyncDeduct(int userId, BigDecimal amount);
}
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.xingo.domain.ApiResult;
import org.xingo.domain.DeductResult;
import org.xingo.entity.UserData;
import org.xingo.enums.DeductType;
import org.xingo.front.config.CacheUtils;
import org.xingo.front.service.DeductService;
import org.xingo.front.service.OrderService;

import java.math.BigDecimal;

/**
 * @Author xingo
 * @Date 2024/9/13
 */
@Slf4j
@Service
public class DeductServiceImpl implements DeductService {

    @Autowired
    private OrderService orderService;
    @Autowired
    private CacheUtils cacheUtils;

    @Override
    public ApiResult asyncDeduct(int userId, BigDecimal amount) {
        ApiResult result = null;
        UserData user = cacheUtils.getUserData(userId);
        if(user != null && user.isApiOpen()) {
            amount = amount.abs();
            if(user.getDeductType() == DeductType.ASYNC) {
                DeductResult rs = orderService.asyncDeductOrder(userId, amount);
                if(StringUtils.isNotBlank(rs.getMessage()) && "null".equals(rs.getMessage())) {
                    BigDecimal rsBalance = orderService.syncBalanceToRedis(userId);
                    if(rsBalance != null) {
                        return this.asyncDeduct(userId, amount);
                    } else {
                        result = ApiResult.fail("同步余额失败");
                    }
                } else {
                    result = ApiResult.success(rs);
                }
            } else {
                DeductResult rs = orderService.syncDeductOrder(userId, amount);
                return StringUtils.isBlank(rs.getMessage()) ? ApiResult.success(rs) : ApiResult.fail(rs.getMessage());
            }
        } else {
            result = ApiResult.fail("用户接口未开启");
        }
        return result;
    }
}

订单扣减服务

import org.xingo.domain.DeductResult;

import java.math.BigDecimal;

/**
 * @Author xingo
 * @Date 2024/9/9
 */
public interface OrderService {

    /**
     * 同步扣减订单
     * @param userId
     * @param amount
     * @return
     */
    DeductResult syncDeductOrder(Integer userId, BigDecimal amount);

    /**
     * 同步余额数据到redis
     * @param userId
     * @return
     */
    BigDecimal syncBalanceToRedis(Integer userId);


    /**
     * 同步扣减订单
     * @param userId
     * @param amount
     * @return
     */
    DeductResult asyncDeductOrder(Integer userId, BigDecimal amount);
}
import cn.hutool.core.util.IdUtil;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.xingo.common.ConstantVal;
import org.xingo.common.JacksonUtils;
import org.xingo.common.RedisKeyUtils;
import org.xingo.domain.DeductResult;
import org.xingo.entity.AccountData;
import org.xingo.entity.OrderData;
import org.xingo.front.mapper.AccountMapper;
import org.xingo.front.mapper.OrderMapper;
import org.xingo.front.service.OrderService;
import org.xingo.front.service.UserService;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @Author xingo
 * @Date 2024/9/9
 */
@Slf4j
@Service
public class OrderServiceImpl implements OrderService {

    /**
     * 100倍
     */
    BigDecimal ONE_HUNDRED = BigDecimal.valueOf(100);

    Logger deductLogger = LoggerFactory.getLogger("deduct");

    @Autowired
    private AccountMapper accountMapper;
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;
    @Autowired
    private RedissonClient redissonClient;
    @Autowired
    private UserService userService;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public DeductResult syncDeductOrder(Integer userId, BigDecimal amount) {
        String lockKey = RedisKeyUtils.userLockKey(userId);
        RLock rlock = redissonClient.getLock(lockKey);
        try {
            boolean tryLock = rlock.tryLock(5, 5, TimeUnit.SECONDS);
            if(tryLock) {
                // 扣减账号余额
                boolean rs = accountMapper.deductBalanceByUserId(userId, amount);
                if(rs) {    // 扣减余额成功
                    // 查找余额
                    AccountData account = accountMapper.selectById(userId);
                    if(account.getBalance().compareTo(BigDecimal.ZERO) <= 0) {
                        userService.closeUserApi(userId);
                    }
                    // 增加订单
                    long id = IdUtil.getSnowflake(1, 1).nextId();
                    OrderData orderData = OrderData.builder()
                            .id(id)
                            .userId(userId)
                            .amount(amount)
                            .balance(account.getBalance())
                            .modifyTime(LocalDateTime.now())
                            .createTime(LocalDateTime.now())
                            .build();
                    orderMapper.insert(orderData);
                    log.info("同步扣减账号余额|{}|{}|{}|{}", userId, amount, account.getBalance(), id);
                    // 实时同步余额到redis
                    String key = RedisKeyUtils.userBalanceKey(userId);
                    String key1 = RedisKeyUtils.userOrderKey(userId, id);
                    List<String> keys = Arrays.asList(key, key1);
                    String execute = redisTemplate.execute(LuaScriptUtils.DB_DEDUCT_SCRIPT, keys,
                            amount.multiply(ONE_HUNDRED).intValue() + "", System.currentTimeMillis() + "");
                    if(execute.startsWith("ok")) {
                        String[] arr = execute.split(";");
                        int redisVersion = Integer.parseInt(arr[2]);
                        if(redisVersion < account.getVersion()) {
                            redisTemplate.delete(key);
                            log.info("缓存数据版本低于数据库|{}|{}|{}|{}|{}", userId, redisVersion, account.getVersion(), arr[1], account.getBalance());
                        }
                    }

                    log.info("同步扣减数据到缓存|{}|{}|{}|{}", userId, amount, account.getBalance(), execute);
                    return DeductResult.builder()
                            .id(id)
                            .userId(userId)
                            .amount(amount)
                            .balance(account.getBalance())
                            .build();
                }
            }
        } catch (InterruptedException e) {
            log.error("获取redisson锁异常", e);
            throw new RuntimeException(e);
        } finally {
            if(rlock.isHeldByCurrentThread()) {
                rlock.unlock();
            }
        }
        return DeductResult.builder().message("扣费失败").build();
    }

    @Override
    public BigDecimal syncBalanceToRedis(Integer userId) {
        String lockKey = RedisKeyUtils.userLockKey(userId);
        RLock rlock = redissonClient.getLock(lockKey);
        try {
            boolean tryLock = rlock.tryLock(5, 5, TimeUnit.SECONDS);
            if(tryLock) {
                AccountData balance = accountMapper.selectById(userId);
                if(balance != null && balance.getBalance().compareTo(BigDecimal.ZERO) > 0) {
                    String key = RedisKeyUtils.userBalanceKey(userId);
                    List<String> keys = Collections.singletonList(key);
                    try {
                        String execute = redisTemplate.execute(LuaScriptUtils.SYNC_BALANCE_SCRIPT, keys,
                                balance.getBalance().multiply(ONE_HUNDRED).intValue() + "",
                                balance.getVersion().toString(),
                                balance.getThreshold().multiply(ONE_HUNDRED).intValue() + "");
                        log.info("同步账号余额到缓存|{}|{}|{}|{}|{}", userId, balance.getBalance(), balance.getVersion(), balance.getThreshold(), execute);
                        return balance.getBalance();
                    } catch (Exception e) {
                        e.printStackTrace();
                        return null;
                    }
                }
            }
        } catch (InterruptedException e) {
            log.error("获取redisson锁异常", e);
            throw new RuntimeException(e);
        } finally {
            if(rlock.isHeldByCurrentThread()) {
                rlock.unlock();
            }
        }
        return null;
    }

    @Override
    public DeductResult asyncDeductOrder(Integer userId, BigDecimal amount) {
        long id = IdUtil.getSnowflake(1, 1).nextId();
        String key = RedisKeyUtils.userBalanceKey(userId);
        String key1 = RedisKeyUtils.userOrderKey(userId, id);
        String key2 = RedisKeyUtils.userOrderZsetKey(userId);
        List<String> keys = Arrays.asList(key, key1, key2);

        try {
            long ts = System.currentTimeMillis();
            int fee = amount.multiply(ONE_HUNDRED).intValue();
            String execute = redisTemplate.execute(LuaScriptUtils.ASYNC_DEDUCT_SCRIPT, keys,
                    fee + "", ts + "", id + "");
            log.info("异步扣减缓存余额|{}|{}|{}", userId, amount, execute);
            if(execute.startsWith("ok")) {      // 扣费成功
                return this.deductSuccess(keys, id, userId, amount, ts, execute);
            } else {    // 扣费失败
                return DeductResult.builder().message(execute).build();
            }
        } catch (Exception e) {
            log.error("扣费异常", e);
            // 扣费失败
            return DeductResult.builder().message("fail").build();
        }
    }

    /**
     * 扣费成功处理逻辑
     * @param keys
     * @param userId
     * @param amount
     * @param execute
     * @return
     * @throws Exception
     */
    private DeductResult deductSuccess(List<String> keys, long id, Integer userId, BigDecimal amount, long ts, String execute) throws Exception {
        String[] arr = execute.split(";");
        BigDecimal balance = new BigDecimal(arr[1]).divide(ONE_HUNDRED, 2, RoundingMode.HALF_UP);
        if(balance.compareTo(BigDecimal.ZERO) <= 0) {
            userService.closeUserApi(userId);
        }
        String version = arr[2];
        // 扣费成功发送kafka消息
        DeductResult deductResult = DeductResult.builder()
                .id(id)
                .userId(userId)
                .balance(balance)
                .amount(amount)
                .build();
        // 发送消息队列采用同步方式,判断发送消息队列成功后才返回接口成功
        kafkaTemplate.send(ConstantVal.KAFKA_CONSUMER_TOPIC, userId.toString(), JacksonUtils.toJSONString(deductResult)).handle((rs, throwable) -> {
                if (throwable == null) {
                    return rs;
                }
                String topic = rs.getProducerRecord().topic();
                log.info("异步扣减余额后发送消息队列失败|{}|{}|{}|{}", topic, userId, amount, execute);

                // kafka消息发送失败回滚扣费
                String execute1 = redisTemplate.execute(LuaScriptUtils.ROLLBACK_DEDUCT_SCRIPT, keys,
                        amount.multiply(ONE_HUNDRED).intValue() + "", version, id + "");
                log.info("异步扣减余额后发送消息队列失败回滚扣费|{}|{}|{}|{}|{}", topic, userId, amount, execute, execute1);
                // 提示失败,调用同步扣费
                deductResult.setMessage("fail");

                return null;
            })
            .thenAccept(rs -> {
                if (rs != null) {
                    deductLogger.info("{}|{}|{}|{}", userId, id, amount, ts);
                }
            }).get();
        return deductResult;
    }
}

上面的代码已经完成了扣费的第一步所有逻辑,只通过redis的高性能扣费逻辑就完成了。使用lua脚本能够保证事务,同时redis是单线程执行命令的不用考虑锁的问题。如果使用数据库完成扣费逻辑,就要考虑使用分布式锁保证服务的安全。
但是上面的代码还有一些点要优化的:

  1. 当redis集群发生了主从切换,由于redis的异步复制就有可能存在丢失数据的风险,所以我们要在业务系统中保证数据不丢失;
  2. redis与db库会存在数据差异,这是性能导致的,在某些场景中要考虑这种差异有可能引起的问题。

余额数据在redis中的结构是一个hash,金额的单位为分:

127.0.0.1:7001> hgetall user:balance:{9}
1) "balance"
2) "9970000"
3) "v"
4) "4"
5) "threshold"
6) "500000"
7) "ts"
8) "1728436908699"

订单信息是一个键值对,值的结构是多个;分隔的值,分别为本次扣减金额、时间戳、扣减后余额:

127.0.0.1:7001> get user:order:{9}:1843824075538042880
"10000;1728436890860;9990000"

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部