backend/java-mall
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

订单命名-改成_下划线，拉卡拉要求的规则，否则无法分账

Browse Source
This commit is contained in:
Jack 2025-09-08 18:19:13 +08:00
parent c5ca9bc95d
commit 9fc880edb1
5 changed files with 95 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
mall-common/src/main/java/com/suisung/mall/common/constant/CommonConstant.java
View File

@ -95,7 +95,7 @@ public class CommonConstant {
public static final String SPLIT_ = "diffCityOrderExpireSeconds"; public static final String SPLIT_ = "diffCityOrderExpireSeconds";
// 订单分拆后 运费和商品子订单前缀 // 订单分拆后 运费和商品子订单前缀
public static final String Sep_DeliveryFee_Prefix = "DF-"; public static final String Sep_DeliveryFee_Prefix = "DF_";
public static final String Sep_GoodsFee_Prefix = "ORD-"; public static final String Sep_GoodsFee_Prefix = "ORD_";
} }

4
mall-pay/src/main/java/com/suisung/mall/pay/service/PayConsumeTradeService.java
View File

@ -75,7 +75,7 @@ public interface PayConsumeTradeService extends IBaseService<PayConsumeTrade> {
* "amount":"1", // 分账金额 * "amount":"1", // 分账金额
* "settle_type":"0", // 结算类型 * "settle_type":"0", // 结算类型
* "sub_log_no":"66250034401288", // 子流水号 * "sub_log_no":"66250034401288", // 子流水号
* "out_sub_trade_no":"DF-DD-20250830-21", // 外部子交易订单号(DF开头为运费订单) * "out_sub_trade_no":"DF_DD_20250830_21", // 外部子交易订单号(DF开头为运费订单)
* "term_no":"N5811590" // 终端设备号 * "term_no":"N5811590" // 终端设备号
* }, * },
* { * {
@ -84,7 +84,7 @@ public interface PayConsumeTradeService extends IBaseService<PayConsumeTrade> {
* "amount":"1", // 分账金额 * "amount":"1", // 分账金额
* "settle_type":"0", // 结算类型 * "settle_type":"0", // 结算类型
* "sub_log_no":"66250034401289", // 子流水号 * "sub_log_no":"66250034401289", // 子流水号
* "out_sub_trade_no":"ORD-DD-20250830-21", // 外部子交易订单号(ORD开头为商品订单) * "out_sub_trade_no":"ORD_DD_20250830_21", // 外部子交易订单号(ORD开头为商品订单)
* "term_no":"N5817779" // 终端设备号 * "term_no":"N5817779" // 终端设备号
* } * }
* ] * ]

2
mall-pay/src/main/java/com/suisung/mall/pay/service/impl/LakalaPayServiceImpl.java
View File

