交易系统
交易系统的数据结构
支付系统API通常需要一个“订单号”作为入参, 而实际调用API接口时使用到的往往不是真正意义的业务订单号, 而是交易订单号. 支付系统的API会使用“商户号+订单号”唯一的标准来设计, 对于商户方就需要做对应的逻辑来保证业务的一致性. 这里就引入了交易订单表, 一个业务订单在支付时会创建一条交易订单，这笔交易订单会关联业务订单，并将交易订单号发给支付系统, 根据结果处理资金账户数据和业务订单数据. 由于是调用远程接口, 有同步也有异步, 结果会出现各种各样的情况，如成功, 失败, 等待, 超时等等, 因此一笔业务订单可能对应多条交易订单，每一条交易订单会对应一个或多个请求结果.
交易的模式
交易主要有三个模式: 同步请求, 异步请求, 还有查询. 对于一些系统, 还有批量提交的请求方式, 这个可以归为异步请求这一类.
对于同步的交易, 可能会在发出请求后收到成功, 失败, 未知三种情况;
对于异步的交易, 可能会收到成功, 失败两种情况;
对于查询, 可能会收到成功, 失败, 未知三种情况, 和同步交易一样.
交易的结果处理
成功: 更新交易订单状态, 记录结果, 根据实际业务处理.
失败: 更新交易订单状态, 记录结果, 根据实际业务, 创建新的交易订单或者将业务订单置为失败.
未知: 不做操作, 等待异步通知, 或通过时间任务异步查询, 或加入队列进行异步查询.
需要注意的是, 对于有多种返回结果代码的支付系统, 一定要明确各个代码的归类, 属于"成功"和"失败"的代码不能出现偏差. 在通道方的结果代码有调整时, 要及时更新.
交易的事务控制
交易的事务应当仅仅局限于本地方法, 中间不能有远程调用, 因为远程接口不可控, 更不可能在事务失败时跟随本地调用一起回滚. 另外还可能导致本地资源一直被占用, 尤其是数据库连接.
并发问题
单机的并发可以通过synchronized或者Lock解决(全局一致性), 也可以通过乐观锁解决(最终一致性), 同时使用队列降低系统突发压力. 这个比较简单就不说明了.
对于分布式系统的并发, 可以通过以下途径解决:
乐观锁
乐观锁是通过数据库入库时, 校验数据版本的一致性来达到业务最终一致性的一种手段, 适用于单机分布式等各种环境, 好处是实现简单, 读性能非常好, 缺点也很明显, 在业务的交易链较长时, 一个回滚可能会导致整个上层交易失败, 这样的情况虽然能保证资金不出错, 但是系统的交易频率越高, 特别是同一个资金账户的交易频率越高, 乐观锁失败的概率就越大, 重试次数多了, 就会影响业务效率. 所以乐观锁只是一个基础, 仅保证业务数据不出错, 要解决并发问题还需要靠其他手段.
分布式锁
分布式锁可以基于db, redis, zookeeper等实现. 最简单的锁实现的是lock和unlock功能, 实际应用中, 还需要两个功能: 一个Reentrant 以实现同线程重入, 和一个Timeout 以实现在某个实例出现异常时, 不至于导致整个交易被永久挂起. 常见的是用Redis或Zookeeper做的分布式锁. 在资金账户数量很大, 交易较分散的情况下, 分布式锁起到了"微队列"的作用, 对处理效率的影响较小.
消息队列
消息队列常用于业务间和模块间的性能优化. 通过队列缓冲突发负载, 对请求进行排重减少实际交易的请求, 以及序列化请求避免资源冲突. 模式简单的业务可以使用Redis的rpush+blpop做简易队列, 需求较复杂的场景, 可以使用rabbitmq.
Redisson的分布式锁
借助Redisson的getLock和getReadWriteLock方法, 对同线程可重入, 可以设置锁超时, 可以设置取锁超时, 锁本身有默认30秒的超时
public class LockManagerImpl implements LockManager {
private final Redisson redisson;
public LockManagerImpl(ZookeeperManager zookeeperManager) {
Map<String, ZookeeperValue> settings = zookeeperManager.load("/lock");
Config config = new Config();
config
.useSingleServer()
.setAddress(settings.get("address").getString("redis://127.0.0.1:6379"))
.setTimeout(settings.get("timeout").getInteger(3000))
.setPassword(settings.get("password").getString(null));
redisson = (Redisson) Redisson.create(config);
}
public void init() {
logger.debug("init()");
}
public void destroy() {
logger.debug("destroy()");
}
@Override
public Lock getLock(String key) {
return redisson.getLock(key);
}
@Override
public ReadWriteLock getReadWriteLock(String key) {
return redisson.getReadWriteLock(key);
}
}
Jedis实现的分布式锁
Redis版本小于2.6的, 借助 SETNX 命令, 只有当key不存在时才能set成功, 这只是一个简单的实现, 有超时, 但是不能同一线程重入. 具体代码参考 https://github.com/abelaska/jedis-lock
Redis版本2.6.0之后, 增加了内置LUA语言支持, 可以通过EVAL()和EVALSHA()执行LUA脚本. 通过LUA脚本实现的分布式锁, 可以更好的支持线程重入和超时的特性.
获取锁的代码
实际上是实现了一个spinlock, 不断尝试获取锁, 直至超时. 锁在Redis中体现为一个hash, hash的名称就是资源ID, hash的超时时间就是锁的超时时间, hash里的key是 uuid + 线程ID, value是当前线程重入的数量.
// Note: index of key&argv starts from 1
private static final String COMMAND_LOCK =
"if (redis.call('exists', KEYS[1]) == 0) then " +
"redis.call('hset', KEYS[1], ARGV[1], 1); " +
"redis.call('pexpire', KEYS[1], ARGV[2]); " +
"return 1; " +
"end; " +
"if (redis.call('hexists', KEYS[1], ARGV[1]) == 1) then " +
"local counter = redis.call('hincrby', KEYS[1], ARGV[1], 1); " +
"redis.call('pexpire', KEYS[1], ARGV[2]); " +
"return counter; " +
"end; " +
"return nil;";
public boolean acquire() {
int timeout = acquiryTimeoutInMillis;
while (timeout >= 0) {
Object result = client.eval(COMMAND_LOCK, 1, lockKeyPath, getId(), lockExpiryInMillis + "");
if (result == null) {
timeout -= DEFAULT_ACQUIRY_RESOLUTION_MILLIS;
try {
Thread.sleep(DEFAULT_ACQUIRY_RESOLUTION_MILLIS);
} catch (InterruptedException e) {
// Do nothing
}
} else {
this.counter = (Long)result;
return true;
}
}
return false;
}
释放锁的代码
释放锁时会减少线程的重入数量, 当重入数量为0时, 才删除锁.
private static final String COMMAND_UNLOCK =
"if (redis.call('hexists', KEYS[1], ARGV[1]) == 0) then " +
"return nil;" +
"end; " +
"local counter = redis.call('hincrby', KEYS[1], ARGV[1], -1); " +
"if (counter > 0) then " +
"redis.call('pexpire', KEYS[1], ARGV[2]); " +
"return counter; " +
"else " +
"redis.call('del', KEYS[1]); " +
"return 0; "+
"end; " +
"return nil;";
public void release() {
Object result = client.eval(COMMAND_UNLOCK, 1, lockKeyPath, getId(), lockExpiryInMillis + "");
if (result == null) {
this.counter = 0;
} else {
this.counter = (Long)result;
}
}
具体的代码参考 https://github.com/MiltonLai/jedis-lock
Zookeeper实现的分布式锁
利用了Zookeeper的Watcher机制. 在Zookeeper中节点类型使用 EPHEMERAL_SEQUENTIAL, 这种类型当客户端无效后会自动删除, 并且同名节点会通过后缀数字增长进行添加. 这样实际上维护了两个序列: 在Zookeeper中会保持一个同名但是后缀数字不断增长的序列, 而在本地是线程序列, 使用一个同步的lock对getChildren进行竞争. 每一个本地线程都会在zookeeper中创建一个带序列号的节点, 同时等待资源锁被释放, 当拿到资源锁时, 判断自己是不是top的那个节点, 如果不是就释放资源锁, 继续等待. 如果是就说明拿到业务锁了, 在业务执行完之后, 要调用unlock释放业务锁, 触发watcher事件. 如果拿到业务锁的线程中途退出了并未执行unlock, zookeeper在检查到客户节点退出后, 也会将对应的节点删除, 也会触发watcher事件.
public class DistributedLock {
private final ZooKeeper zk;
private final String lockBasePath;
private final String lockName;
private String lockPath;
public DistributedLock(ZooKeeper zk, String lockBasePath, String lockName) {
this.zk = zk;
this.lockBasePath = lockBasePath;
this.lockName = lockName;
}
public void lock() throws IOException {
try {
// lockPath will be different than (lockBasePath + "/" + lockName) becuase of the sequence number ZooKeeper appends
lockPath = zk.create(lockBasePath + "/" + lockName, null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
final Object lock = new Object();
// The requests in the same jvm will be blocked here waiting for wait() or notifyAll(). This will prevent missing notifications.
synchronized(lock) {
while(true) {
List<String> nodes = zk.getChildren(lockBasePath, new Watcher() {
@Override
public void process(WatchedEvent event) {
synchronized (lock) {
// When the brother nodes are changed, all waiting threads will be notified.
lock.notifyAll();
}
}
});
Collections.sort(nodes); // ZooKeeper node names can be sorted lexographically
if (lockPath.endsWith(nodes.get(0))) {
return;
} else {
// This will give up the lock and wait the next notification. When woken up, it will go through the WHILE block again
lock.wait();
}
}
}
} catch (KeeperException e) {
throw new IOException (e);
} catch (InterruptedException e) {
throw new IOException (e);
}
}
public void unlock() throws IOException {
try {
// This will trigger the Watcher.process()
zk.delete(lockPath, -1);
lockPath = null;
} catch (KeeperException e) {
throw new IOException (e);
} catch (InterruptedException e) {
throw new IOException (e);
}
}
}
Jedis实现的队列
利用 Redis 的 LIST 类型数据的 RPUSH 和 BLPOP 方法实现消息的生产和消费
public long rpush(final String... value) {
if (value == null) return -1;
return (Long) execute((Jedis jedis) -> jedis.rpush(getId(), value));
}
public long rpushObject(final Object value) {
if (value == null) return -1;
return (Long) execute((Jedis jedis) -> jedis.rpush(getId().getBytes(), SerializeUtil.serialize(value)));
}
public long rpushObject(final Object... value) {
if (value == null || value.length == 0) return -1;
return (Long) execute((Jedis jedis) -> jedis.rpush(getId().getBytes(), SerializeUtil.serialize(value)));
}
public List<String> blpop(int timeout) {
return (List<String>) execute((Jedis jedis)-> jedis.blpop(timeout, getId()));
}
public List<Object> blpopObject(int timeout) {
return (List<Object>)execute((Jedis jedis) -> {
List<Object> objects = new ArrayList<>();
List<byte[]> bytesList = jedis.blpop(timeout, getId().getBytes());
for (byte[] bytes : bytesList) {
objects.add(SerializeUtil.unserialize(bytes));
}
return objects;
});
}
业务中使用队列
@Override
public long lRpush(String id, String value) {
return factory.getList(id).rpush(value);
}
@Override
public long lRpushObject(String id, Object value) {
return factory.getList(id).rpushObject(value);
}
@Override
public List<String> lBlpop(String id, int timeout) {
return factory.getList(id).blpop(timeout);
}
@Override
public List<Object> lBlpopObject(String id, int timeout) {
return factory.getList(id).blpopObject(timeout);
}
/*
* =========================================
*/
@Override
public long pushToQueue(int type, String id) {
QueueItemDTO item = new QueueItemDTO(type, id);
String value = JacksonUtils.compressObject(item);
if (redisService.sIsMember(REDIS_SET_TRANS, value)) {
logger.info("Item:{} exists in queue, skip.", value);
return 0;
}
redisService.sAdd(REDIS_SET_TRANS, value);
long size = redisService.lRpush(REDIS_QUEUE_TRANS, value);
logger.info("Request:{} pushed to queue. size:{}", value, size);
return size;
}
@Override
public QueueItemDTO readQueue() {
List<String> list = redisService.lBlpop(REDIS_QUEUE_TRANS, 5);
if (list != null && list.size() > 1) {
logger.info("Queue:{}, pop:{}", list.get(0), list.get(1));
redisService.sRemove(REDIS_SET_TRANS, list.get(1));
return JacksonUtils.extractObject(list.get(1), QueueItemDTO.class);
} else {
return null;
}
}
.