@ -263,7 +263,7 @@ public class LakalaPayServiceImpl implements LakalaPayService {
accBusiFields.put("user_id", openId); // 用户openid accBusiFields.put("user_id", openId); // 用户openid
reqData.put("acc_busi_fields", accBusiFields); reqData.put("acc_busi_fields", accBusiFields);
// 重要约定，订单号规则：商品订单：ORD-订单号,运费订单：DF-订单号 // 重要约定，订单号规则：商品订单：ORD_订单号,运费订单：DF_订单号
// 分单信息 // 分单信息
JSONObject goodsSplitInfo = new JSONObject(); JSONObject goodsSplitInfo = new JSONObject();
goodsSplitInfo.put("out_sub_trade_no", CommonConstant.Sep_GoodsFee_Prefix + orderId); // 商品子订单号 goodsSplitInfo.put("out_sub_trade_no", CommonConstant.Sep_GoodsFee_Prefix + orderId); // 商品子订单号

6
mall-shop/src/main/java/com/suisung/mall/shop/base/service/impl/ShopBaseStateCodeServiceImpl.java
View File

@ -32,7 +32,7 @@ public class ShopBaseStateCodeServiceImpl extends BaseServiceImpl<ShopBaseStateC
* 根据商品状态码 获取状态名称 (注意在该类内部调用此方法缓存则失效 并且 此表数据如果发生变动则需要靠重启JVM来刷新缓存) * 根据商品状态码 获取状态名称 (注意在该类内部调用此方法缓存则失效 并且 此表数据如果发生变动则需要靠重启JVM来刷新缓存)
* todo 可以优化（这里缓存的是一个字段，不是一条数据） * todo 可以优化（这里缓存的是一个字段，不是一条数据）
* todo 一般情况此表不会发生变化，如果追求数据一致性，可以考虑使用redis Hash来存储，使用JVM来缓存是更好的选择 * todo 一般情况此表不会发生变化，如果追求数据一致性，可以考虑使用redis Hash来存储，使用JVM来缓存是更好的选择
* * <p>
* update 2024-12-14 切换到redis缓存 30秒 * update 2024-12-14 切换到redis缓存 30秒
* *
* @param code 商品状态码 * @param code 商品状态码
@ -72,12 +72,12 @@ public class ShopBaseStateCodeServiceImpl extends BaseServiceImpl<ShopBaseStateC
/** /**
* @param code * @param code
* @param type 默认值 "state_code_code" * @param type 默认值 "state_code_code"
* todo 加缓存 * todo 加缓存
*/ */
@Override @Override
public String getCode(Integer code, String type) { public String getCode(Integer code, String type) {
if (code != null) { if (code != null) {
// String code_key = String.format("statecode-%s", code); // String code_key = String.format("statecode_%s", code);
Map rows = Convert.toMap(String.class, Object.class, get(code)); Map rows = Convert.toMap(String.class, Object.class, get(code));
if (rows != null) { if (rows != null) {

174
mall-shop/src/main/java/com/suisung/mall/shop/number/service/impl/ShopNumberSeqServiceImpl.java
View File

@ -38,12 +38,11 @@ import java.util.stream.LongStream;
@lombok.extern.slf4j.Slf4j @lombok.extern.slf4j.Slf4j
public class ShopNumberSeqServiceImpl extends BaseServiceImpl<ShopNumberSeqMapper, ShopNumberSeq> implements ShopNumberSeqService { public class ShopNumberSeqServiceImpl extends BaseServiceImpl<ShopNumberSeqMapper, ShopNumberSeq> implements ShopNumberSeqService {
private final String CACHE_PREFIX = "shop_number_seq:%S";
@Autowired @Autowired
private ShopNumberSeqMapper shopNumberSeqMapper; private ShopNumberSeqMapper shopNumberSeqMapper;
@Autowired @Autowired
private RedisService redisService; private RedisService redisService;
private String CACHE_PREFIX = "shop_number_seq:%S";
@Autowired @Autowired
private ShopProductSpecItemService shopProductSpecItemService; private ShopProductSpecItemService shopProductSpecItemService;
@ -53,6 +52,10 @@ public class ShopNumberSeqServiceImpl extends BaseServiceImpl<ShopNumberSeqMappe
@Autowired @Autowired
private AccountService accountService; private AccountService accountService;
public static void main(String[] args) {
System.out.printf(IntStream.rangeClosed(1, 1).boxed().collect(Collectors.toList()).toString());
}
/** /**
* 得到下一个Id * 得到下一个Id
* 方法走到这里会产生串行化，集群部署这里不能使用单机锁 * 方法走到这里会产生串行化，集群部署这里不能使用单机锁
@ -65,7 +68,7 @@ public class ShopNumberSeqServiceImpl extends BaseServiceImpl<ShopNumberSeqMappe
public synchronized String createNextSeq(String prefix) { public synchronized String createNextSeq(String prefix) {
String ymd = DateUtil.format(new Date(), "yyyyMMdd"); String ymd = DateUtil.format(new Date(), "yyyyMMdd");
String id = String.format("%s-%s-", prefix, ymd); String id = String.format("%s_%s_", prefix, ymd);
ShopNumberSeq shopNumberSeq = this.baseMapper.selectById(id); ShopNumberSeq shopNumberSeq = this.baseMapper.selectById(id);
if (shopNumberSeq == null) { if (shopNumberSeq == null) {
shopNumberSeq = new ShopNumberSeq(); shopNumberSeq = new ShopNumberSeq();
@ -76,7 +79,7 @@ public class ShopNumberSeqServiceImpl extends BaseServiceImpl<ShopNumberSeqMappe
} }
} }
String order_id = String.format("%s-%s-%s", prefix, ymd, shopNumberSeq.getNumber()); String order_id = String.format("%s_%s_%s", prefix, ymd, shopNumberSeq.getNumber());
shopNumberSeq.setPrefix(id); shopNumberSeq.setPrefix(id);
boolean flag = edit(shopNumberSeq); boolean flag = edit(shopNumberSeq);
if (flag) { if (flag) {
@ -86,7 +89,6 @@ public class ShopNumberSeqServiceImpl extends BaseServiceImpl<ShopNumberSeqMappe
return null; return null;
} }
/** /**
* 得到下一个Id * 得到下一个Id
* *
@ -128,25 +130,26 @@ public class ShopNumberSeqServiceImpl extends BaseServiceImpl<ShopNumberSeqMappe
/** /**
* 校验同步数据是否同步完成，就是两个库的主键是否一致 * 校验同步数据是否同步完成，就是两个库的主键是否一致
*
* @return * @return
*/ */
private void checkPrimaryKey(){ private void checkPrimaryKey() {
boolean flag = shopNumberSeqMapper.findNumberFromShopBaseAndItem(new ShopNumberSeq()).size()>1; boolean flag = shopNumberSeqMapper.findNumberFromShopBaseAndItem(new ShopNumberSeq()).size() > 1;
while (!flag){ while (!flag) {
try { try {
Thread.sleep(3600); Thread.sleep(3600);
} catch (InterruptedException e) { } catch (InterruptedException e) {
log.error("checkPrimaryKey枷锁失败--"+e.getMessage()); log.error("checkPrimaryKey枷锁失败--" + e.getMessage());
break; break;
} }
flag=shopNumberSeqMapper.findNumberFromShopBaseAndItem(new ShopNumberSeq()).size()>1; flag = shopNumberSeqMapper.findNumberFromShopBaseAndItem(new ShopNumberSeq()).size() > 1;
} }
} }
/** /**
* 批量获取id * 批量获取id
*
* @param seqName * @param seqName
* @param batchSize * @param batchSize
* @return * @return
@ -156,8 +159,8 @@ public class ShopNumberSeqServiceImpl extends BaseServiceImpl<ShopNumberSeqMappe
if (batchSize <= 0) { if (batchSize <= 0) {
return Collections.emptyList(); return Collections.emptyList();
} }
long number= 0; long number = 0;
if (null==redisService.get(String.format(CACHE_PREFIX, seqName))) { if (null == redisService.get(String.format(CACHE_PREFIX, seqName))) {
// 1. 获取当前序列值 // 1. 获取当前序列值
QueryWrapper<ShopNumberSeq> wrapper = new QueryWrapper<>(); QueryWrapper<ShopNumberSeq> wrapper = new QueryWrapper<>();
wrapper.eq("prefix", seqName); wrapper.eq("prefix", seqName);
@ -171,9 +174,9 @@ public class ShopNumberSeqServiceImpl extends BaseServiceImpl<ShopNumberSeqMappe
return LongStream.range(1, batchSize + 1).boxed().collect(Collectors.toList()); return LongStream.range(1, batchSize + 1).boxed().collect(Collectors.toList());
} }
number = seq.getNumber(); number = seq.getNumber();
}else { } else {
int numberCache=(Integer) redisService.get(String.format(CACHE_PREFIX, seqName))+1; int numberCache = (Integer) redisService.get(String.format(CACHE_PREFIX, seqName)) + 1;
number= numberCache; number = numberCache;
} }
@ -187,8 +190,8 @@ public class ShopNumberSeqServiceImpl extends BaseServiceImpl<ShopNumberSeqMappe
return LongStream.rangeClosed(start, end).boxed().collect(Collectors.toList()); return LongStream.rangeClosed(start, end).boxed().collect(Collectors.toList());
} }
public void batchUpdateSeq(List<ShopNumberSeq> shopNumberSeqList){ public void batchUpdateSeq(List<ShopNumberSeq> shopNumberSeqList) {
int count=0; int count = 0;
for (int i = 0; i < shopNumberSeqList.size(); i++) { for (int i = 0; i < shopNumberSeqList.size(); i++) {
shopNumberSeqMapper.myUpdateSeq(shopNumberSeqList.get(i)); shopNumberSeqMapper.myUpdateSeq(shopNumberSeqList.get(i));
Long number = shopNumberSeqList.get(i).getNumber(); Long number = shopNumberSeqList.get(i).getNumber();
@ -196,24 +199,24 @@ public class ShopNumberSeqServiceImpl extends BaseServiceImpl<ShopNumberSeqMappe
this.edit(shopNumberSeqList.get(i)); this.edit(shopNumberSeqList.get(i));
count++; count++;
} }
log.info("更新成功{}条数据",count); log.info("更新成功{}条数据", count);
} }
public void clearKey(){ public void clearKey() {
redisService.del(String.format(CACHE_PREFIX,"item_id")); redisService.del(String.format(CACHE_PREFIX, "item_id"));
redisService.del(String.format(CACHE_PREFIX,"product_id")); redisService.del(String.format(CACHE_PREFIX, "product_id"));
} }
public void clearKeyStoreItemSepcId(){ public void clearKeyStoreItemSepcId() {
redisService.del(RedisKey.STOREDATASPECITEMID); redisService.del(RedisKey.STOREDATASPECITEMID);
} }
public void clearKeyStoreAccountBaseId(){ public void clearKeyStoreAccountBaseId() {
redisService.del(RedisKey.STOREDATACCOUNTBASEID); redisService.del(RedisKey.STOREDATACCOUNTBASEID);
} }
public void clearKeyStoreSepcId(){ public void clearKeyStoreSepcId() {
redisService.del(RedisKey.STOREDATASPECID); redisService.del(RedisKey.STOREDATASPECID);
} }
@ -221,31 +224,32 @@ public class ShopNumberSeqServiceImpl extends BaseServiceImpl<ShopNumberSeqMappe
* 清除缓存，专门给并发使用,防止redis的缓存没有加载 * 清除缓存，专门给并发使用,防止redis的缓存没有加载
*/ */
@Override @Override
public void clearRelateGoodsId(){ public void clearRelateGoodsId() {
boolean flag = shopNumberSeqMapper.findNumberFromShopBaseAndItem(new ShopNumberSeq()).size()>1; boolean flag = shopNumberSeqMapper.findNumberFromShopBaseAndItem(new ShopNumberSeq()).size() > 1;
if(flag){ if (flag) {
return; return;
} }
List<ShopNumberSeq> shopNumberSeqList=shopNumberSeqMapper.findProductAndImtemId(new ShopNumberSeq()); List<ShopNumberSeq> shopNumberSeqList = shopNumberSeqMapper.findProductAndImtemId(new ShopNumberSeq());
for (ShopNumberSeq shopNumberSeq:shopNumberSeqList) { for (ShopNumberSeq shopNumberSeq : shopNumberSeqList) {
if(shopNumberSeq.getPrefix().equals("product_id")){ if (shopNumberSeq.getPrefix().equals("product_id")) {
clearCache("product_id",shopNumberSeq.getNumber()); clearCache("product_id", shopNumberSeq.getNumber());
} }
if(shopNumberSeq.getPrefix().equals("item_id")){ if (shopNumberSeq.getPrefix().equals("item_id")) {
clearCache("item_id",shopNumberSeq.getNumber()); clearCache("item_id", shopNumberSeq.getNumber());
} }
} }
} }
/** /**
* 刷新缓存 * 刷新缓存
*/ */
private void clearCache(String seqName,long number){ private void clearCache(String seqName, long number) {
QueryWrapper<ShopNumberSeq> wrapper = new QueryWrapper<>(); QueryWrapper<ShopNumberSeq> wrapper = new QueryWrapper<>();
wrapper.eq("prefix", seqName); wrapper.eq("prefix", seqName);
ShopNumberSeq seq = getById(seqName); ShopNumberSeq seq = getById(seqName);
if (seq != null) { if (seq != null) {
seq = new ShopNumberSeq(); seq = new ShopNumberSeq();
seq.setNumber(number-1); seq.setNumber(number - 1);
seq.setPrefix(seqName); seq.setPrefix(seqName);
} }
edit(seq); edit(seq);
@ -253,88 +257,84 @@ public class ShopNumberSeqServiceImpl extends BaseServiceImpl<ShopNumberSeqMappe
/** /**
* 存的是最大值，取的是范围，如存最大值1，批量是2，则取范围【1+1，1+2】,如果没有则从1开始算即取范围[0+1,0+2] * 存的是最大值，取的是范围，如存最大值1，批量是2，则取范围【1+1，1+2】,如果没有则从1开始算即取范围[0+1,0+2]
*
* @param batchSize * @param batchSize
* @return * @return
*/ */
@Override @Override
public synchronized List<Integer> getBatchSpecId(int batchSize) { public synchronized List<Integer> getBatchSpecId(int batchSize) {
int start=0; int start = 0;
if(null!=redisService.get(RedisKey.STOREDATASPECID)){ if (null != redisService.get(RedisKey.STOREDATASPECID)) {
start=(Integer) redisService.get(RedisKey.STOREDATASPECID); start = (Integer) redisService.get(RedisKey.STOREDATASPECID);
redisService.set(RedisKey.STOREDATASPECID,start+batchSize); redisService.set(RedisKey.STOREDATASPECID, start + batchSize);
return IntStream.rangeClosed(start+1, start+batchSize).boxed().collect(Collectors.toList()); return IntStream.rangeClosed(start + 1, start + batchSize).boxed().collect(Collectors.toList());
} }
QueryWrapper<ShopBaseProductSpec> queryWrapper= new QueryWrapper<>(); QueryWrapper<ShopBaseProductSpec> queryWrapper = new QueryWrapper<>();
queryWrapper.select("max(spec_id) as spec_id"); queryWrapper.select("max(spec_id) as spec_id");
ShopBaseProductSpec shopBaseProductSpec=shopBaseProductSpecService.getOne(queryWrapper); ShopBaseProductSpec shopBaseProductSpec = shopBaseProductSpecService.getOne(queryWrapper);
if(null!=shopBaseProductSpec){ if (null != shopBaseProductSpec) {
start=shopBaseProductSpec.getSpec_id(); start = shopBaseProductSpec.getSpec_id();
redisService.set(RedisKey.STOREDATASPECID,start+batchSize); redisService.set(RedisKey.STOREDATASPECID, start + batchSize);
} }
if(start==0){ if (start == 0) {
redisService.set(RedisKey.STOREDATASPECID,start+batchSize); redisService.set(RedisKey.STOREDATASPECID, start + batchSize);
return IntStream.rangeClosed(start+1, start+batchSize).boxed().collect(Collectors.toList()); return IntStream.rangeClosed(start + 1, start + batchSize).boxed().collect(Collectors.toList());
} }
return IntStream.rangeClosed(start+1, start+batchSize).boxed().collect(Collectors.toList()); return IntStream.rangeClosed(start + 1, start + batchSize).boxed().collect(Collectors.toList());
} }
/** /**
* 存的是最大值，取的是范围，如存最大值1，批量是2，则取范围【1+1，1+2】,如果没有则从1开始算即取范围[0+1,0+2] * 存的是最大值，取的是范围，如存最大值1，批量是2，则取范围【1+1，1+2】,如果没有则从1开始算即取范围[0+1,0+2]
*
* @param batchSize * @param batchSize
* @return * @return
*/ */
@Override @Override
public synchronized List<Integer> getBatchSpecItemId(int batchSize) { public synchronized List<Integer> getBatchSpecItemId(int batchSize) {
int start=0; int start = 0;
if(null!=redisService.get(RedisKey.STOREDATASPECITEMID)){ if (null != redisService.get(RedisKey.STOREDATASPECITEMID)) {
start=(Integer) redisService.get(RedisKey.STOREDATASPECITEMID); start = (Integer) redisService.get(RedisKey.STOREDATASPECITEMID);
redisService.set(RedisKey.STOREDATASPECITEMID,start+batchSize); redisService.set(RedisKey.STOREDATASPECITEMID, start + batchSize);
return IntStream.rangeClosed(start+1, start+batchSize).boxed().collect(Collectors.toList()); return IntStream.rangeClosed(start + 1, start + batchSize).boxed().collect(Collectors.toList());
} }
QueryWrapper<ShopProductSpecItem> queryWrapper= new QueryWrapper<>(); QueryWrapper<ShopProductSpecItem> queryWrapper = new QueryWrapper<>();
queryWrapper.select("max(spec_item_id) as spec_item_id"); queryWrapper.select("max(spec_item_id) as spec_item_id");
ShopProductSpecItem shopProductSpecItem=shopProductSpecItemService.getOne(queryWrapper); ShopProductSpecItem shopProductSpecItem = shopProductSpecItemService.getOne(queryWrapper);
if(null!=shopProductSpecItem){ if (null != shopProductSpecItem) {
start=shopProductSpecItem.getSpec_item_id(); start = shopProductSpecItem.getSpec_item_id();
redisService.set(RedisKey.STOREDATASPECITEMID,start+batchSize); redisService.set(RedisKey.STOREDATASPECITEMID, start + batchSize);
} }
if(start==0){ if (start == 0) {
redisService.set(RedisKey.STOREDATASPECITEMID,start+batchSize); redisService.set(RedisKey.STOREDATASPECITEMID, start + batchSize);
return IntStream.rangeClosed(start+1, start+batchSize).boxed().collect(Collectors.toList()); return IntStream.rangeClosed(start + 1, start + batchSize).boxed().collect(Collectors.toList());
} }
return IntStream.rangeClosed(start+1, start+batchSize).boxed().collect(Collectors.toList()); return IntStream.rangeClosed(start + 1, start + batchSize).boxed().collect(Collectors.toList());
} }
/** /**
* 存的是最大值，取的是范围，如存最大值1，批量是2，则取范围【1+1，1+2】,如果没有则从1开始算即取范围[0+1,0+2] * 存的是最大值，取的是范围，如存最大值1，批量是2，则取范围【1+1，1+2】,如果没有则从1开始算即取范围[0+1,0+2]
*
* @param batchSize * @param batchSize
* @return * @return
*/ */
@Override @Override
public synchronized List<Integer> getBatchUserAccountBaseId(int batchSize) { public synchronized List<Integer> getBatchUserAccountBaseId(int batchSize) {
int start=0; int start = 0;
if(null!=redisService.get(RedisKey.STOREDATACCOUNTBASEID)){ if (null != redisService.get(RedisKey.STOREDATACCOUNTBASEID)) {
start=(Integer) redisService.get(RedisKey.STOREDATACCOUNTBASEID); start = (Integer) redisService.get(RedisKey.STOREDATACCOUNTBASEID);
redisService.set(RedisKey.STOREDATACCOUNTBASEID,start+batchSize); redisService.set(RedisKey.STOREDATACCOUNTBASEID, start + batchSize);
return IntStream.rangeClosed(start+1, start+batchSize).boxed().collect(Collectors.toList()); return IntStream.rangeClosed(start + 1, start + batchSize).boxed().collect(Collectors.toList());
} }
Integer maxId= accountService.getAccountMaxId(); Integer maxId = accountService.getAccountMaxId();
if(null!=maxId){ if (null != maxId) {
start=maxId; start = maxId;
redisService.set(RedisKey.STOREDATACCOUNTBASEID,start+batchSize); redisService.set(RedisKey.STOREDATACCOUNTBASEID, start + batchSize);
} }
if(start==0){ if (start == 0) {
redisService.set(RedisKey.STOREDATACCOUNTBASEID,start+batchSize); redisService.set(RedisKey.STOREDATACCOUNTBASEID, start + batchSize);
return IntStream.rangeClosed(start+1, start+batchSize).boxed().collect(Collectors.toList()); return IntStream.rangeClosed(start + 1, start + batchSize).boxed().collect(Collectors.toList());
} }
return IntStream.rangeClosed(start+1, start+batchSize).boxed().collect(Collectors.toList()); return IntStream.rangeClosed(start + 1, start + batchSize).boxed().collect(Collectors.toList());
}
public static void main(String[] args) {
System.out.printf(IntStream.rangeClosed(1, 1).boxed().collect(Collectors.toList()).toString());
} }
} }