package com.kucoin.gemstaking.core.service.impl;
import com.kucoin.gemstaking.common.dal.dataobject.*;
import com.kucoin.gemstaking.common.dal.mapper.StakingPoolOrderMapper;
import com.kucoin.gemstaking.common.dal.mapper.UserStakingHoldMapper;
import com.kucoin.gemstaking.common.dal.mapper.UserTransferLogMapper;
import com.kucoin.gemstaking.common.util.constants.OrderState;
import com.kucoin.gemstaking.common.util.constants.TransferStatus;
import com.kucoin.gemstaking.core.service.StakingTransactionProcessService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
@Slf4j
public class StakingTransactionProcessServiceImpl implements StakingTransactionProcessService {
@Autowired
private StakingPoolOrderMapper poolOrderMapper;
@Autowired
private UserTransferLogMapper transferLogMapper;
@Autowired
private UserStakingHoldMapper userStakingHoldMapper;
@Override
@Transactional
public void processAfterTransferSuccess(UserTransferLogDO transferLogDO,StakingPoolOrderDO orderOpsDO) {
//1.更改划账状态至success
//2.更改订单状态至success
//3.更新持仓记录,如果是第一次,就新增记录
//更新transferLog
UserTransferLogDO transferLogDOUpdate = buildUpdateTransferLog(transferLogDO,true);
updateTransferLog(transferLogDOUpdate,transferLogDO);
//更新orderState
StakingPoolOrderDO stakingPoolOrderDORecord = buildUpdatePoolOrder(orderOpsDO,true);
updatePoolOrder(stakingPoolOrderDORecord,orderOpsDO);
//查看是否有持仓记录
UserStakingHoldDOExample userStakingHoldDOExample = new UserStakingHoldDOExample();
userStakingHoldDOExample.createCriteria().andUserIdEqualTo(orderOpsDO.getUserId()).andPoolIdEqualTo(orderOpsDO.getPoolId());
UserStakingHoldDO userStakingHoldDO = userStakingHoldMapper.selectOneByExample(userStakingHoldDOExample);
if(null == userStakingHoldDO) {
//如果没有就NEW一个
UserStakingHoldDO userStakingHoldDONew = buildUNewStakingHoldDO(orderOpsDO);
userStakingHoldMapper.insertSelective(userStakingHoldDONew);
} else {
//更新持仓
UserStakingHoldDO userStakingHoldDO1 = new UserStakingHoldDO();
userStakingHoldDO1.setStakingHoldAmount(userStakingHoldDO.getStakingHoldAmount().add(orderOpsDO.getOrderAmount()));
UserStakingHoldDOExample update = new UserStakingHoldDOExample();
update.createCriteria().andUserIdEqualTo(orderOpsDO.getUserId()).andPoolIdEqualTo(orderOpsDO.getPoolId());
userStakingHoldMapper.updateByExampleSelective(userStakingHoldDO1,update);
}
}
@Override
@Transactional
public void processAfterTransferFail(UserTransferLogDO transferLogDO,StakingPoolOrderDO orderOpsDO) {
//余额不足
//更新transferLog
UserTransferLogDO transferLogDOUpdate = buildUpdateTransferLog(transferLogDO,false);
updateTransferLog(transferLogDOUpdate,transferLogDO);
//更新orderState
StakingPoolOrderDO stakingPoolOrderDORecord = buildUpdatePoolOrder(orderOpsDO,false);
updatePoolOrder(stakingPoolOrderDORecord,orderOpsDO);
}
private UserTransferLogDO buildUpdateTransferLog(UserTransferLogDO transferLogDO,Boolean isSuccess) {
UserTransferLogDO result = new UserTransferLogDO();
if (isSuccess) {
result.setTransferStatus(TransferStatus.STAKING_SUCCESS.getCode());
} else {
result.setFailReason(transferLogDO.getFailReason());
result.setTransferStatus(TransferStatus.STAKING_FAIL.getCode());
}
return result;
}
private StakingPoolOrderDO buildUpdatePoolOrder(StakingPoolOrderDO stakingPoolOrderDO,Boolean isSuccess) {
StakingPoolOrderDO result = new StakingPoolOrderDO();
if (isSuccess) {
result.setOrderState(OrderState.STAKING_SUCCESS.getCode());
} else {
result.setOrderState(OrderState.STAKING_FAIL.getCode());
}
return result;
}
private int updateTransferLog(UserTransferLogDO transferLogDORecord,UserTransferLogDO transferLogDO) {
UserTransferLogDOExample userTransferLogDOExample = new UserTransferLogDOExample();
userTransferLogDOExample.createCriteria().andBizIdEqualTo(transferLogDO.getBizId())
.andUserIdEqualTo(transferLogDO.getUserId()).andTransferStatusEqualTo(TransferStatus.NEW.getCode());
return transferLogMapper.updateByExampleSelective(transferLogDORecord,userTransferLogDOExample);
}
private int updatePoolOrder(StakingPoolOrderDO poolOrderDORecord,StakingPoolOrderDO poolOrderDO) {
StakingPoolOrderDOExample stakingPoolOrderDOExample = new StakingPoolOrderDOExample();
stakingPoolOrderDOExample.createCriteria().andOrderIdEqualTo(poolOrderDO.getOrderId())
.andUserIdEqualTo(poolOrderDO.getUserId()).andOrderStateEqualTo(OrderState.NEW.getCode());
return poolOrderMapper.updateByExampleSelective(poolOrderDORecord,stakingPoolOrderDOExample);
}
private UserStakingHoldDO buildUNewStakingHoldDO(StakingPoolOrderDO stakingPoolOrderDO) {
UserStakingHoldDO userStakingHoldDO = new UserStakingHoldDO();
userStakingHoldDO.setPoolId(stakingPoolOrderDO.getPoolId());
userStakingHoldDO.setCampaignId(stakingPoolOrderDO.getCampaignId());
userStakingHoldDO.setStakingHoldAmount(stakingPoolOrderDO.getOrderAmount());
userStakingHoldDO.setUserId(userStakingHoldDO.getUserId());
userStakingHoldDO.setStakingReturn(0);
userStakingHoldDO.setStakingHoldToken(stakingPoolOrderDO.getOrderToken());
userStakingHoldDO.setBonusCoefficient(stakingPoolOrderDO.getBonusCoefficient());
userStakingHoldDO.setEarnToken(stakingPoolOrderDO.getEarnToken());
return userStakingHoldDO;
}
}
processAfterTransferSuccess和processAfterTransferFail方法内到三个表的更新或者插入操作是一个事务的吗
是的,processAfterTransferSuccess 和 processAfterTransferFail 方法内的操作都是在同一个事务中进行的。以下是一些关键点:
@Transactional 注解:这两个方法都被 @Transactional 注解修饰。这意味着方法内的所有操作(如数据库的插入、更新等)要么全部成功,要么全部回滚,不会出现部分成功部分失败的情况。Spring 的事务管理器会确保这一点。
多个数据库操作:在 processAfterTransferSuccess 和 processAfterTransferFail 方法内,你可以看到对多个表的更新和插入操作。这些操作包括对 UserTransferLogDO、StakingPoolOrderDO 和 UserStakingHoldDO 表的更新或插入。这些操作都是在同一个事务上下文中进行的。
事务的一致性和原子性:由于 @Transactional 注解的存在,这些操作要么全部成功,要么在任意一个操作失败时回滚所有已经进行的操作,从而保证了数据的一致性和原子性。
以下是 processAfterTransferSuccess 方法的一个简化视图,展示了其中的一些数据库操作:
@Override
@Transactional
public void processAfterTransferSuccess(UserTransferLogDO transferLogDO, StakingPoolOrderDO orderOpsDO) {
// 更新 transferLog 状态
UserTransferLogDO transferLogDOUpdate = buildUpdateTransferLog(transferLogDO, true);
updateTransferLog(transferLogDOUpdate, transferLogDO);
// 更新 order 状态
StakingPoolOrderDO stakingPoolOrderDORecord = buildUpdatePoolOrder(orderOpsDO, true);
updatePoolOrder(stakingPoolOrderDORecord, orderOpsDO);
// 更新或插入持仓记录
UserStakingHoldDOExample userStakingHoldDOExample = new UserStakingHoldDOExample();
userStakingHoldDOExample.createCriteria().andUserIdEqualTo(orderOpsDO.getUserId()).andPoolIdEqualTo(orderOpsDO.getPoolId());
UserStakingHoldDO userStakingHoldDO = userStakingHoldMapper.selectOneByExample(userStakingHoldDOExample);
if (null == userStakingHoldDO) {
UserStakingHoldDO userStakingHoldDONew = buildUNewStakingHoldDO(orderOpsDO);
userStakingHoldMapper.insertSelective(userStakingHoldDONew);
} else {
UserStakingHoldDO userStakingHoldDO1 = new UserStakingHoldDO();
userStakingHoldDO1.setStakingHoldAmount(userStakingHoldDO.getStakingHoldAmount().add(orderOpsDO.getOrderAmount()));
UserStakingHoldDOExample update = new UserStakingHoldDOExample();
update.createCriteria().andUserIdEqualTo(orderOpsDO.getUserId()).andPoolIdEqualTo(orderOpsDO.getPoolId());
userStakingHoldMapper.updateByExampleSelective(userStakingHoldDO1, update);
}
}
在这个方法中,涉及到多个数据库表的操作,但因为有 @Transactional 注解,这些操作被视为一个原子操作,如果其中任何一个操作失败,整个方法会回滚,保证数据的一致性。
因此,可以确认 processAfterTransferSuccess 和 processAfterTransferFail 方法内的所有数据库更新或插入操作都在同一个事务中进行。
事务是生效的吗
要确保 @Transactional 注解的事务管理真正生效,需要确认以下几个要点:
事务管理器配置正确:确保 Spring 配置了正确的事务管理器。通常在 Spring Boot 中,这些配置是自动完成的,但在某些情况下(例如自定义配置、使用特定的数据库等),你可能需要手动配置事务管理器。
Spring AOP 的代理机制:Spring 的事务管理是基于 AOP(面向方面编程)的,需要确保代理机制正常工作。如果你的 Spring Bean 是通过 @Autowired 注入的,并且事务方法是在同一个类内调用的,Spring 的代理机制可能无法捕获事务注解。为确保事务生效,建议将事务方法放在单独的服务层类中,并通过 Spring 容器管理这些 Bean 的注入。
事务传播属性:默认情况下,@Transactional 注解使用传播属性 REQUIRED,这意味着如果当前已经存在一个事务,则该方法将在现有事务中运行;如果没有事务,则会启动一个新的事务。在大多数情况下,这种传播行为是可以满足需求的。
异常处理:确保方法内部抛出的异常没有被捕获并吞掉。Spring 的事务机制默认只在遇到未捕获的运行时异常时才会回滚事务。你可以通过配置 @Transactional 注解的 rollbackFor 属性来指定需要回滚的异常类型。
以下是一些常见的检查点,确保事务管理生效:
确保 Spring Boot 或 Spring 配置文件中有启用事务管理的配置:
@SpringBootApplication
@EnableTransactionManagement
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
@Transactional 注解放置正确确保你的事务方法位于 Spring 管理的 Bean 中,并且是通过容器注入的方式调用:
@Service
public class StakingTransactionProcessServiceImpl implements StakingTransactionProcessService {
// Service methods here
}
事务方法如果在同一个类内调用,事务管理可能不会生效,因为 Spring 的 AOP 代理机制无法拦截这种内部调用:
@Service
public class SomeService {
@Transactional
public void outerMethod() {
// This will not work as expected if innerMethod is called directly
innerMethod();
}
@Transactional
public void innerMethod() {
// Some DB operations
}
}
确保遇到异常时事务会回滚:
@Override
@Transactional(rollbackFor = { Exception.class })
public void processAfterTransferSuccess(UserTransferLogDO transferLogDO, StakingPoolOrderDO orderOpsDO) {
try {
// Your transactional code
} catch (Exception e) {
log.error("Error occurred during transaction", e);
throw e; // This will trigger transaction rollback
}
}
查看日志和调试信息,确保事务管理器正确工作。你可以在日志中查找有关事务开始、提交和回滚的消息:
logging:
level:
org.springframework.transaction: DEBUG
通过以上检查,你可以确保 @Transactional 注解的事务管理生效。如果所有这些配置都正确,你的方法中的数据库操作将会在一个事务中执行,并且在遇到错误时会自动回滚。
我上面贴的那个类的事务是否是生效的
要确定你提供的类中的事务是否生效,需要检查以下几个关键点:
@Transactional 注解的位置:确保 @Transactional 注解放置在需要事务管理的方法上。从你提供的代码来看,@Transactional 注解已经正确放置在需要事务管理的方法上,以下是代码片段:
@Service
@Slf4j
public class StakingTransactionProcessServiceImpl implements StakingTransactionProcessService {
@Autowired
private StakingPoolOrderMapper poolOrderMapper;
@Autowired
private UserTransferLogMapper transferLogMapper;
@Autowired
private UserStakingHoldMapper userStakingHoldMapper;
@Override
@Transactional
public void processAfterTransferSuccess(UserTransferLogDO transferLogDO, StakingPoolOrderDO orderOpsDO) {
// 方法实现
}
@Override
@Transactional
public void processAfterTransferFail(UserTransferLogDO transferLogDO, StakingPoolOrderDO orderOpsDO) {
// 方法实现
}
}
为了验证事务是否生效,可以通过以下几步检查:
@SpringBootApplication
@EnableTransactionManagement
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
StakingTransactionProcessServiceImpl 是通过 Spring 容器管理的确保你的服务类是通过 Spring 容器管理的,并且是通过依赖注入的方式调用,而不是直接实例化。
确保事务方法是在类外部被调用的,而不是在同一个类中调用。Spring 的事务管理是基于 AOP 的,如果方法在同一个类中调用,事务将不会生效。
例如:
@Service
public class SomeOtherService {
@Autowired
private StakingTransactionProcessService stakingTransactionProcessService;
public void someMethod() {
// 调用事务方法
stakingTransactionProcessService.processAfterTransferSuccess(...);
}
}
启用 Spring 的事务日志,可以帮助你确定事务是否生效。在 application.properties 或 application.yml 中添加以下配置:
logging:
level:
org.springframework.transaction: DEBUG
然后检查日志,确保你看到事务开始、提交或回滚的日志消息。
确保在事务方法中,异常没有被捕获并吞掉:
@Override
@Transactional
public void processAfterTransferSuccess(UserTransferLogDO transferLogDO, StakingPoolOrderDO orderOpsDO) {
try {
// 你的事务代码
} catch (Exception e) {
log.error("Error occurred during transaction", e);
throw e; // 确保异常被抛出,以便事务回滚
}
}
你可以编写一个测试用例,模拟事务方法中的异常,看看事务是否会回滚。例如:
@SpringBootTest
public class StakingTransactionProcessServiceImplTest {
@Autowired
private StakingTransactionProcessService stakingTransactionProcessService;
@Test
public void testTransactionRollback() {
UserTransferLogDO transferLogDO = new UserTransferLogDO();
StakingPoolOrderDO orderOpsDO = new StakingPoolOrderDO();
try {
stakingTransactionProcessService.processAfterTransferSuccess(transferLogDO, orderOpsDO);
} catch (Exception e) {
// 预期的异常
}
// 验证数据库状态,确保事务已回滚
}
}
通过这些检查和验证,你可以确认 StakingTransactionProcessServiceImpl 类中的事务是否生效。如果所有这些步骤都正确,@Transactional 注解应该能够正常工作。
String redeemingLock = StakingOrderCacheKeysUtils
.getUserRedeemCacheKey(order.getUserId(), order.getOrderToken(), order.getEarnToken());
IRedisFuture<String> futureRedis = stringRedisBusTemplate.opsForValue().get(redeemingLock);
if(null != futureRedis && StringUtils.isNotEmpty(futureRedis.get())) {
//说明该用户在该池有进行中的赎回,拒绝继续
throw new BaseException("error.createRedeemOrder.existsRedeeming", GemStakingOrderErrorCode.SERVER_ERROR);
} else {
//
stringRedisBusTemplate.opsForValue().set(redeemingLock,order.getOrderId(),GemStakingConstants.ONE_HOUR, TimeUnit.SECONDS);
} 这段代码能起到分布式锁的作用吗?需要怎么改进
这段代码在某种程度上可以实现分布式锁的作用,但是它并不是一个真正的分布式锁实现。主要问题在于它不能保证原子性操作,即检查和设置值不是原子操作,这可能会导致竞争条件问题。要实现一个真正的分布式锁,需要使用 Redis 提供的原子操作。
SET NX(仅在键不存在时设置键)和 EX(设置键的过期时间)选项,可以确保设置键和值是一个原子操作。以下是使用 Redis 的 SET NX EX 命令实现分布式锁的示例:
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
@Service
public class YourService {
@Autowired
private StringRedisTemplate stringRedisTemplate;
public void yourMethod(StakingPoolOrderDO order) {
String redeemingLock = StakingOrderCacheKeysUtils
.getUserRedeemCacheKey(order.getUserId(), order.getOrderToken(), order.getEarnToken());
ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
boolean isLocked = ops.setIfAbsent(redeemingLock, order.getOrderId(), GemStakingConstants.ONE_HOUR, TimeUnit.SECONDS);
if (!isLocked) {
// 说明该用户在该池有进行中的赎回,拒绝继续
throw new BaseException("error.createRedeemOrder.existsRedeeming", GemStakingOrderErrorCode.SERVER_ERROR);
}
try {
// 你的业务逻辑
} finally {
// 释放锁
stringRedisTemplate.delete(redeemingLock);
}
}
}
setIfAbsent 方法:这个方法等价于 Redis 的 SET NX 命令,它会在键不存在时设置键,并返回一个布尔值表示设置是否成功。setIfAbsent 的第三和第四个参数设置过期时间,确保锁不会永久存在。delete 方法删除锁。为了更可靠地实现分布式锁,可以使用 Redis 的 Redisson 客户端,它提供了更高级的分布式锁功能,包括自动续期、看门狗机制等。
以下是使用 Redisson 实现分布式锁的示例:
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
@Service
public class YourService {
@Autowired
private RedissonClient redissonClient;
public void yourMethod(StakingPoolOrderDO order) {
String redeemingLock = StakingOrderCacheKeysUtils
.getUserRedeemCacheKey(order.getUserId(), order.getOrderToken(), order.getEarnToken());
RLock lock = redissonClient.getLock(redeemingLock);
boolean isLocked = false;
try {
// 尝试加锁,等待时间为0,锁定时间为1小时
isLocked = lock.tryLock(0, GemStakingConstants.ONE_HOUR, TimeUnit.SECONDS);
if (!isLocked) {
// 说明该用户在该池有进行中的赎回,拒绝继续
throw new BaseException("error.createRedeemOrder.existsRedeeming", GemStakingOrderErrorCode.SERVER_ERROR);
}
// 你的业务逻辑
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new BaseException("error.createRedeemOrder.lockError", GemStakingOrderErrorCode.SERVER_ERROR);
} finally {
if (isLocked) {
lock.unlock();
}
}
}
}
原始的代码虽然可以在某种程度上起到锁的作用,但它不是线程安全的分布式锁实现。通过使用 Redis 的原子操作或者 Redisson,可以实现更可靠的分布式锁。
public void createRedeemOrder(GemStakingOrderRequest order) {
//赎回是质押的逆向
//这边需要加一个分布式锁,避免重复赎回造成平台损失
String redeemingLock = StakingOrderCacheKeysUtils
.getUserRedeemCacheKey(order.getUserId(), order.getOrderToken(), order.getEarnToken());
RLock lock = redissonClient.getLock(redeemingLock);
try {
AssertUtil.assertTrue(lock.tryLock(), "error.createRedeemOrder.existsRedeeming",
CommonErrorCode.RATE_LIMITED);
} catch (BizException e) {
throw new BaseException("error.createRedeemOrder.existsRedeeming", e.getErrorCode());
} catch (Exception e) {
//如果redis出问题,拒绝赎回,涉及平台往外出资金
throw new BaseException("error.createRedeemOrder.redisError", GemStakingOrderErrorCode.SERVER_ERROR);
}
UserTransferLogDO transferLogDO = null;
StakingPoolOrderDO orderOpsDO = null;
//创建订单记录
order.setOrderId(ObjectId.getString());
orderOpsDO = buildToDBOrder(order);
//保存订单-新建
savePoolOrder(orderOpsDO);
//创建转账记录
transferLogDO = buildToDBTransferLog(order,TransferEvent.REDEEM.getCode());
//保存划账记录-新建
saveTransferLog(transferLogDO);
//发起转账
AccountTransferVO accountTransferVO = buildAccountTransferVO(order);
try {
GenericResult<AccountOpreationResponse> opreationResponseGenericResult = accountIntegrationService.transferV2(accountTransferVO);
if(opreationResponseGenericResult != null && opreationResponseGenericResult.isSuccess()) {
//转账成功
//此处必须调用数据库原子事务,将修改订单状态、转账记录状态、入持仓并入一个事务
transactionProcessService.processAfterTransferSuccess(transferLogDO,orderOpsDO);
//异步更新矿池已经质押额度和参与人次
//异步更新活动已经质押额度和参与人次
} else {
//解析失败原因
if(null != opreationResponseGenericResult && opreationResponseGenericResult.getCode().equals(NO_BALANCE.getCode())) {
//余额不足
//更新transferLog
transferLogDO.setFailReason(NO_BALANCE.getDescription());
throw new BaseException("error.createRedeemOrder.save2DB", GemStakingOrderErrorCode.SERVER_ERROR);
} else {
//其他原因
if(null == opreationResponseGenericResult) {
transferLogDO.setFailReason("createRedeemOrder.transfer.none.result");
} else {
transferLogDO.setFailReason(opreationResponseGenericResult.getMsg());
}
throw new BaseException("error.createRedeemOrder.save2DB", GemStakingOrderErrorCode.SERVER_ERROR);
}
}
} catch (Exception e) {
transactionProcessService.processAfterTransferFail(transferLogDO,orderOpsDO);
throw new BaseException(e.getMessage(), GemStakingOrderErrorCode.SERVER_ERROR);
} finally {
if (lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
} 该方法有没有问题
你的 createRedeemOrder 方法总体上是正确的,但仍有一些潜在问题和改进空间。下面是一些详细的建议:
在调用 lock.tryLock() 时,你没有指定等待时间。如果 Redis 出现问题或锁被其他线程持有,tryLock 将立即返回 false。为了提高鲁棒性,可以增加一个等待时间。
AssertUtil.assertTrue(lock.tryLock(10, TimeUnit.SECONDS), "error.createRedeemOrder.existsRedeeming", CommonErrorCode.RATE_LIMITED);
确保锁在最终块中释放,并且在任何情况下都能正确释放。你已经在 finally 块中处理了锁的释放,这很好。确保 lock.isHeldByCurrentThread() 只是一个安全检查。
你捕获了 BizException 和 Exception,并根据不同的情况抛出 BaseException。确保所有异常都能正确处理,尤其是那些可能导致事务失败的异常。
确保 transactionProcessService.processAfterTransferSuccess 和 transactionProcessService.processAfterTransferFail 方法中的事务控制是正确的。你已经在这些方法上使用了 @Transactional 注解,所以事务控制应该是有效的。
为了更清晰和易于维护,建议将某些逻辑分解成单独的方法。例如,创建订单和转账记录的逻辑可以提取到单独的方法中。
确保在关键路径上添加日志记录,方便以后调试和监控。
public void createRedeemOrder(GemStakingOrderRequest order) {
String redeemingLock = StakingOrderCacheKeysUtils
.getUserRedeemCacheKey(order.getUserId(), order.getOrderToken(), order.getEarnToken());
RLock lock = redissonClient.getLock(redeemingLock);
boolean isLocked = false;
try {
isLocked = lock.tryLock(10, TimeUnit.SECONDS);
AssertUtil.assertTrue(isLocked, "error.createRedeemOrder.existsRedeeming", CommonErrorCode.RATE_LIMITED);
UserTransferLogDO transferLogDO = null;
StakingPoolOrderDO orderOpsDO = null;
// 创建订单记录
order.setOrderId(ObjectId.getString());
orderOpsDO = buildToDBOrder(order);
savePoolOrder(orderOpsDO);
// 创建转账记录
transferLogDO = buildToDBTransferLog(order, TransferEvent.REDEEM.getCode());
saveTransferLog(transferLogDO);
// 发起转账
AccountTransferVO accountTransferVO = buildAccountTransferVO(order);
GenericResult<AccountOpreationResponse> opreationResponseGenericResult = accountIntegrationService.transferV2(accountTransferVO);
if (opreationResponseGenericResult != null && opreationResponseGenericResult.isSuccess()) {
// 转账成功,处理成功后的逻辑
transactionProcessService.processAfterTransferSuccess(transferLogDO, orderOpsDO);
// 异步更新矿池和活动的质押额度和参与人次
} else {
handleTransferFailure(opreationResponseGenericResult, transferLogDO);
}
} catch (BizException e) {
throw new BaseException("error.createRedeemOrder.existsRedeeming", e.getErrorCode());
} catch (Exception e) {
transactionProcessService.processAfterTransferFail(transferLogDO, orderOpsDO);
throw new BaseException("error.createRedeemOrder.redisError", GemStakingOrderErrorCode.SERVER_ERROR);
} finally {
if (isLocked && lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}
private void handleTransferFailure(GenericResult<AccountOpreationResponse> opreationResponseGenericResult, UserTransferLogDO transferLogDO) {
if (opreationResponseGenericResult != null && NO_BALANCE.getCode().equals(opreationResponseGenericResult.getCode())) {
transferLogDO.setFailReason(NO_BALANCE.getDescription());
} else {
transferLogDO.setFailReason(opreationResponseGenericResult != null ? opreationResponseGenericResult.getMsg() : "createRedeemOrder.transfer.none.result");
}
throw new BaseException("error.createRedeemOrder.save2DB", GemStakingOrderErrorCode.SERVER_ERROR);
}
tryLock 方法中增加等待时间,提高鲁棒性。finally 块中释放锁,以确保无论发生什么情况都能正确释放锁。通过这些改进,你的 createRedeemOrder 方法将会更加健壮和可维护。
<update id="updateParticipantsAndAmount" parameterType="map">
update staking_campaign_pool
<set>
real_staking_amount = real_staking_amount + #{amounts,jdbcType=DECIMAL},
real_staking_participants = real_staking_participants + 1,
</set>
where pool_id = #{poolId,jdbcType=BIGINT}
</update>根据这个写mapper接口
根据你提供的 MyBatis 映射文件中的 updateParticipantsAndAmount 更新语句,我们可以编写相应的 Mapper 接口。以下是一个示例:
首先定义一个 Mapper 接口 StakingCampaignPoolMapper,其中包含 updateParticipantsAndAmount 方法。
import org.apache.ibatis.annotations.Param;
import java.math.BigDecimal;
public interface StakingCampaignPoolMapper {
/**
* 更新质押金额和参与人数
*
* @param poolId 质押池的ID
* @param amounts 增加的质押金额
* @return 更新的行数
*/
int updateParticipantsAndAmount(@Param("poolId") Long poolId, @Param("amounts") BigDecimal amounts);
}
确保你的 MyBatis 映射文件包含正确的 SQL 语句和更新方法的映射:
<mapper namespace="com.example.StakingCampaignPoolMapper">
<update id="updateParticipantsAndAmount" parameterType="map">
update staking_campaign_pool
<set>
real_staking_amount = real_staking_amount + #{amounts,jdbcType=DECIMAL},
real_staking_participants = real_staking_participants + 1
</set>
where pool_id = #{poolId,jdbcType=BIGINT}
</update>
</mapper>
在你的服务类或其他业务逻辑中注入 StakingCampaignPoolMapper 并调用 updateParticipantsAndAmount 方法:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
@Service
public class StakingService {
@Autowired
private StakingCampaignPoolMapper stakingCampaignPoolMapper;
public void updateStakingPool(Long poolId, BigDecimal amounts) {
int rowsUpdated = stakingCampaignPoolMapper.updateParticipantsAndAmount(poolId, amounts);
if (rowsUpdated == 0) {
throw new RuntimeException("Failed to update staking pool");
}
}
}
updateParticipantsAndAmount 方法的 Mapper 接口。updateParticipantsAndAmount 方法来执行更新操作。通过这些步骤,你就可以在 Java 代码中调用 MyBatis 映射文件中的 updateParticipantsAndAmount 方法来更新数据库中的记录。
package com.kucoin.gemstaking.core.service.impl;
import com.kucoin.gemstaking.common.dal.dataobject.StakingCampaignBonusTaskDO;
import com.kucoin.gemstaking.common.dal.dataobject.StakingCampaignBonusTaskDOExample;
import com.kucoin.gemstaking.common.dal.mapper.StakingCampaignBonusTaskMapper;
import com.kucoin.gemstaking.core.service.CampaignBonusTaskService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class CampaignBonusTaskServiceImpl implements CampaignBonusTaskService {
@Autowired
private StakingCampaignBonusTaskMapper campaignBonusTaskMapper;
@Cacheable(value = "GEM_STAKING:TaskInfoByCampaignId#60#5", key = "#campaignId")
public List<StakingCampaignBonusTaskDO> getTaskInfoByCampaignId(String campaignId) {
StakingCampaignBonusTaskDOExample stakingCampaignBonusTaskDOExample = new StakingCampaignBonusTaskDOExample();
stakingCampaignBonusTaskDOExample.createCriteria().andCampaignIdEqualTo(campaignId);
return campaignBonusTaskMapper.selectByExample(stakingCampaignBonusTaskDOExample);
}
}
中的 @Cacheable(value = "GEM_STAKING:TaskInfoByCampaignId#60#5", key = "#campaignId")
什么意思
@Cacheable 注解用于在方法调用时自动将返回值缓存起来,以便后续调用时可以直接从缓存中获取数据,而不需要再次执行方法。这对于提高性能和减少数据库查询的次数非常有用。
具体到你的代码中的 @Cacheable(value = "GEM_STAKING:TaskInfoByCampaignId#60#5", key = "#campaignId") 注解,以下是各个部分的解释:
value 属性value 属性指定了缓存的名称。在你的例子中,value = "GEM_STAKING:TaskInfoByCampaignId#60#5" 包含了缓存名称以及一些过期时间和刷新时间的信息。这是一个自定义的格式,用于指定缓存的名称和管理缓存的行为。
GEM_STAKING:TaskInfoByCampaignId:这是缓存的名称,表示这个缓存区域存储的是与任务信息相关的数据。#60:表示缓存的过期时间为60秒。#5:表示缓存的刷新时间为5秒。这种格式可能是你们团队自定义的约定,用于统一管理缓存的过期和刷新策略。
key 属性key 属性指定了缓存条目的唯一标识符。在你的例子中,key = "#campaignId" 表示使用方法参数 campaignId 作为缓存的键。这意味着对于不同的 campaignId,将会有不同的缓存条目。
整体上,这个注解表示对于 getTaskInfoByCampaignId 方法,当传入相同的 campaignId 参数时,方法的返回值将被缓存60秒,并且每5秒刷新一次缓存。具体策略取决于缓存管理器的实现。
以下是你的代码的完整解释:
@Service
public class CampaignBonusTaskServiceImpl implements CampaignBonusTaskService {
@Autowired
private StakingCampaignBonusTaskMapper campaignBonusTaskMapper;
@Cacheable(value = "GEM_STAKING:TaskInfoByCampaignId#60#5", key = "#campaignId")
public List<StakingCampaignBonusTaskDO> getTaskInfoByCampaignId(String campaignId) {
StakingCampaignBonusTaskDOExample stakingCampaignBonusTaskDOExample = new StakingCampaignBonusTaskDOExample();
stakingCampaignBonusTaskDOExample.createCriteria().andCampaignIdEqualTo(campaignId);
return campaignBonusTaskMapper.selectByExample(stakingCampaignBonusTaskDOExample);
}
}
getTaskInfoByCampaignId 方法被调用时,如果缓存中已经有相应的 campaignId 的数据,方法不会被执行,直接返回缓存中的数据。campaignId 的数据,方法将被执行,并将返回值缓存起来。通过合理使用缓存注解,可以显著提升应用的性能,减少数据库的压力。
如果5秒刷新一次,这样的话,这个ek y
如果缓存每5秒刷新一次,这意味着缓存将会在每5秒钟重新加载一次数据,而不会等到缓存过期(60秒)才重新加载。这种配置适用于一些数据变化频率较高的场景,确保数据在缓存中的时效性较高。
不过在标准的 Spring Cache 注解中,@Cacheable 注解并没有提供直接设置刷新时间的功能。你提到的 #60#5 是一种自定义的缓存策略配置,可能是你们团队或框架的特定实现。通常情况下,我们需要借助一些高级的缓存管理库(例如 Caffeine 或 Redis)来实现这种行为。
Caffeine 是一个高性能的 Java 缓存库,支持缓存刷新机制。以下是一个使用 Caffeine 实现缓存刷新时间的示例:
引入依赖
在 pom.xml 中添加 Caffeine 依赖:
<dependency>
<groupId>com.github.ben-manes.caffeine</groupId>
<artifactId>caffeine</artifactId>
<version>2.9.2</version>
</dependency>
配置 Caffeine Cache
创建一个配置类来配置缓存:
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.caffeine.CaffeineCache;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.concurrent.TimeUnit;
@Configuration
@EnableCaching
public class CacheConfig {
@Bean
public CacheManager cacheManager() {
CaffeineCacheManager cacheManager = new CaffeineCacheManager("TaskInfoByCampaignId");
cacheManager.setCaffeine(Caffeine.newBuilder()
.expireAfterWrite(60, TimeUnit.SECONDS)
.refreshAfterWrite(5, TimeUnit.SECONDS));
return cacheManager;
}
}
使用缓存
在服务类中使用缓存注解:
@Service
public class CampaignBonusTaskServiceImpl implements CampaignBonusTaskService {
@Autowired
private StakingCampaignBonusTaskMapper campaignBonusTaskMapper;
@Cacheable(value = "TaskInfoByCampaignId", key = "#campaignId")
public List<StakingCampaignBonusTaskDO> getTaskInfoByCampaignId(String campaignId) {
StakingCampaignBonusTaskDOExample example = new StakingCampaignBonusTaskDOExample();
example.createCriteria().andCampaignIdEqualTo(campaignId);
return campaignBonusTaskMapper.selectByExample(example);
}
}
如果你使用的是 Redis 作为缓存,并且希望实现类似的刷新机制,你可能需要在缓存失效前主动更新缓存。这通常需要一些额外的逻辑来实现。
在标准的 Spring Cache 注解中,@Cacheable 注解不支持直接设置刷新时间。你提到的 #60#5 配置可能是你们团队或框架的特定实现,如果你使用的是标准 Spring Cache,你需要借助像 Caffeine 这样的高级缓存库来实现缓存刷新机制。
通过合理配置缓存策略,可以在保证数据时效性的同时,提高系统性能,减少数据库的压力。
public BigDecimal getUserBonusByUserAndCampaign(String userId, String campaignId) {
BigDecimal userBonus = BigDecimal.ZERO;
//先查用户
UserStakingTaskBonusDOExample userStakingTaskBonusDOExample = new UserStakingTaskBonusDOExample();
userStakingTaskBonusDOExample.createCriteria().andUserIdEqualTo(userId).andCampaignIdEqualTo(campaignId);
List<UserStakingTaskBonusDO> userStakingTaskBonusDOS = stakingTaskBonusMapper.selectByExample(userStakingTaskBonusDOExample);
if(CollectionUtils.isNotEmpty(userStakingTaskBonusDOS)) {
//遍历一下
userStakingTaskBonusDOS.forEach(userStakingTaskBonusDO -> {
userBonus.add(userStakingTaskBonusDO.getBonusCoefficient());
});
} else {
//针对VIP这种特殊奖励额外处理
}
return userBonus;
}
你提供的 getUserBonusByUserAndCampaign 方法中有一些需要改进的地方,尤其是在累加奖金时。BigDecimal 是不可变的对象,因此在累加时需要使用 add 方法赋值给原变量。此外,注释中提到针对 VIP 奖励的特殊处理,但没有实现这部分逻辑。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.util.List;
import org.apache.commons.collections4.CollectionUtils;
@Service
public class CampaignBonusTaskServiceImpl {
@Autowired
private StakingTaskBonusMapper stakingTaskBonusMapper;
public BigDecimal getUserBonusByUserAndCampaign(String userId, String campaignId) {
BigDecimal userBonus = BigDecimal.ZERO;
// 先查用户
UserStakingTaskBonusDOExample userStakingTaskBonusDOExample = new UserStakingTaskBonusDOExample();
userStakingTaskBonusDOExample.createCriteria().andUserIdEqualTo(userId).andCampaignIdEqualTo(campaignId);
List<UserStakingTaskBonusDO> userStakingTaskBonusDOS = stakingTaskBonusMapper.selectByExample(userStakingTaskBonusDOExample);
if (CollectionUtils.isNotEmpty(userStakingTaskBonusDOS)) {
// 遍历累加奖金
for (UserStakingTaskBonusDO userStakingTaskBonusDO : userStakingTaskBonusDOS) {
userBonus = userBonus.add(userStakingTaskBonusDO.getBonusCoefficient());
}
} else {
// 针对 VIP 这种特殊奖励额外处理
userBonus = handleVipBonus(userId, campaignId);
}
return userBonus;
}
private BigDecimal handleVipBonus(String userId, String campaignId) {
// 这里是处理 VIP 奖励的逻辑,可以根据具体需求实现
// 返回一个示例值
return BigDecimal.ZERO;
}
}
userBonus = userBonus.add(userStakingTaskBonusDO.getBonusCoefficient()) 来确保累加操作正确。handleVipBonus 方法,用于处理 VIP 奖励的特殊逻辑。你可以根据具体业务需求实现这个方法。CollectionUtils.isNotEmpty:使用 CollectionUtils.isNotEmpty 来检查集合是否为空,可以避免空指针异常。add 方法会返回一个新的 BigDecimal 对象,因此需要将结果赋值回 userBonus。handleVipBonus,用于处理 VIP 奖励的特殊逻辑。你可以根据实际需求实现这个方法。通过这些改进,你的 getUserBonusByUserAndCampaign 方法将更加健壮和易于维护。
String bonusCoefficient = stakingBonusTaskVipconfigDO.getBonusCoefficient(); bonusCoefficient的格式是{"1":"1.2","2":"1.333","12":"0.2"},请用fastjson或者gson帮忙解析这个字符串并按照"1"取出value
你可以使用 FastJSON 或 Gson 来解析 JSON 字符串,并提取指定键的值。以下是两种方法的示例:
首先,确保你已经在项目中引入了 FastJSON 依赖。你可以在 pom.xml 中添加以下依赖:
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.75</version>
</dependency>
然后,你可以使用以下代码来解析 JSON 字符串并提取指定键的值:
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
public class JsonParser {
public static void main(String[] args) {
String bonusCoefficient = "{\"1\":\"1.2\",\"2\":\"1.333\",\"12\":\"0.2\"}";
JSONObject jsonObject = JSON.parseObject(bonusCoefficient);
String value = jsonObject.getString("1");
System.out.println("Value for key '1': " + value);
}
}
首先,确保你已经在项目中引入了 Gson 依赖。你可以在 pom.xml 中添加以下依赖:
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.6</version>
</dependency>
然后,你可以使用以下代码来解析 JSON 字符串并提取指定键的值:
import com.google.gson.Gson;
import com.google.gson.JsonObject;
public class JsonParser {
public static void main(String[] args) {
String bonusCoefficient = "{\"1\":\"1.2\",\"2\":\"1.333\",\"12\":\"0.2\"}";
Gson gson = new Gson();
JsonObject jsonObject = gson.fromJson(bonusCoefficient, JsonObject.class);
String value = jsonObject.get("1").getAsString();
System.out.println("Value for key '1': " + value);
}
}
JSON.parseObject 方法将 JSON 字符串解析为 JSONObject,然后使用 jsonObject.getString("1") 获取指定键的值。gson.fromJson 方法将 JSON 字符串解析为 JsonObject,然后使用 jsonObject.get("1").getAsString() 获取指定键的值。你可以根据自己的项目依赖和开发习惯选择使用 FastJSON 或 Gson。两者都能方便地解析 JSON 字符串并提取指定键的值。
private BigDecimal handleVIPBonus(String userId,String campaignId) {
List<StakingCampaignBonusTaskDO> stakingCampaignBonusTaskDOS = campaignBonusTaskService.getTaskInfoByCampaignId(campaignId);
//看看是否开启了VIP任务
if (CollectionUtils.isNotEmpty(stakingCampaignBonusTaskDOS)) {
for (StakingCampaignBonusTaskDO stakingCampaignBonusTaskDO : stakingCampaignBonusTaskDOS) {
if (stakingCampaignBonusTaskDO.getTaskType().equals(1)) {
//拿到VIP的加成系数,并返回
StakingBonusTaskVipconfigDO stakingBonusTaskVipconfigDO = vipConfigService.getVIPConfigByCampaign(campaignId);
if (null != stakingBonusTaskVipconfigDO) {
//VIP加成系数
String bonusCoefficient = stakingBonusTaskVipconfigDO.getBonusCoefficient();
//用户VIP level
UserVipResponse userVipResponse = userService.getUserVipInfo(userId);
if (null != userVipResponse) {
int vipLevel = userVipResponse.getUserLevel();
Gson gson = new Gson();
JsonObject jsonObject = gson.fromJson(bonusCoefficient, JsonObject.class);
String value = jsonObject.get("1").getAsString();
return new BigDecimal(value);
} else {
return BigDecimal.ZERO;
}
} else {
return BigDecimal.ZERO;
}
}
}
}
return BigDecimal.ZERO;
}
你的 handleVIPBonus 方法大致上是正确的,但有一些需要改进的地方:
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.util.List;
@Service
public class CampaignBonusTaskServiceImpl {
@Autowired
private CampaignBonusTaskService campaignBonusTaskService;
@Autowired
private VipConfigService vipConfigService;
@Autowired
private UserService userService;
private BigDecimal handleVIPBonus(String userId, String campaignId) {
List<StakingCampaignBonusTaskDO> stakingCampaignBonusTaskDOS = campaignBonusTaskService.getTaskInfoByCampaignId(campaignId);
// 看看是否开启了VIP任务
if (CollectionUtils.isNotEmpty(stakingCampaignBonusTaskDOS)) {
for (StakingCampaignBonusTaskDO stakingCampaignBonusTaskDO : stakingCampaignBonusTaskDOS) {
if (stakingCampaignBonusTaskDO.getTaskType().equals(1)) {
// 拿到VIP的加成系数,并返回
StakingBonusTaskVipconfigDO stakingBonusTaskVipconfigDO = vipConfigService.getVIPConfigByCampaign(campaignId);
if (null != stakingBonusTaskVipconfigDO) {
// VIP加成系数
String bonusCoefficient = stakingBonusTaskVipconfigDO.getBonusCoefficient();
// 用户VIP level
UserVipResponse userVipResponse = userService.getUserVipInfo(userId);
if (null != userVipResponse) {
int vipLevel = userVipResponse.getUserLevel();
return getVipBonusCoefficient(bonusCoefficient, vipLevel);
}
}
}
}
}
return BigDecimal.ZERO;
}
private BigDecimal getVipBonusCoefficient(String bonusCoefficient, int vipLevel) {
try {
Gson gson = new Gson();
JsonObject jsonObject = gson.fromJson(bonusCoefficient, JsonObject.class);
if (jsonObject.has(String.valueOf(vipLevel))) {
String value = jsonObject.get(String.valueOf(vipLevel)).getAsString();
return new BigDecimal(value);
}
} catch (Exception e) {
// 处理解析异常,可以记录日志或抛出异常
e.printStackTrace();
}
return BigDecimal.ZERO;
}
}
getVipBonusCoefficient 方法来解析 JSON 字符串,并根据用户的实际 VIP 等级获取相应的加成系数。getVipBonusCoefficient 方法中添加了异常处理,以防在解析 JSON 时发生错误。getVipBonusCoefficient 中,提高了代码的可读性和可维护性。CollectionUtils.isNotEmpty:检查集合是否为空,避免空指针异常。getVipBonusCoefficient 方法:用于解析 JSON 字符串,并根据 VIP 等级获取相应的加成系数。如果解析失败或没有找到对应的 VIP 等级,返回 BigDecimal.ZERO。通过这些改进,你的 handleVIPBonus 方法将更加健壮和易于维护。
package com.kucoin.gemstaking.core.service.impl;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import com.kucoin.gemstaking.common.dal.dataobject.StakingBonusTaskVipconfigDO;
import com.kucoin.gemstaking.common.dal.dataobject.StakingCampaignBonusTaskDO;
import com.kucoin.gemstaking.common.dal.dataobject.UserStakingTaskBonusDO;
import com.kucoin.gemstaking.common.dal.dataobject.UserStakingTaskBonusDOExample;
import com.kucoin.gemstaking.common.dal.mapper.UserStakingTaskBonusMapper;
import com.kucoin.gemstaking.common.service.integration.user.UserService;
import com.kucoin.gemstaking.common.service.integration.user.vo.UserVipResponse;
import com.kucoin.gemstaking.core.service.UserStakingTaskBonusService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.List;
@Service
@Slf4j
public class UserStakingTaskBonusServiceImpl implements UserStakingTaskBonusService {
@Autowired
private UserStakingTaskBonusMapper stakingTaskBonusMapper;
@Autowired
private CampaignBonusTaskServiceImpl campaignBonusTaskService;
@Autowired
private StakingBonusTaskVIPConfigService vipConfigService;
@Resource
private UserService userService;
@Override
public BigDecimal getUserBonusByUserAndCampaign(String userId, String campaignId) {
BigDecimal userBonus = BigDecimal.ZERO;
//先查用户
UserStakingTaskBonusDOExample userStakingTaskBonusDOExample = new UserStakingTaskBonusDOExample();
userStakingTaskBonusDOExample.createCriteria().andUserIdEqualTo(userId).andCampaignIdEqualTo(campaignId);
List<UserStakingTaskBonusDO> userStakingTaskBonusDOS = stakingTaskBonusMapper.selectByExample(userStakingTaskBonusDOExample);
if(CollectionUtils.isNotEmpty(userStakingTaskBonusDOS)) {
//遍历一下
boolean hasVIP = Boolean.FALSE;
for (UserStakingTaskBonusDO userStakingTaskBonusDO : userStakingTaskBonusDOS) {
if(userStakingTaskBonusDO.getTaskType() == 1) {
hasVIP = Boolean.TRUE;
}
userBonus = userBonus.add(userStakingTaskBonusDO.getBonusCoefficient());
}
if(!hasVIP) {
//这里要考虑把VIP的奖励处理
userBonus = userBonus.add(handleVIPBonus(userId,campaignId));
}
} else {
//针对VIP这种特殊奖励额外处理
userBonus = userBonus.add(handleVIPBonus(userId,campaignId));
}
return userBonus;
}
private BigDecimal handleVIPBonus(String userId,String campaignId) {
List<StakingCampaignBonusTaskDO> stakingCampaignBonusTaskDOS = campaignBonusTaskService.getTaskInfoByCampaignId(campaignId);
// 看看是否开启了VIP任务
if (CollectionUtils.isNotEmpty(stakingCampaignBonusTaskDOS)) {
for (StakingCampaignBonusTaskDO stakingCampaignBonusTaskDO : stakingCampaignBonusTaskDOS) {
if (stakingCampaignBonusTaskDO.getTaskType().equals(1)) {
// 拿到VIP的加成系数,并返回
StakingBonusTaskVipconfigDO stakingBonusTaskVipconfigDO = vipConfigService.getVIPConfigByCampaign(campaignId);
if (null != stakingBonusTaskVipconfigDO) {
// VIP加成系数
String bonusCoefficient = stakingBonusTaskVipconfigDO.getBonusCoefficient();
// 用户VIP level
UserVipResponse userVipResponse = userService.getUserVipInfo(userId);
if (null != userVipResponse) {
int vipLevel = userVipResponse.getUserLevel();
return getVipBonusCoefficient(bonusCoefficient, vipLevel);
}
}
}
}
}
return BigDecimal.ZERO;
}
private BigDecimal getVipBonusCoefficient(String bonusCoefficient, int vipLevel) {
try {
Gson gson = new Gson();
JsonObject jsonObject = gson.fromJson(bonusCoefficient, JsonObject.class);
if (null != jsonObject && jsonObject.has(String.valueOf(vipLevel))) {
String value = jsonObject.get(String.valueOf(vipLevel)).getAsString();
return new BigDecimal(value);
}
} catch (Exception e) {
// 处理解析异常,可以记录日志或抛出异常
log.error("gem.staking.getVipBonusCoefficient.jsonParse.error,param:{}",bonusCoefficient);
}
return BigDecimal.ZERO;
}
}
你的代码基本上是正确的,但是有一些可以改进的地方,特别是在代码结构和异常处理方面。以下是一些改进建议:
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import com.kucoin.gemstaking.common.dal.dataobject.StakingBonusTaskVipconfigDO;
import com.kucoin.gemstaking.common.dal.dataobject.StakingCampaignBonusTaskDO;
import com.kucoin.gemstaking.common.dal.dataobject.UserStakingTaskBonusDO;
import com.kucoin.gemstaking.common.dal.dataobject.UserStakingTaskBonusDOExample;
import com.kucoin.gemstaking.common.dal.mapper.UserStakingTaskBonusMapper;
import com.kucoin.gemstaking.common.service.integration.user.UserService;
import com.kucoin.gemstaking.common.service.integration.user.vo.UserVipResponse;
import com.kucoin.gemstaking.core.service.CampaignBonusTaskService;
import com.kucoin.gemstaking.core.service.StakingBonusTaskVIPConfigService;
import com.kucoin.gemstaking.core.service.UserStakingTaskBonusService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.List;
@Service
@Slf4j
public class UserStakingTaskBonusServiceImpl implements UserStakingTaskBonusService {
private static final int VIP_TASK_TYPE = 1;
@Autowired
private UserStakingTaskBonusMapper stakingTaskBonusMapper;
@Autowired
private CampaignBonusTaskService campaignBonusTaskService;
@Autowired
private StakingBonusTaskVIPConfigService vipConfigService;
@Resource
private UserService userService;
@Override
public BigDecimal getUserBonusByUserAndCampaign(String userId, String campaignId) {
BigDecimal userBonus = BigDecimal.ZERO;
List<UserStakingTaskBonusDO> userStakingTaskBonusDOS = getUserStakingTaskBonuses(userId, campaignId);
if (CollectionUtils.isNotEmpty(userStakingTaskBonusDOS)) {
boolean hasVIP = false;
for (UserStakingTaskBonusDO userStakingTaskBonusDO : userStakingTaskBonusDOS) {
if (userStakingTaskBonusDO.getTaskType() == VIP_TASK_TYPE) {
hasVIP = true;
}
userBonus = userBonus.add(userStakingTaskBonusDO.getBonusCoefficient());
}
if (!hasVIP) {
userBonus = userBonus.add(handleVIPBonus(userId, campaignId));
}
} else {
userBonus = userBonus.add(handleVIPBonus(userId, campaignId));
}
return userBonus;
}
private List<UserStakingTaskBonusDO> getUserStakingTaskBonuses(String userId, String campaignId) {
UserStakingTaskBonusDOExample example = new UserStakingTaskBonusDOExample();
example.createCriteria().andUserIdEqualTo(userId).andCampaignIdEqualTo(campaignId);
return stakingTaskBonusMapper.selectByExample(example);
}
private BigDecimal handleVIPBonus(String userId, String campaignId) {
List<StakingCampaignBonusTaskDO> stakingCampaignBonusTaskDOS = campaignBonusTaskService.getTaskInfoByCampaignId(campaignId);
if (CollectionUtils.isNotEmpty(stakingCampaignBonusTaskDOS)) {
for (StakingCampaignBonusTaskDO task : stakingCampaignBonusTaskDOS) {
if (VIP_TASK_TYPE == task.getTaskType()) {
StakingBonusTaskVipconfigDO vipConfig = vipConfigService.getVIPConfigByCampaign(campaignId);
if (vipConfig != null) {
UserVipResponse userVipResponse = userService.getUserVipInfo(userId);
if (userVipResponse != null) {
return getVipBonusCoefficient(vipConfig.getBonusCoefficient(), userVipResponse.getUserLevel());
}
}
}
}
}
return BigDecimal.ZERO;
}
private BigDecimal getVipBonusCoefficient(String bonusCoefficient, int vipLevel) {
try {
Gson gson = new Gson();
JsonObject jsonObject = gson.fromJson(bonusCoefficient, JsonObject.class);
if (jsonObject != null && jsonObject.has(String.valueOf(vipLevel))) {
return new BigDecimal(jsonObject.get(String.valueOf(vipLevel)).getAsString());
}
} catch (Exception e) {
log.error("Error parsing VIP bonus coefficient JSON: {}", bonusCoefficient, e);
}
return BigDecimal.ZERO;
}
}
常量使用:
VIP_TASK_TYPE 常量,避免直接使用数字,提高代码可读性。提取方法:
getUserStakingTaskBonuses 方法中。getUserBonusByUserAndCampaign 方法更简洁。异常处理:
log.error 记录详细的错误信息,包括 bonusCoefficient 和异常堆栈信息。代码结构优化:
handleVIPBonus 方法的逻辑,提高了代码的可读性和可维护性。通过这些改进,你的代码将更加健壮、易读和易于维护。
CREATE TABLE gem_staking.user_staking_earn (
id BIGINT AUTO_INCREMENT COMMENT '主键ID',
bus_id CHAR(24) NOT NULL DEFAULT '' COMMENT '唯一ID',
user_id CHAR(24) NOT NULL DEFAULT '' COMMENT '用户ID',
campaign_id CHAR(24) NOT NULL DEFAULT '' COMMENT '活动ID',
pool_id CHAR(24) NOT NULL DEFAULT '' COMMENT '矿池ID',
staking_hold_amount DECIMAL(38, 20) NOT NULL COMMENT '当时持仓',
earn_amount DECIMAL(38, 20) NOT NULL COMMENT '奖励数量',
earn_token CHAR(24) NOT NULL COMMENT '奖励币种',
earn_token_logo VARCHAR(200) NOT NULL COMMENT '奖励币种logo',
staking_token CHAR(24) NOT NULL COMMENT '质押币种',
staking_token_logo VARCHAR(200) NOT NULL COMMENT '质押币种logo',
earn_state INT NOT NULL COMMENT '领取状态,0,待领取,领取成功,领取失败',,
earn_type INT NOT NULL COMMENT '领取方式,0:手动,1:系统自动分发',
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (id),
KEY id_campaign_user_pool (user_id,campaign_id,pool_id) USING BTREE,
KEY id_user_pool (user_id,campaign_id,earn_state) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='用户收益表';根据上表,生成sql,实现根据user_id和campaign_id,以pool分组,统计待领取的收益总额。
要根据 user_id 和 campaign_id 以 pool_id 分组,统计待领取的收益总额,可以编写如下 SQL 查询:
SELECT
pool_id,
SUM(earn_amount) AS total_earn_amount
FROM
gem_staking.user_staking_earn
WHERE
user_id = 'your_user_id'
AND campaign_id = 'your_campaign_id'
AND earn_state = 0 -- 0 表示待领取
GROUP BY
pool_id;
选择的字段:
pool_id:我们需要按 pool_id 分组。SUM(earn_amount) AS total_earn_amount:计算每个 pool_id 的待领取收益总额,并将结果命名为 total_earn_amount。条件:
user_id = 'your_user_id':过滤指定的用户ID。campaign_id = 'your_campaign_id':过滤指定的活动ID。earn_state = 0:仅选择待领取的收益。分组:
GROUP BY pool_id:按 pool_id 分组。假设你的 user_id 是 '123456',campaign_id 是 'abcdef',查询语句如下:
SELECT
pool_id,
SUM(earn_amount) AS total_earn_amount
FROM
gem_staking.user_staking_earn
WHERE
user_id = '123456'
AND campaign_id = 'abcdef'
AND earn_state = 0 -- 0 表示待领取
GROUP BY
pool_id;
假设你的 user_staking_earn 表中有以下数据:
| id | bus_id | user_id | campaign_id | pool_id | staking_hold_amount | earn_amount | earn_token | earn_token_logo | staking_token | staking_token_logo | earn_state | earn_type | created_at | updated_at |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | ... | 123456 | abcdef | pool1 | ... | 10.00 | ... | ... | ... | ... | 0 | 0 | ... | ... |
| 2 | ... | 123456 | abcdef | pool2 | ... | 20.00 | ... | ... | ... | ... | 0 | 0 | ... | ... |
| 3 | ... | 123456 | abcdef | pool1 | ... | 5.00 | ... | ... | ... | ... | 0 | 0 | ... | ... |
| 4 | ... | 123456 | abcdef | pool2 | ... | 15.00 | ... | ... | ... | ... | 1 | 0 | ... | ... |
执行上述查询语句后,结果将如下:
| pool_id | total_earn_amount |
|---|---|
| pool1 | 15.00 |
| pool2 | 20.00 |
pool1 的待领取收益总额为 10.00 + 5.00 = 15.00。pool2 的待领取收益总额为 20.00(注意第 4 行的 earn_state = 1,因此不计入待领取收益)。通过这种方式,你可以轻松统计每个池子的待领取收益总额。
请生成sql根据campaign_id分组,返回每个campaign已领取的数量、未领取的数量、earn_token、earn_token_logo,每个campaign只有一个earn_token,有多个pool
要根据 campaign_id 分组,返回每个 campaign 的已领取数量、未领取数量、earn_token 和 earn_token_logo,可以使用以下 SQL 查询:
SELECT
campaign_id,
earn_token,
earn_token_logo,
SUM(CASE WHEN earn_state = 0 THEN 1 ELSE 0 END) AS unclaimed_count,
SUM(CASE WHEN earn_state = 1 THEN 1 ELSE 0 END) AS claimed_count
FROM
gem_staking.user_staking_earn
GROUP BY
campaign_id,
earn_token,
earn_token_logo;
选择的字段:
campaign_id:我们需要按 campaign_id 分组。earn_token 和 earn_token_logo:每个 campaign 只有一个 earn_token 和 earn_token_logo。SUM(CASE WHEN earn_state = 0 THEN 1 ELSE 0 END) AS unclaimed_count:计算未领取的数量(earn_state = 0 表示待领取)。SUM(CASE WHEN earn_state = 1 THEN 1 ELSE 0 END) AS claimed_count:计算已领取的数量(earn_state = 1 表示领取成功)。条件:
campaign_id 的信息。分组:
GROUP BY campaign_id, earn_token, earn_token_logo:按 campaign_id、earn_token 和 earn_token_logo 分组。假设你的 user_staking_earn 表中有以下数据:
| id | bus_id | user_id | campaign_id | pool_id | staking_hold_amount | earn_amount | earn_token | earn_token_logo | staking_token | staking_token_logo | earn_state | earn_type | created_at | updated_at |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | ... | 123456 | campaign1 | pool1 | ... | 10.00 | tokenA | logoA | ... | ... | 0 | 0 | ... | ... |
| 2 | ... | 123456 | campaign1 | pool2 | ... | 20.00 | tokenA | logoA | ... | ... | 1 | 0 | ... | ... |
| 3 | ... | 123456 | campaign2 | pool1 | ... | 5.00 | tokenB | logoB | ... | ... | 0 | 0 | ... | ... |
| 4 | ... | 123456 | campaign2 | pool2 | ... | 15.00 | tokenB | logoB | ... | ... | 1 | 0 | ... | ... |
| 5 | ... | 123456 | campaign1 | pool1 | ... | 8.00 | tokenA | logoA | ... | ... | 1 | 0 | ... | ... |
执行上述查询语句后,结果将如下:
| campaign_id | earn_token | earn_token_logo | unclaimed_count | claimed_count |
|---|---|---|---|---|
| campaign1 | tokenA | logoA | 1 | 2 |
| campaign2 | tokenB | logoB | 1 | 1 |
campaign1 中:
unclaimed_count 为 1(第 1 行)。claimed_count 为 2(第 2 行和第 5 行)。campaign2 中:
unclaimed_count 为 1(第 3 行)。claimed_count 为 1(第 4 行)。通过这种方式,你可以统计每个 campaign_id 的已领取和未领取数量,以及对应的 earn_token 和 earn_token_logo。
还需要返回pool_id
要在结果中包含 pool_id,你可以在查询中按 campaign_id 和 pool_id 分组,并返回每个 pool_id 的已领取数量、未领取数量、earn_token 和 earn_token_logo。以下是修改后的 SQL 查询:
SELECT
campaign_id,
pool_id,
earn_token,
earn_token_logo,
SUM(CASE WHEN earn_state = 0 THEN 1 ELSE 0 END) AS unclaimed_count,
SUM(CASE WHEN earn_state = 1 THEN 1 ELSE 0 END) AS claimed_count
FROM
gem_staking.user_staking_earn
GROUP BY
campaign_id,
pool_id,
earn_token,
earn_token_logo;
选择的字段:
campaign_id:按 campaign_id 分组。pool_id:按 pool_id 分组。earn_token 和 earn_token_logo:每个 campaign 只有一个 earn_token 和 earn_token_logo。SUM(CASE WHEN earn_state = 0 THEN 1 ELSE 0 END) AS unclaimed_count:计算未领取的数量(earn_state = 0 表示待领取)。SUM(CASE WHEN earn_state = 1 THEN 1 ELSE 0 END) AS claimed_count:计算已领取的数量(earn_state = 1 表示领取成功)。条件:
campaign_id 的信息。分组:
GROUP BY campaign_id, pool_id, earn_token, earn_token_logo:按 campaign_id、pool_id、earn_token 和 earn_token_logo 分组。假设你的 user_staking_earn 表中有以下数据:
| id | bus_id | user_id | campaign_id | pool_id | staking_hold_amount | earn_amount | earn_token | earn_token_logo | staking_token | staking_token_logo | earn_state | earn_type | created_at | updated_at |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | ... | 123456 | campaign1 | pool1 | ... | 10.00 | tokenA | logoA | ... | ... | 0 | 0 | ... | ... |
| 2 | ... | 123456 | campaign1 | pool2 | ... | 20.00 | tokenA | logoA | ... | ... | 1 | 0 | ... | ... |
| 3 | ... | 123456 | campaign2 | pool1 | ... | 5.00 | tokenB | logoB | ... | ... | 0 | 0 | ... | ... |
| 4 | ... | 123456 | campaign2 | pool2 | ... | 15.00 | tokenB | logoB | ... | ... | 1 | 0 | ... | ... |
| 5 | ... | 123456 | campaign1 | pool1 | ... | 8.00 | tokenA | logoA | ... | ... | 1 | 0 | ... | ... |
执行上述查询语句后,结果将如下:
| campaign_id | pool_id | earn_token | earn_token_logo | unclaimed_count | claimed_count |
|---|---|---|---|---|---|
| campaign1 | pool1 | tokenA | logoA | 1 | 1 |
| campaign1 | pool2 | tokenA | logoA | 0 | 1 |
| campaign2 | pool1 | tokenB | logoB | 1 | 0 |
| campaign2 | pool2 | tokenB | logoB | 0 | 1 |
campaign1 中:
pool1 的 unclaimed_count 为 1(第 1 行),claimed_count 为 1(第 5 行)。pool2 的 unclaimed_count 为 0,claimed_count 为 1(第 2 行)。campaign2 中:
pool1 的 unclaimed_count 为 1(第 3 行),claimed_count 为 0。pool2 的 unclaimed_count 为 0,claimed_count 为 1(第 4 行)。通过这种方式,你可以按 campaign_id 和 pool_id 分组,统计每个 campaign 和 pool 的已领取和未领取数量,以及对应的 earn_token 和 earn_token_logo。
claimed_count这不是想要的,而是想要待领取的earn_amount
明白了,你希望返回每个 campaign_id 下的 pool_id 分组后,统计待领取的 earn_amount 总和,而不仅仅是计算待领取的数量。以下是修改后的 SQL 查询:
SELECT
campaign_id,
pool_id,
earn_token,
earn_token_logo,
SUM(CASE WHEN earn_state = 0 THEN earn_amount ELSE 0 END) AS unclaimed_amount,
SUM(CASE WHEN earn_state = 1 THEN earn_amount ELSE 0 END) AS claimed_amount
FROM
gem_staking.user_staking_earn
GROUP BY
campaign_id,
pool_id,
earn_token,
earn_token_logo;
选择的字段:
campaign_id:按 campaign_id 分组。pool_id:按 pool_id 分组。earn_token 和 earn_token_logo:每个 campaign 只有一个 earn_token 和 earn_token_logo。SUM(CASE WHEN earn_state = 0 THEN earn_amount ELSE 0 END) AS unclaimed_amount:计算未领取的收益总额(earn_state = 0 表示待领取)。SUM(CASE WHEN earn_state = 1 THEN earn_amount ELSE 0 END) AS claimed_amount:计算已领取的收益总额(earn_state = 1 表示领取成功)。分组:
GROUP BY campaign_id, pool_id, earn_token, earn_token_logo:按 campaign_id、pool_id、earn_token 和 earn_token_logo 分组。假设你的 user_staking_earn 表中有以下数据:
| id | bus_id | user_id | campaign_id | pool_id | staking_hold_amount | earn_amount | earn_token | earn_token_logo | staking_token | staking_token_logo | earn_state | earn_type | created_at | updated_at |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | ... | 123456 | campaign1 | pool1 | ... | 10.00 | tokenA | logoA | ... | ... | 0 | 0 | ... | ... |
| 2 | ... | 123456 | campaign1 | pool2 | ... | 20.00 | tokenA | logoA | ... | ... | 1 | 0 | ... | ... |
| 3 | ... | 123456 | campaign2 | pool1 | ... | 5.00 | tokenB | logoB | ... | ... | 0 | 0 | ... | ... |
| 4 | ... | 123456 | campaign2 | pool2 | ... | 15.00 | tokenB | logoB | ... | ... | 1 | 0 | ... | ... |
| 5 | ... | 123456 | campaign1 | pool1 | ... | 8.00 | tokenA | logoA | ... | ... | 1 | 0 | ... | ... |
执行上述查询语句后,结果将如下:
| campaign_id | pool_id | earn_token | earn_token_logo | unclaimed_amount | claimed_amount |
|---|---|---|---|---|---|
| campaign1 | pool1 | tokenA | logoA | 10.00 | 8.00 |
| campaign1 | pool2 | tokenA | logoA | 0.00 | 20.00 |
| campaign2 | pool1 | tokenB | logoB | 5.00 | 0.00 |
| campaign2 | pool2 | tokenB | logoB | 0.00 | 15.00 |
campaign1 中:
pool1 的 unclaimed_amount 为 10.00(第 1 行),claimed_amount 为 8.00(第 5 行)。pool2 的 unclaimed_amount 为 0.00,claimed_amount 为 20.00(第 2 行)。campaign2 中:
pool1 的 unclaimed_amount 为 5.00(第 3 行),claimed_amount 为 0.00。pool2 的 unclaimed_amount 为 0.00,claimed_amount 为 15.00(第 4 行)。通过这种方式,你可以按 campaign_id 和 pool_id 分组,统计每个 campaign 和 pool 的待领取和已领取的收益总额,以及对应的 earn_token 和 earn_token_logo。
<select id="selectPoolSummary" parameterType="java.lang.String" resultType="com.kucoin.gemstakingfront.common.dal.dataobject.manual.PoolUnclaimedDO">
SELECT
campaign_id,
staking_token,
SUM(CASE WHEN earn_state = 0 THEN earn_amount ELSE 0 END) AS pool_unclaimed_rewards,
FROM
gem_staking.user_staking_earn
WHERE user_id = #{userId,jdbcType=CHAR}
AND campaign_id = #{campaignId,jdbcType=CHAR}
GROUP BY
pool_id,
staking_token
</select> 请帮忙纠正一下
你的 SQL 语句中有一些小问题需要纠正:
AS pool_unclaimed_rewards 后面有一个多余的逗号。pool_id 的选择:虽然你在 GROUP BY 中使用了 pool_id,但是在 SELECT 子句中没有选择 pool_id。以下是修正后的 SQL 语句:
<select id="selectPoolSummary" parameterType="java.lang.String" resultType="com.kucoin.gemstakingfront.common.dal.dataobject.manual.PoolUnclaimedDO">
SELECT
campaign_id,
pool_id,
staking_token,
SUM(CASE WHEN earn_state = 0 THEN earn_amount ELSE 0 END) AS pool_unclaimed_rewards
FROM
gem_staking.user_staking_earn
WHERE
user_id = #{userId,jdbcType=CHAR}
AND campaign_id = #{campaignId,jdbcType=CHAR}
GROUP BY
campaign_id,
pool_id,
staking_token
</select>
选择的字段:
campaign_id、pool_id 和 staking_token:这些字段用于分组并且在查询结果中返回。SUM(CASE WHEN earn_state = 0 THEN earn_amount ELSE 0 END) AS pool_unclaimed_rewards:计算每个 pool_id 的待领取收益总额。过滤条件:
user_id = #{userId,jdbcType=CHAR}:过滤指定用户ID。campaign_id = #{campaignId,jdbcType=CHAR}:过滤指定活动ID。分组:
GROUP BY campaign_id, pool_id, staking_token:按 campaign_id、pool_id 和 staking_token 分组。确保你的 PoolUnclaimedDO 类具有与查询结果字段匹配的属性。例如:
package com.kucoin.gemstakingfront.common.dal.dataobject.manual;
import java.math.BigDecimal;
public class PoolUnclaimedDO {
private String campaignId;
private String poolId;
private String stakingToken;
private BigDecimal poolUnclaimedRewards;
// Getters and Setters
public String getCampaignId() {
return campaignId;
}
public void setCampaignId(String campaignId) {
this.campaignId = campaignId;
}
public String getPoolId() {
return poolId;
}
public void setPoolId(String poolId) {
this.poolId = poolId;
}
public String getStakingToken() {
return stakingToken;
}
public void setStakingToken(String stakingToken) {
this.stakingToken = stakingToken;
}
public BigDecimal getPoolUnclaimedRewards() {
return poolUnclaimedRewards;
}
public void setPoolUnclaimedRewards(BigDecimal poolUnclaimedRewards) {
this.poolUnclaimedRewards = poolUnclaimedRewards;
}
}
通过这些修正,你的 SQL 查询应该能够正确地根据 user_id 和 campaign_id 过滤数据,并按 pool_id 和 staking_token 分组,统计每个 pool_id 的待领取收益总额。
parameterType="java.lang.String"这样正确吗,where条件有两个
你是对的,parameterType="java.lang.String" 只适用于单一参数的情况。如果你的 WHERE 子句中有多个参数(例如 userId 和 campaignId),你需要使用一个包含这些参数的对象或一个 Map。
Map 作为参数类型你可以使用 Map 来传递多个参数。以下是 XML 配置和 Java 代码的示例:
XML 配置:
<select id="selectPoolSummary" parameterType="map" resultType="com.kucoin.gemstakingfront.common.dal.dataobject.manual.PoolUnclaimedDO">
SELECT
campaign_id,
pool_id,
staking_token,
SUM(CASE WHEN earn_state = 0 THEN earn_amount ELSE 0 END) AS pool_unclaimed_rewards
FROM
gem_staking.user_staking_earn
WHERE
user_id = #{userId,jdbcType=CHAR}
AND campaign_id = #{campaignId,jdbcType=CHAR}
GROUP BY
campaign_id,
pool_id,
staking_token
</select>
Java 代码:
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public interface UserStakingEarnMapper {
List<PoolUnclaimedDO> selectPoolSummary(Map<String, Object> params);
}
// 调用示例
Map<String, Object> params = new HashMap<>();
params.put("userId", "yourUserId");
params.put("campaignId", "yourCampaignId");
List<PoolUnclaimedDO> result = userStakingEarnMapper.selectPoolSummary(params);
你也可以创建一个自定义的参数对象来传递多个参数。以下是 XML 配置和 Java 代码的示例:
自定义参数对象:
public class UserCampaignParam {
private String userId;
private String campaignId;
// Getters and Setters
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public String getCampaignId() {
return campaignId;
}
public void setCampaignId(String campaignId) {
this.campaignId = campaignId;
}
}
XML 配置:
<select id="selectPoolSummary" parameterType="com.kucoin.gemstakingfront.common.dal.dataobject.manual.UserCampaignParam" resultType="com.kucoin.gemstakingfront.common.dal.dataobject.manual.PoolUnclaimedDO">
SELECT
campaign_id,
pool_id,
staking_token,
SUM(CASE WHEN earn_state = 0 THEN earn_amount ELSE 0 END) AS pool_unclaimed_rewards
FROM
gem_staking.user_staking_earn
WHERE
user_id = #{userId,jdbcType=CHAR}
AND campaign_id = #{campaignId,jdbcType=CHAR}
GROUP BY
campaign_id,
pool_id,
staking_token
</select>
Java 代码:
public interface UserStakingEarnMapper {
List<PoolUnclaimedDO> selectPoolSummary(UserCampaignParam param);
}
// 调用示例
UserCampaignParam param = new UserCampaignParam();
param.setUserId("yourUserId");
param.setCampaignId("yourCampaignId");
List<PoolUnclaimedDO> result = userStakingEarnMapper.selectPoolSummary(param);
确保你的 PoolUnclaimedDO 类定义正确,并包含查询结果中的字段。
package com.kucoin.gemstakingfront.common.dal.dataobject.manual;
import java.math.BigDecimal;
public class PoolUnclaimedDO {
private String campaignId;
private String poolId;
private String stakingToken;
private BigDecimal poolUnclaimedRewards;
// Getters and Setters
public String getCampaignId() {
return campaignId;
}
public void setCampaignId(String campaignId) {
this.campaignId = campaignId;
}
public String getPoolId() {
return poolId;
}
public void setPoolId(String poolId) {
this.poolId = poolId;
}
public String getStakingToken() {
return stakingToken;
}
public void setStakingToken(String stakingToken) {
this.stakingToken = stakingToken;
}
public BigDecimal getPoolUnclaimedRewards() {
return poolUnclaimedRewards;
}
public void setPoolUnclaimedRewards(BigDecimal poolUnclaimedRewards) {
this.poolUnclaimedRewards = poolUnclaimedRewards;
}
}
通过这些改进,你的 SQL 查询和 MyBatis 配置将能够正确处理多个参数,并返回每个 campaign_id 下按 pool_id 分组的待领取收益总额。
List<PoolUnclaimedVO> poolUnclaimedVOS = new ArrayList<>();
List<PoolUnclaimedDO> poolUnclaimedDOS = userStakingEarnMapper.selectPoolSummary(userId,unclaimedCampaignsVO.getCampaignId());把poolUnclaimedDOS转换为poolUnclaimedVOS,PoolUnclaimedVO和PoolUnclaimedDO属性一样
你可以通过遍历 poolUnclaimedDOS 列表,并将每个 PoolUnclaimedDO 对象转换为 PoolUnclaimedVO 对象来实现这一需求。由于这两个类的属性相同,可以直接使用构造函数或 setter 方法进行转换。
以下是如何将 poolUnclaimedDOS 列表转换为 poolUnclaimedVOS 列表的示例代码:
import java.util.ArrayList;
import java.util.List;
public class ConversionExample {
public static void main(String[] args) {
// 假设这些是从数据库查询得到的结果
List<PoolUnclaimedDO> poolUnclaimedDOS = userStakingEarnMapper.selectPoolSummary(userId, unclaimedCampaignsVO.getCampaignId());
// 将 PoolUnclaimedDO 列表转换为 PoolUnclaimedVO 列表
List<PoolUnclaimedVO> poolUnclaimedVOS = convertToPoolUnclaimedVO(poolUnclaimedDOS);
// 现在 poolUnclaimedVOS 包含转换后的对象
}
private static List<PoolUnclaimedVO> convertToPoolUnclaimedVO(List<PoolUnclaimedDO> poolUnclaimedDOS) {
List<PoolUnclaimedVO> poolUnclaimedVOS = new ArrayList<>();
for (PoolUnclaimedDO poolUnclaimedDO : poolUnclaimedDOS) {
PoolUnclaimedVO poolUnclaimedVO = new PoolUnclaimedVO();
poolUnclaimedVO.setCampaignId(poolUnclaimedDO.getCampaignId());
poolUnclaimedVO.setPoolId(poolUnclaimedDO.getPoolId());
poolUnclaimedVO.setStakingToken(poolUnclaimedDO.getStakingToken());
poolUnclaimedVO.setPoolUnclaimedRewards(poolUnclaimedDO.getPoolUnclaimedRewards());
poolUnclaimedVOS.add(poolUnclaimedVO);
}
return poolUnclaimedVOS;
}
}
如果 PoolUnclaimedVO 有一个接受所有属性的构造函数,你可以简化转换过程:
public class PoolUnclaimedVO {
private String campaignId;
private String poolId;
private String stakingToken;
private BigDecimal poolUnclaimedRewards;
// 其他代码省略...
// 接受所有属性的构造函数
public PoolUnclaimedVO(String campaignId, String poolId, String stakingToken, BigDecimal poolUnclaimedRewards) {
this.campaignId = campaignId;
this.poolId = poolId;
this.stakingToken = stakingToken;
this.poolUnclaimedRewards = poolUnclaimedRewards;
}
}
private static List<PoolUnclaimedVO> convertToPoolUnclaimedVO(List<PoolUnclaimedDO> poolUnclaimedDOS) {
List<PoolUnclaimedVO> poolUnclaimedVOS = new ArrayList<>();
for (PoolUnclaimedDO poolUnclaimedDO : poolUnclaimedDOS) {
PoolUnclaimedVO poolUnclaimedVO = new PoolUnclaimedVO(
poolUnclaimedDO.getCampaignId(),
poolUnclaimedDO.getPoolId(),
poolUnclaimedDO.getStakingToken(),
poolUnclaimedDO.getPoolUnclaimedRewards()
);
poolUnclaimedVOS.add(poolUnclaimedVO);
}
return poolUnclaimedVOS;
}
如果你使用的是 Java 8 及以上版本,也可以使用 Streams API 来简化转换过程:
import java.util.List;
import java.util.stream.Collectors;
private static List<PoolUnclaimedVO> convertToPoolUnclaimedVO(List<PoolUnclaimedDO> poolUnclaimedDOS) {
return poolUnclaimedDOS.stream()
.map(poolUnclaimedDO -> new PoolUnclaimedVO(
poolUnclaimedDO.getCampaignId(),
poolUnclaimedDO.getPoolId(),
poolUnclaimedDO.getStakingToken(),
poolUnclaimedDO.getPoolUnclaimedRewards()
))
.collect(Collectors.toList());
}
无论你选择哪种方法,都能实现 PoolUnclaimedDO 列表到 PoolUnclaimedVO 列表的转换。选择最适合你项目风格和需求的方法即可。
@Override
public List<UnclaimedCampaignsVO> getUnclaimedCampaigns(String userId) {
List<UnclaimedCampaignsVO> unclaimedCampaignsVOS = new ArrayList<>();
List<UnclaimedCampaignsDO> unclaimedCampaignsDOS = userStakingEarnMapper.selectSummary(userId);
//遍历处理
if(CollectionUtils.isNotEmpty(unclaimedCampaignsDOS)) {
for(UnclaimedCampaignsDO unclaimedCampaignsDOL:unclaimedCampaignsDOS) {
UnclaimedCampaignsVO unclaimedCampaignsVO = new UnclaimedCampaignsVO();
unclaimedCampaignsVO.setCampaignId(unclaimedCampaignsDOL.getCampaignId());
unclaimedCampaignsVO.setUnclaimedRewards(unclaimedCampaignsDOL.getUnclaimedAmount());
unclaimedCampaignsVO.setClaimedRewards(unclaimedCampaignsDOL.getClaimedRewards());
unclaimedCampaignsVO.setEarnTokenName(unclaimedCampaignsVO.getEarnTokenName());
unclaimedCampaignsVO.setEarnTokenLogo(unclaimedCampaignsVO.getEarnTokenLogo());
List<PoolUnclaimedVO> poolUnclaimedVOS = new ArrayList<>();
List<PoolUnclaimedDO> poolUnclaimedDOS = userStakingEarnMapper.selectPoolSummary(userId,unclaimedCampaignsVO.getCampaignId());
for(PoolUnclaimedDO poolUnclaimedDO:poolUnclaimedDOS) {
PoolUnclaimedVO poolUnclaimedVO = new PoolUnclaimedVO();
poolUnclaimedVO.setPoolId(poolUnclaimedDO.getPoolId());
poolUnclaimedVO.setStakingToken(poolUnclaimedVO.getStakingToken());
poolUnclaimedVO.setPoolUnclaimedRewards(poolUnclaimedDO.getPoolUnclaimedRewards());
poolUnclaimedVOS.add(poolUnclaimedVO);
}
unclaimedCampaignsVO.setPools(poolUnclaimedVOS);
unclaimedCampaignsVOS.add(unclaimedCampaignsVO);
}
}
return unclaimedCampaignsVOS;
}可以优化一下吗
当然可以,对你的代码进行以下几个方面的优化:
UnclaimedCampaignsVO 中设置 earnTokenName 和 earnTokenLogo 时,应该从 UnclaimedCampaignsDO 获取,而不是从 UnclaimedCampaignsVO 自己获取。下面是优化后的代码:
import org.apache.commons.collections4.CollectionUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
@Override
public List<UnclaimedCampaignsVO> getUnclaimedCampaigns(String userId) {
List<UnclaimedCampaignsVO> unclaimedCampaignsVOS = new ArrayList<>();
List<UnclaimedCampaignsDO> unclaimedCampaignsDOS = userStakingEarnMapper.selectSummary(userId);
if (CollectionUtils.isNotEmpty(unclaimedCampaignsDOS)) {
unclaimedCampaignsVOS = unclaimedCampaignsDOS.stream().map(unclaimedCampaignsDO -> {
UnclaimedCampaignsVO unclaimedCampaignsVO = new UnclaimedCampaignsVO();
unclaimedCampaignsVO.setCampaignId(unclaimedCampaignsDO.getCampaignId());
unclaimedCampaignsVO.setUnclaimedRewards(unclaimedCampaignsDO.getUnclaimedAmount());
unclaimedCampaignsVO.setClaimedRewards(unclaimedCampaignsDO.getClaimedRewards());
unclaimedCampaignsVO.setEarnTokenName(unclaimedCampaignsDO.getEarnTokenName());
unclaimedCampaignsVO.setEarnTokenLogo(unclaimedCampaignsDO.getEarnTokenLogo());
List<PoolUnclaimedDO> poolUnclaimedDOS = userStakingEarnMapper.selectPoolSummary(userId, unclaimedCampaignsDO.getCampaignId());
List<PoolUnclaimedVO> poolUnclaimedVOS = poolUnclaimedDOS.stream().map(poolUnclaimedDO -> {
PoolUnclaimedVO poolUnclaimedVO = new PoolUnclaimedVO();
poolUnclaimedVO.setPoolId(poolUnclaimedDO.getPoolId());
poolUnclaimedVO.setStakingToken(poolUnclaimedDO.getStakingToken());
poolUnclaimedVO.setPoolUnclaimedRewards(poolUnclaimedDO.getPoolUnclaimedRewards());
return poolUnclaimedVO;
}).collect(Collectors.toList());
unclaimedCampaignsVO.setPools(poolUnclaimedVOS);
return unclaimedCampaignsVO;
}).collect(Collectors.toList());
}
return unclaimedCampaignsVOS;
}
使用 Java 8 Streams:
stream 和 map 方法来简化列表转换逻辑。collect(Collectors.toList()) 将流转换回列表。减少重复代码:
map 操作中直接创建并设置 UnclaimedCampaignsVO 和 PoolUnclaimedVO 对象,减少了重复的 setter 调用。修复逻辑错误:
UnclaimedCampaignsDO 获取 earnTokenName 和 earnTokenLogo,而不是从 UnclaimedCampaignsVO 自己获取。确保你的相关类具有适当的属性和方法,例如:
public class UnclaimedCampaignsVO {
private String campaignId;
private BigDecimal unclaimedRewards;
private BigDecimal claimedRewards;
private String earnTokenName;
private String earnTokenLogo;
private List<PoolUnclaimedVO> pools;
// Getters and Setters
}
public class UnclaimedCampaignsDO {
private String campaignId;
private BigDecimal unclaimedAmount;
private BigDecimal claimedRewards;
private String earnTokenName;
private String earnTokenLogo;
// Getters and Setters
}
public class PoolUnclaimedVO {
private String poolId;
private String stakingToken;
private BigDecimal poolUnclaimedRewards;
// Getters and Setters
}
public class PoolUnclaimedDO {
private String poolId;
private String stakingToken;
private BigDecimal poolUnclaimedRewards;
// Getters and Setters
}
通过这些优化,你的代码将更加简洁、易读和易于维护。
CREATE TABLE gem_staking.user_staking_earn (
id BIGINT AUTO_INCREMENT COMMENT '主键ID',
bus_id CHAR(24) NOT NULL DEFAULT '' COMMENT '唯一ID',
user_id CHAR(24) NOT NULL DEFAULT '' COMMENT '用户ID',
campaign_id CHAR(24) NOT NULL DEFAULT '' COMMENT '活动ID',
pool_id CHAR(24) NOT NULL DEFAULT '' COMMENT '矿池ID',
staking_hold_amount DECIMAL(38, 20) NOT NULL COMMENT '当时持仓',
earn_amount DECIMAL(38, 20) NOT NULL COMMENT '奖励数量',
earn_token CHAR(24) NOT NULL COMMENT '奖励币种',
earn_token_logo VARCHAR(200) NOT NULL COMMENT '奖励币种logo',
staking_token CHAR(24) NOT NULL COMMENT '质押币种',
staking_token_logo VARCHAR(200) NOT NULL COMMENT '质押币种logo',
earn_state INT NOT NULL COMMENT '领取状态,0,待领取,领取成功,领取失败',
earn_type INT NOT NULL COMMENT '领取方式,0:手动,1:系统自动分发',
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (id),
KEY id_campaign_user_pool (user_id,campaign_id,pool_id) USING BTREE,
KEY id_user_pool (user_id,campaign_id,earn_state) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='用户收益表';表结构如上,需求是查出来待领取的活动,并根据活动分组,统计待领取奖励总和,另外还需要统计这些活动已经领取的总额,最终返回的字段里还要包括pool_id,earn_token_logo,earn_token
要实现这个需求,你需要编写一个 SQL 查询来根据 campaign_id 分组,统计待领取和已领取的奖励总额,同时还需要返回 pool_id、earn_token_logo 和 earn_token。你可以使用子查询或联合查询来实现这一点。
以下是一个示例查询,可以满足你的需求:
SELECT
campaign_id,
pool_id,
earn_token,
earn_token_logo,
SUM(CASE WHEN earn_state = 0 THEN earn_amount ELSE 0 END) AS total_unclaimed_rewards,
SUM(CASE WHEN earn_state = 1 THEN earn_amount ELSE 0 END) AS total_claimed_rewards
FROM
gem_staking.user_staking_earn
GROUP BY
campaign_id,
pool_id,
earn_token,
earn_token_logo
HAVING
total_unclaimed_rewards > 0;
选择的字段:
campaign_id:按活动分组。pool_id:按矿池分组。earn_token 和 earn_token_logo:奖励币种及其 logo。SUM(CASE WHEN earn_state = 0 THEN earn_amount ELSE 0 END) AS total_unclaimed_rewards:待领取的奖励总和。SUM(CASE WHEN earn_state = 1 THEN earn_amount ELSE 0 END) AS total_claimed_rewards:已领取的奖励总和。分组:
GROUP BY campaign_id, pool_id, earn_token, earn_token_logo:按活动、矿池、奖励币种及其 logo 分组。过滤条件:
HAVING total_unclaimed_rewards > 0:只返回有待领取奖励的活动。假设你的 user_staking_earn 表中有以下数据:
| id | bus_id | user_id | campaign_id | pool_id | staking_hold_amount | earn_amount | earn_token | earn_token_logo | staking_token | staking_token_logo | earn_state | earn_type | created_at | updated_at |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | ... | 123456 | campaign1 | pool1 | ... | 10.00 | tokenA | logoA | ... | ... | 0 | 0 | ... | ... |
| 2 | ... | 123456 | campaign1 | pool2 | ... | 20.00 | tokenA | logoA | ... | ... | 1 | 0 | ... | ... |
| 3 | ... | 123456 | campaign2 | pool1 | ... | 5.00 | tokenB | logoB | ... | ... | 0 | 0 | ... | ... |
| 4 | ... | 123456 | campaign2 | pool2 | ... | 15.00 | tokenB | logoB | ... | ... | 1 | 0 | ... | ... |
| 5 | ... | 123456 | campaign1 | pool1 | ... | 8.00 | tokenA | logoA | ... | ... | 1 | 0 | ... | ... |
执行上述查询语句后,结果将如下:
| campaign_id | pool_id | earn_token | earn_token_logo | total_unclaimed_rewards | total_claimed_rewards |
|---|---|---|---|---|---|
| campaign1 | pool1 | tokenA | logoA | 10.00 | 8.00 |
| campaign1 | pool2 | tokenA | logoA | 0.00 | 20.00 |
| campaign2 | pool1 | tokenB | logoB | 5.00 | 0.00 |
| campaign2 | pool2 | tokenB | logoB | 0.00 | 15.00 |
通过这种方式,你可以按 campaign_id 和 pool_id 分组,统计每个活动的待领取和已领取的奖励总额,同时返回 earn_token 和 earn_token_logo。
会不会把没有待领取的活动查出来
为了确保只返回有待领取奖励的活动,你需要在查询中使用 HAVING 子句来过滤掉那些待领取奖励总和为零的记录。
以下是修正后的查询,确保只返回有待领取奖励的活动:
SELECT
campaign_id,
pool_id,
earn_token,
earn_token_logo,
SUM(CASE WHEN earn_state = 0 THEN earn_amount ELSE 0 END) AS total_unclaimed_rewards,
SUM(CASE WHEN earn_state = 1 THEN earn_amount ELSE 0 END) AS total_claimed_rewards
FROM
gem_staking.user_staking_earn
GROUP BY
campaign_id,
pool_id,
earn_token,
earn_token_logo
HAVING
SUM(CASE WHEN earn_state = 0 THEN earn_amount ELSE 0 END) > 0;
选择的字段:
campaign_id:按活动分组。pool_id:按矿池分组。earn_token 和 earn_token_logo:奖励币种及其 logo。SUM(CASE WHEN earn_state = 0 THEN earn_amount ELSE 0 END) AS total_unclaimed_rewards:待领取的奖励总和。SUM(CASE WHEN earn_state = 1 THEN earn_amount ELSE 0 END) AS total_claimed_rewards:已领取的奖励总和。分组:
GROUP BY campaign_id, pool_id, earn_token, earn_token_logo:按活动、矿池、奖励币种及其 logo 分组。过滤条件:
HAVING SUM(CASE WHEN earn_state = 0 THEN earn_amount ELSE 0 END) > 0:只返回有待领取奖励的活动。假设你的 user_staking_earn 表中有以下数据:
| id | bus_id | user_id | campaign_id | pool_id | staking_hold_amount | earn_amount | earn_token | earn_token_logo | staking_token | staking_token_logo | earn_state | earn_type | created_at | updated_at |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | ... | 123456 | campaign1 | pool1 | ... | 10.00 | tokenA | logoA | ... | ... | 0 | 0 | ... | ... |
| 2 | ... | 123456 | campaign1 | pool2 | ... | 20.00 | tokenA | logoA | ... | ... | 1 | 0 | ... | ... |
| 3 | ... | 123456 | campaign2 | pool1 | ... | 5.00 | tokenB | logoB | ... | ... | 0 | 0 | ... | ... |
| 4 | ... | 123456 | campaign2 | pool2 | ... | 15.00 | tokenB | logoB | ... | ... | 1 | 0 | ... | ... |
| 5 | ... | 123456 | campaign1 | pool1 | ... | 8.00 | tokenA | logoA | ... | ... | 1 | 0 | ... | ... |
执行上述查询语句后,结果将如下:
| campaign_id | pool_id | earn_token | earn_token_logo | total_unclaimed_rewards | total_claimed_rewards |
|---|---|---|---|---|---|
| campaign1 | pool1 | tokenA | logoA | 10.00 | 8.00 |
| campaign2 | pool1 | tokenB | logoB | 5.00 | 0.00 |
campaign1 中:
pool1 的 total_unclaimed_rewards 为 10.00(第 1 行),total_claimed_rewards 为 8.00(第 5 行)。campaign2 中:
pool1 的 total_unclaimed_rewards 为 5.00(第 3 行),total_claimed_rewards 为 0.00。campaign1 的 pool2 和 campaign2 的 pool2 没有返回,因为它们没有待领取的奖励。
通过这种方式,你可以确保查询结果只包含有待领取奖励的活动,并按 campaign_id 和 pool_id 分组,统计每个活动和矿池的待领取和已领取的奖励总额,同时返回 earn_token 和 earn_token_logo。
假设campaign2没有earn_state是0的会查出来campaign2吗
如果 campaign2 没有任何 earn_state 为 0 的记录,根据我们使用的 HAVING 子句,它不会被查询出来。HAVING 子句确保只有待领取奖励总和 (total_unclaimed_rewards) 大于 0 的活动会出现在结果中。
假设你的 user_staking_earn 表中有以下数据:
| id | bus_id | user_id | campaign_id | pool_id | staking_hold_amount | earn_amount | earn_token | earn_token_logo | staking_token | staking_token_logo | earn_state | earn_type | created_at | updated_at |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | ... | 123456 | campaign1 | pool1 | ... | 10.00 | tokenA | logoA | ... | ... | 0 | 0 | ... | ... |
| 2 | ... | 123456 | campaign1 | pool2 | ... | 20.00 | tokenA | logoA | ... | ... | 1 | 0 | ... | ... |
| 3 | ... | 123456 | campaign2 | pool1 | ... | 5.00 | tokenB | logoB | ... | ... | 1 | 0 | ... | ... |
| 4 | ... | 123456 | campaign2 | pool2 | ... | 15.00 | tokenB | logoB | ... | ... | 1 | 0 | ... | ... |
| 5 | ... | 123456 | campaign1 | pool1 | ... | 8.00 | tokenA | logoA | ... | ... | 1 | 0 | ... | ... |
执行上述查询语句后,结果将如下:
SELECT
campaign_id,
pool_id,
earn_token,
earn_token_logo,
SUM(CASE WHEN earn_state = 0 THEN earn_amount ELSE 0 END) AS total_unclaimed_rewards,
SUM(CASE WHEN earn_state = 1 THEN earn_amount ELSE 0 END) AS total_claimed_rewards
FROM
gem_staking.user_staking_earn
GROUP BY
campaign_id,
pool_id,
earn_token,
earn_token_logo
HAVING
SUM(CASE WHEN earn_state = 0 THEN earn_amount ELSE 0 END) > 0;
结果将如下:
| campaign_id | pool_id | earn_token | earn_token_logo | total_unclaimed_rewards | total_claimed_rewards |
|---|---|---|---|---|---|
| campaign1 | pool1 | tokenA | logoA | 10.00 | 8.00 |
campaign1 中:
pool1 的 total_unclaimed_rewards 为 10.00(第 1 行),total_claimed_rewards 为 8.00(第 5 行)。campaign2 中没有返回,因为它没有任何 earn_state 为 0 的记录。
通过使用 HAVING 子句过滤 total_unclaimed_rewards 大于 0 的记录,你可以确保查询结果只包含有待领取奖励的活动。如果某个 campaign 没有任何 earn_state 为 0 的记录,它将不会出现在查询结果中。
List<GemStakingCampaignDO> checkedCampaignsDO = gemStakingCampaignMapper.selectByExample(gemStakingCampaignDOExample);
if (null != checkedCampaignsDO) {
//GemStakingCampaignDO里有个earnToken,帮我把checkedCampaignsDO转换为List<String> earnTokens
}
你可以通过遍历 checkedCampaignsDO 列表,将 GemStakingCampaignDO 对象中的 earnToken 字段提取出来,并添加到 List<String> 列表中。下面是一个示例代码,展示了如何实现这一转换。
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class Example {
public static void main(String[] args) {
// 假设这些是从数据库查询得到的结果
List<GemStakingCampaignDO> checkedCampaignsDO = gemStakingCampaignMapper.selectByExample(gemStakingCampaignDOExample);
// 检查是否为空
if (checkedCampaignsDO != null) {
// 方法1:使用传统的for循环
List<String> earnTokens = new ArrayList<>();
for (GemStakingCampaignDO campaign : checkedCampaignsDO) {
earnTokens.add(campaign.getEarnToken());
}
// 方法2:使用Java 8 Streams
List<String> earnTokensUsingStreams = checkedCampaignsDO.stream()
.map(GemStakingCampaignDO::getEarnToken)
.collect(Collectors.toList());
// 打印结果
System.out.println(earnTokens);
System.out.println(earnTokensUsingStreams);
}
}
}
检查是否为空:
checkedCampaignsDO 是否为 null,以避免空指针异常。方法1:使用传统的 for 循环:
ArrayList<String>,名为 earnTokens。for 循环遍历 checkedCampaignsDO 列表,将每个 GemStakingCampaignDO 对象中的 earnToken 字段提取并添加到 earnTokens 列表中。方法2:使用 Java 8 Streams:
stream() 方法将 checkedCampaignsDO 列表转换为流。map 方法将每个 GemStakingCampaignDO 对象转换为它的 earnToken 字段。collect(Collectors.toList()) 将流转换回 List<String>。确保你的 GemStakingCampaignDO 类具有 getEarnToken 方法。例如:
public class GemStakingCampaignDO {
private String earnToken;
// 其他属性和方法省略...
public String getEarnToken() {
return earnToken;
}
public void setEarnToken(String earnToken) {
this.earnToken = earnToken;
}
}
通过这些代码,你可以方便地将 List<GemStakingCampaignDO> 转换为 List<String>,提取每个对象的 earnToken 字段。你可以选择使用传统的 for 循环或 Java 8 的 Streams,根据你的需求和代码风格来选择。
如何优雅的构造一个空的list
在 Java 中构造一个空的 List 有多种方式。以下是几种常见且优雅的方法:
Collections.emptyList()Collections.emptyList() 是最推荐的方式之一,它返回一个不可变的空列表。
import java.util.Collections;
import java.util.List;
List<String> emptyList = Collections.emptyList();
Arrays.asList() 创建空列表Arrays.asList() 可以用来创建一个固定大小的列表。当你传递空数组时,它会返回一个空列表。
import java.util.Arrays;
import java.util.List;
List<String> emptyList = Arrays.asList();
new ArrayList<>()直接创建一个新的 ArrayList。这是最常见的方式之一,特别是当你需要一个可变的空列表时。
import java.util.ArrayList;
import java.util.List;
List<String> emptyList = new ArrayList<>();
List.of() (Java 9 及以上)List.of() 方法在 Java 9 中引入,它返回一个不可变的空列表。
import java.util.List;
List<String> emptyList = List.of();
选择哪种方式主要取决于你的需求:
Collections.emptyList() 或 List.of()。new ArrayList<>()。以下是一个示例,展示如何使用这些方法来构造一个空的 List:
import java.util.Collections;
import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
public class EmptyListExample {
public static void main(String[] args) {
// 使用 Collections.emptyList()
List<String> emptyList1 = Collections.emptyList();
System.out.println("Empty List using Collections.emptyList(): " + emptyList1);
// 使用 Arrays.asList()
List<String> emptyList2 = Arrays.asList();
System.out.println("Empty List using Arrays.asList(): " + emptyList2);
// 使用 new ArrayList<>()
List<String> emptyList3 = new ArrayList<>();
System.out.println("Empty List using new ArrayList<>(): " + emptyList3);
// 使用 List.of() (Java 9 及以上)
List<String> emptyList4 = List.of();
System.out.println("Empty List using List.of(): " + emptyList4);
}
}
Collections.emptyList():返回一个不可变的空列表,适用于不需要修改列表的场景。Arrays.asList():返回一个固定大小的列表,可以用于创建空列表,但列表本身不可变。new ArrayList<>():返回一个新的可变空列表,适用于需要修改列表的场景。List.of():Java 9 引入的方法,返回一个不可变的空列表,适用于不需要修改列表的场景。根据你的具体需求选择适合的方法,可以确保代码的简洁性和可维护性。
List<RewardsHistoryVO> gemPoolCampaignHisVOs = new ArrayList<>();
gemPoolCampaignHisVOs = userStakingEarnDOS.stream().map().collect(Collectors.toList());请帮我补齐代码,或者优化,@Data
public class RewardsHistoryVO {
/**
* 领取时间
*/
@ApiModelProperty(value = "条数")
Long time;
@ApiModelProperty(value = "未领取的活动集合")
String token;
@ApiModelProperty(value = "--类型,0手动,1系统分发")
Integer type;
@ApiModelProperty(value = "收益")
BigDecimal amount;
}public class UserStakingEarnDO {
/**
* 主键ID
*/
private Long id;
/**
* 唯一ID
*/
private String busId;
/**
* 用户ID
*/
private String userId;
/**
* 活动ID
*/
private String campaignId;
/**
* 矿池ID
*/
private String poolId;
/**
* 当时持仓
*/
private BigDecimal stakingHoldAmount;
/**
* 奖励数量
*/
private BigDecimal earnAmount;
/**
* 奖励币种
*/
private String earnToken;
/**
* 奖励币种logo
*/
private String earnTokenLogo;
/**
* 质押币种
*/
private String stakingToken;
/**
* 质押币种logo
*/
private String stakingTokenLogo;
/**
* 领取状态,0,待领取,领取成功,领取失败
*/
private Integer earnState;
/**
* 领取方式,0:手动,1:系统自动分发
*/
private Integer earnType;
/**
* 创建时间
*/
private Date createdAt;
/**
* 更新时间
*/
private Date updatedAt;
/**
* 获取主键ID
*/
public Long getId() {
return id;
}
/**
* 设置主键ID
*/
public void setId(Long id) {
this.id = id;
}
/**
* 获取唯一ID
*/
public String getBusId() {
return busId;
}
/**
* 设置唯一ID
*/
public void setBusId(String busId) {
this.busId = busId;
}
/**
* 获取用户ID
*/
public String getUserId() {
return userId;
}
/**
* 设置用户ID
*/
public void setUserId(String userId) {
this.userId = userId;
}
/**
* 获取活动ID
*/
public String getCampaignId() {
return campaignId;
}
/**
* 设置活动ID
*/
public void setCampaignId(String campaignId) {
this.campaignId = campaignId;
}
/**
* 获取矿池ID
*/
public String getPoolId() {
return poolId;
}
/**
* 设置矿池ID
*/
public void setPoolId(String poolId) {
this.poolId = poolId;
}
/**
* 获取当时持仓
*/
public BigDecimal getStakingHoldAmount() {
return stakingHoldAmount;
}
/**
* 设置当时持仓
*/
public void setStakingHoldAmount(BigDecimal stakingHoldAmount) {
this.stakingHoldAmount = stakingHoldAmount;
}
/**
* 获取奖励数量
*/
public BigDecimal getEarnAmount() {
return earnAmount;
}
/**
* 设置奖励数量
*/
public void setEarnAmount(BigDecimal earnAmount) {
this.earnAmount = earnAmount;
}
/**
* 获取奖励币种
*/
public String getEarnToken() {
return earnToken;
}
/**
* 设置奖励币种
*/
public void setEarnToken(String earnToken) {
this.earnToken = earnToken;
}
/**
* 获取奖励币种logo
*/
public String getEarnTokenLogo() {
return earnTokenLogo;
}
/**
* 设置奖励币种logo
*/
public void setEarnTokenLogo(String earnTokenLogo) {
this.earnTokenLogo = earnTokenLogo;
}
/**
* 获取质押币种
*/
public String getStakingToken() {
return stakingToken;
}
/**
* 设置质押币种
*/
public void setStakingToken(String stakingToken) {
this.stakingToken = stakingToken;
}
/**
* 获取质押币种logo
*/
public String getStakingTokenLogo() {
return stakingTokenLogo;
}
/**
* 设置质押币种logo
*/
public void setStakingTokenLogo(String stakingTokenLogo) {
this.stakingTokenLogo = stakingTokenLogo;
}
/**
* 获取领取状态,0,待领取,领取成功,领取失败
*/
public Integer getEarnState() {
return earnState;
}
/**
* 设置领取状态,0,待领取,领取成功,领取失败
*/
public void setEarnState(Integer earnState) {
this.earnState = earnState;
}
/**
* 获取领取方式,0:手动,1:系统自动分发
*/
public Integer getEarnType() {
return earnType;
}
/**
* 设置领取方式,0:手动,1:系统自动分发
*/
public void setEarnType(Integer earnType) {
this.earnType = earnType;
}
/**
* 获取创建时间
*/
public Date getCreatedAt() {
return createdAt;
}
/**
* 设置创建时间
*/
public void setCreatedAt(Date createdAt) {
this.createdAt = createdAt;
}
/**
* 获取更新时间
*/
public Date getUpdatedAt() {
return updatedAt;
}
/**
* 设置更新时间
*/
public void setUpdatedAt(Date updatedAt) {
this.updatedAt = updatedAt;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(getClass().getSimpleName());
sb.append(" [");
sb.append("Hash = ").append(hashCode());
sb.append(", id=").append(id);
sb.append(", busId=").append(busId);
sb.append(", userId=").append(userId);
sb.append(", campaignId=").append(campaignId);
sb.append(", poolId=").append(poolId);
sb.append(", stakingHoldAmount=").append(stakingHoldAmount);
sb.append(", earnAmount=").append(earnAmount);
sb.append(", earnToken=").append(earnToken);
sb.append(", earnTokenLogo=").append(earnTokenLogo);
sb.append(", stakingToken=").append(stakingToken);
sb.append(", stakingTokenLogo=").append(stakingTokenLogo);
sb.append(", earnState=").append(earnState);
sb.append(", earnType=").append(earnType);
sb.append(", createdAt=").append(createdAt);
sb.append(", updatedAt=").append(updatedAt);
sb.append("]");
return sb.toString();
}
}
你可以通过使用 Java 8 的 Streams API 将 List<UserStakingEarnDO> 转换为 List<RewardsHistoryVO>。具体来说,你可以使用 map 方法来转换每个 UserStakingEarnDO 对象,并将结果收集到一个新的列表中。
以下是一个示例代码,展示了如何将 List<UserStakingEarnDO> 转换为 List<RewardsHistoryVO>:
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
import java.util.ArrayList;
public class Example {
public static void main(String[] args) {
// 假设这些是从数据库查询得到的结果
List<UserStakingEarnDO> userStakingEarnDOS = new ArrayList<>();
// 将 UserStakingEarnDO 列表转换为 RewardsHistoryVO 列表
List<RewardsHistoryVO> gemPoolCampaignHisVOs = userStakingEarnDOS.stream()
.map(userStakingEarnDO -> {
RewardsHistoryVO rewardsHistoryVO = new RewardsHistoryVO();
rewardsHistoryVO.setTime(userStakingEarnDO.getCreatedAt().getTime());
rewardsHistoryVO.setToken(userStakingEarnDO.getEarnToken());
rewardsHistoryVO.setType(userStakingEarnDO.getEarnType());
rewardsHistoryVO.setAmount(userStakingEarnDO.getEarnAmount());
return rewardsHistoryVO;
})
.collect(Collectors.toList());
// 打印结果
gemPoolCampaignHisVOs.forEach(System.out::println);
}
}
使用 Streams API:
stream() 方法将 userStakingEarnDOS 列表转换为流。map 方法将每个 UserStakingEarnDO 对象转换为 RewardsHistoryVO 对象。collect(Collectors.toList()) 将流转换回 List<RewardsHistoryVO>。映射属性:
rewardsHistoryVO.setTime(userStakingEarnDO.getCreatedAt().getTime()):将 UserStakingEarnDO 的 createdAt 属性转换为时间戳并设置到 RewardsHistoryVO 的 time 属性。rewardsHistoryVO.setToken(userStakingEarnDO.getEarnToken()):将 UserStakingEarnDO 的 earnToken 属性设置到 RewardsHistoryVO 的 token 属性。rewardsHistoryVO.setType(userStakingEarnDO.getEarnType()):将 UserStakingEarnDO 的 earnType 属性设置到 RewardsHistoryVO 的 type 属性。rewardsHistoryVO.setAmount(userStakingEarnDO.getEarnAmount()):将 UserStakingEarnDO 的 earnAmount 属性设置到 RewardsHistoryVO 的 amount 属性。确保你的相关类具有适当的属性和方法,例如:
// RewardsHistoryVO.java
import java.math.BigDecimal;
public class RewardsHistoryVO {
/**
* 领取时间
*/
Long time;
/**
* 未领取的活动集合
*/
String token;
/**
* 类型,0手动,1系统分发
*/
Integer type;
/**
* 收益
*/
BigDecimal amount;
// Getters and Setters
public Long getTime() {
return time;
}
public void setTime(Long time) {
this.time = time;
}
public String getToken() {
return token;
}
public void setToken(String token) {
this.token = token;
}
public Integer getType() {
return type;
}
public void setType(Integer type) {
this.type = type;
}
public BigDecimal getAmount() {
return amount;
}
public void setAmount(BigDecimal amount) {
this.amount = amount;
}
@Override
public String toString() {
return "RewardsHistoryVO{" +
"time=" + time +
", token='" + token + '\'' +
", type=" + type +
", amount=" + amount +
'}';
}
}
// UserStakingEarnDO.java
import java.math.BigDecimal;
import java.util.Date;
public class UserStakingEarnDO {
private Long id;
private String busId;
private String userId;
private String campaignId;
private String poolId;
private BigDecimal stakingHoldAmount;
private BigDecimal earnAmount;
private String earnToken;
private String earnTokenLogo;
private String stakingToken;
private String stakingTokenLogo;
private Integer earnState;
private Integer earnType;
private Date createdAt;
private Date updatedAt;
// Getters and Setters
// ... (省略了getter和setter方法以节省空间)
}
通过这些代码,你可以方便地将 List<UserStakingEarnDO> 转换为 List<RewardsHistoryVO>,提取并设置每个对象的相关属性。
CREATE TABLE gem_staking.user_staking_earn (
id BIGINT AUTO_INCREMENT COMMENT '主键ID',
bus_id CHAR(24) NOT NULL DEFAULT '' COMMENT '唯一ID',
user_id CHAR(24) NOT NULL DEFAULT '' COMMENT '用户ID',
campaign_id CHAR(24) NOT NULL DEFAULT '' COMMENT '活动ID',
pool_id CHAR(24) NOT NULL DEFAULT '' COMMENT '矿池ID',
staking_hold_amount DECIMAL(38, 20) NOT NULL COMMENT '当时持仓',
earn_amount DECIMAL(38, 20) NOT NULL COMMENT '奖励数量',
earn_token CHAR(24) NOT NULL COMMENT '奖励币种',
earn_token_logo VARCHAR(200) NOT NULL COMMENT '奖励币种logo',
staking_token CHAR(24) NOT NULL COMMENT '质押币种',
staking_token_logo VARCHAR(200) NOT NULL COMMENT '质押币种logo',
earn_state INT NOT NULL COMMENT '领取状态,0,待领取,领取成功,领取失败',
earn_type INT NOT NULL COMMENT '领取方式,0:手动,1:系统自动分发',
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (id),
KEY id_campaign_user_pool (user_id,campaign_id,pool_id) USING BTREE,
KEY id_user_pool (user_id,campaign_id,earn_state) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='用户收益表';
首先都要是领取成功的,根据earn_token分组,再根据pool_id分组,统计出每个earn_token下每个pool的收益,以及每个earn_token的收益总额,每个earn_token的收益总额应该等于这个earn_token下的所有po o
你需要编写一个 SQL 查询,首先过滤出 earn_state 为领取成功的记录,然后根据 earn_token 和 pool_id 分组,统计每个 earn_token 下每个 pool 的收益,以及每个 earn_token 的收益总额。最终结果应该包括每个 earn_token 下每个 pool 的收益和总收益。
以下是一个示例查询,可以满足你的需求:
SELECT
earn_token,
pool_id,
SUM(earn_amount) AS pool_earnings,
SUM(SUM(earn_amount)) OVER (PARTITION BY earn_token) AS total_earnings_per_token
FROM
gem_staking.user_staking_earn
WHERE
earn_state = 1 -- 1 表示领取成功
GROUP BY
earn_token,
pool_id
ORDER BY
earn_token,
pool_id;
选择的字段:
earn_token:奖励币种。pool_id:矿池 ID。SUM(earn_amount) AS pool_earnings:每个 pool 的收益总额。SUM(SUM(earn_amount)) OVER (PARTITION BY earn_token) AS total_earnings_per_token:每个 earn_token 的收益总额。使用窗口函数 OVER (PARTITION BY earn_token) 实现。过滤条件:
earn_state = 1:只选择领取成功的记录。分组:
GROUP BY earn_token, pool_id:按 earn_token 和 pool_id 分组。排序:
ORDER BY earn_token, pool_id:按 earn_token 和 pool_id 排序,以便结果更有条理。假设你的 user_staking_earn 表中有以下数据:
| id | bus_id | user_id | campaign_id | pool_id | staking_hold_amount | earn_amount | earn_token | earn_token_logo | staking_token | staking_token_logo | earn_state | earn_type | created_at | updated_at |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | ... | 123456 | campaign1 | pool1 | ... | 10.00 | tokenA | logoA | ... | ... | 1 | 0 | ... | ... |
| 2 | ... | 123456 | campaign1 | pool2 | ... | 20.00 | tokenA | logoA | ... | ... | 1 | 0 | ... | ... |
| 3 | ... | 123456 | campaign2 | pool1 | ... | 5.00 | tokenB | logoB | ... | ... | 1 | 0 | ... | ... |
| 4 | ... | 123456 | campaign2 | pool2 | ... | 15.00 | tokenB | logoB | ... | ... | 1 | 0 | ... | ... |
| 5 | ... | 123456 | campaign1 | pool1 | ... | 8.00 | tokenA | logoA | ... | ... | 1 | 0 | ... | ... |
执行上述查询语句后,结果将如下:
| earn_token | pool_id | pool_earnings | total_earnings_per_token |
|---|---|---|---|
| tokenA | pool1 | 18.00 | 38.00 |
| tokenA | pool2 | 20.00 | 38.00 |
| tokenB | pool1 | 5.00 | 20.00 |
| tokenB | pool2 | 15.00 | 20.00 |
tokenA 中:
pool1 的 pool_earnings 为 18.00(第 1 行和第 5 行)。pool2 的 pool_earnings 为 20.00(第 2 行)。total_earnings_per_token 为 38.00(18.00 + 20.00)。tokenB 中:
pool1 的 pool_earnings 为 5.00(第 3 行)。pool2 的 pool_earnings 为 15.00(第 4 行)。total_earnings_per_token 为 20.00(5.00 + 15.00)。通过这种方式,你可以统计每个 earn_token 下每个 pool 的收益,以及每个 earn_token 的总收益,并确保每个 earn_token 的总收益等于该 earn_token 下所有 pool 的收益总和。
<select id="countByEarnTokenGroup" parameterType="com.kucoin.gemstakingfront.common.dal.dataobject.StakingProductsDOExample" resultType="java.lang.Long">
select count(*) from gem_staking.user_staking_earn
where user_id = #{userId,jdbcType=CHAR},
<if test="earnToken != null">
and earn_token = #{earnToken,jdbcType=CHAR},
</if>
<if test="startTime != null">
and updated_at >= #{startTime,jdbcType=CHAR},
</if>
<if test="endTime != null">
and updated_at <= #{endTime,jdbcType=CHAR},
</if>
and earn_state = 1
GROUP BY
earn_token
</select>
你提供的 SQL 语句有一些小问题需要修正:
where 子句中的条件之间应该使用 AND,而不是逗号。AND 连接符在条件之间适当地使用。GROUP BY 子句:你正在使用 COUNT(*) 函数,并且希望按 earn_token 分组,因此需要确保 GROUP BY 子句没有语法错误。resultType 应该是 java.lang.Long,因为你正在计算计数。以下是修正后的 SQL 语句:
<select id="countByEarnTokenGroup" parameterType="com.kucoin.gemstakingfront.common.dal.dataobject.StakingProductsDOExample" resultType="java.lang.Long">
select count(*)
from gem_staking.user_staking_earn
where user_id = #{userId,jdbcType=CHAR}
<if test="earnToken != null">
and earn_token = #{earnToken,jdbcType=CHAR}
</if>
<if test="startTime != null">
and updated_at >= #{startTime,jdbcType=CHAR}
</if>
<if test="endTime != null">
and updated_at <= #{endTime,jdbcType=CHAR}
</if>
and earn_state = 1
GROUP BY earn_token
</select>
选择的字段:
count(*):计算记录的数量。过滤条件:
user_id = #{userId,jdbcType=CHAR}:指定用户 ID。earn_token = #{earnToken,jdbcType=CHAR}(如果 earnToken 不为空):指定奖励币种。updated_at >= #{startTime,jdbcType=CHAR}(如果 startTime 不为空):指定开始时间。updated_at <= #{endTime,jdbcType=CHAR}(如果 endTime 不为空):指定结束时间。earn_state = 1:只选择领取成功的记录。分组:
GROUP BY earn_token:按 earn_token 分组。确保你的 StakingProductsDOExample 类具有适当的属性和方法。例如:
public class StakingProductsDOExample {
private String userId;
private String earnToken;
private String startTime;
private String endTime;
// Getters and Setters
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public String getEarnToken() {
return earnToken;
}
public void setEarnToken(String earnToken) {
this.earnToken = earnToken;
}
public String getStartTime() {
return startTime;
}
public void setStartTime(String startTime) {
this.startTime = startTime;
}
public String getEndTime() {
return endTime;
}
public void setEndTime(String endTime) {
this.endTime = endTime;
}
}
通过这些修正,你的 MyBatis 查询应该能够正确计算和分组,并返回每个 earn_token 组的记录数量。确保在调用这个查询时,传入的 StakingProductsDOExample 对象包含了必要的参数。
and updated_at <= #{endTime,jdbcType=CHAR}
idea编辑器提示<= Tag name expected
IDE 提示 "Tag name expected" 通常是因为 XML 语法错误。你的 SQL 语句中的 <if> 标签需要正确关闭,并且需要确保条件之间的连接符正确使用。
以下是修正后的 SQL 语句,确保所有 XML 标签正确关闭,并且条件之间的连接符正确:
<select id="countByEarnTokenGroup" parameterType="com.kucoin.gemstakingfront.common.dal.dataobject.StakingProductsDOExample" resultType="java.lang.Long">
SELECT
COUNT(*)
FROM
gem_staking.user_staking_earn
WHERE
user_id = #{userId,jdbcType=CHAR}
AND earn_state = 1
<if test="earnToken != null">
AND earn_token = #{earnToken,jdbcType=CHAR}
</if>
<if test="startTime != null">
AND updated_at >= #{startTime,jdbcType=CHAR}
</if>
<if test="endTime != null">
AND updated_at <= #{endTime,jdbcType=CHAR}
</if>
GROUP BY
earn_token
</select>
选择的字段:
COUNT(*):计算记录的数量。过滤条件:
user_id = #{userId,jdbcType=CHAR}:指定用户 ID。earn_state = 1:只选择领取成功的记录。earn_token = #{earnToken,jdbcType=CHAR}(如果 earnToken 不为空):指定奖励币种。updated_at >= #{startTime,jdbcType=CHAR}(如果 startTime 不为空):指定开始时间。updated_at <= #{endTime,jdbcType=CHAR}(如果 endTime 不为空):指定结束时间。分组:
GROUP BY earn_token:按 earn_token 分组。确保你的 StakingProductsDOExample 类具有适当的属性和方法。例如:
public class StakingProductsDOExample {
private String userId;
private String earnToken;
private String startTime;
private String endTime;
// Getters and Setters
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public String getEarnToken() {
return earnToken;
}
public void setEarnToken(String earnToken) {
this.earnToken = earnToken;
}
public String getStartTime() {
return startTime;
}
public void setStartTime(String startTime) {
this.startTime = startTime;
}
public String getEndTime() {
return endTime;
}
public void setEndTime(String endTime) {
this.endTime = endTime;
}
}
通过这些修正,你的 MyBatis 查询应该能够正确计算和分组,并返回每个 earn_token 组的记录数量。确保在调用这个查询时,传入的 StakingProductsDOExample 对象包含了必要的参数。
<select id="countByEarnTokenGroup" parameterType="com.kucoin.gemstakingfront.common.dal.dataobject.StakingProductsDOExample" resultType="java.lang.Long">
select count(*)
from gem_staking.user_staking_earn
where user_id = #{userId,jdbcType=CHAR}
<if test="earnToken != null">
and earn_token = #{earnToken,jdbcType=CHAR}
</if>
<if test="startTime != null">
and updated_at >= #{startTime,jdbcType=CHAR}
</if>
<if test="endTime != null">
and updated_at <= #{endTime,jdbcType=CHAR}
</if>
and earn_state = 1
GROUP BY earn_token
</select>
你的 SQL 语句有一个关键问题:在使用 <if> 标签添加条件时,应该确保这些条件在逻辑上正确连接。特别是最后一个条件 and earn_state = 1,如果前面的条件不添加,则会导致语法错误。为了避免这个问题,建议将 earn_state = 1 条件放在最前面,或者在每个条件前面都添加一个占位符条件。
此外,需要注意的是,在 XML 中,必须使用 > 和 < 分别表示 >= 和 <=。
以下是修正后的 SQL 语句:
<select id="countByEarnTokenGroup" parameterType="com.kucoin.gemstakingfront.common.dal.dataobject.StakingProductsDOExample" resultType="java.lang.Long">
SELECT
COUNT(*)
FROM
gem_staking.user_staking_earn
WHERE
user_id = #{userId,jdbcType=CHAR}
AND earn_state = 1
<if test="earnToken != null">
AND earn_token = #{earnToken,jdbcType=CHAR}
</if>
<if test="startTime != null">
AND updated_at >= #{startTime,jdbcType=CHAR}
</if>
<if test="endTime != null">
AND updated_at <= #{endTime,jdbcType=CHAR}
</if>
GROUP BY
earn_token
</select>
选择的字段:
COUNT(*):计算记录的数量。过滤条件:
user_id = #{userId,jdbcType=CHAR}:指定用户 ID。earn_state = 1:只选择领取成功的记录。earn_token = #{earnToken,jdbcType=CHAR}(如果 earnToken 不为空):指定奖励币种。updated_at >= #{startTime,jdbcType=CHAR}(如果 startTime 不为空):指定开始时间。updated_at <= #{endTime,jdbcType=CHAR}(如果 endTime 不为空):指定结束时间。分组:
GROUP BY earn_token:按 earn_token 分组。<if> 标签时,条件需要在逻辑上前后一致。>= 和 <= 分别用 > 和 < 表示。确保你的 StakingProductsDOExample 类具有适当的属性和方法。例如:
public class StakingProductsDOExample {
private String userId;
private String earnToken;
private String startTime;
private String endTime;
// Getters and Setters
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public String getEarnToken() {
return earnToken;
}
public void setEarnToken(String earnToken) {
this.earnToken = earnToken;
}
public String getStartTime() {
return startTime;
}
public void setStartTime(String startTime) {
this.startTime = startTime;
}
public String getEndTime() {
return endTime;
}
public void setEndTime(String endTime) {
this.endTime = endTime;
}
}
通过这些修正,你的 MyBatis 查询应该能够正确计算和分组,并返回每个 earn_token 组的记录数量。确保在调用这个查询时,传入的 StakingProductsDOExample 对象包含了必要的参数。
mapper接口该怎么写
为了让 MyBatis 映射文件中的 countByEarnTokenGroup 查询在 Java 中可用,你需要在 Mapper 接口中定义相应的方法。以下是如何编写 Mapper 接口的方法:
首先,定义一个 UserStakingEarnMapper 接口并声明 countByEarnTokenGroup 方法。
package com.kucoin.gemstakingfront.common.dal.mapper;
import com.kucoin.gemstakingfront.common.dal.dataobject.StakingProductsDOExample;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import java.util.List;
@Mapper
public interface UserStakingEarnMapper {
@Select("YOUR SQL QUERY HERE")
List<Long> countByEarnTokenGroup(@Param("example") StakingProductsDOExample example);
}
以下是完整的 Mapper 接口定义。注意:你需要将 @Select 注解中的 SQL 查询替换为你的实际查询,或者将 SQL 查询放在 XML 映射文件中。
UserStakingEarnMapper.java:
package com.kucoin.gemstakingfront.common.dal.mapper;
import com.kucoin.gemstakingfront.common.dal.dataobject.StakingProductsDOExample;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@Mapper
public interface UserStakingEarnMapper {
List<Long> countByEarnTokenGroup(@Param("example") StakingProductsDOExample example);
}
确保你的 MyBatis 映射文件中包含 countByEarnTokenGroup 查询的定义,并与 Mapper 接口中的方法名一致。
UserStakingEarnMapper.xml:
<mapper namespace="com.kucoin.gemstakingfront.common.dal.mapper.UserStakingEarnMapper">
<select id="countByEarnTokenGroup" parameterType="com.kucoin.gemstakingfront.common.dal.dataobject.StakingProductsDOExample" resultType="java.lang.Long">
SELECT
COUNT(*)
FROM
gem_staking.user_staking_earn
WHERE
user_id = #{example.userId,jdbcType=CHAR}
AND earn_state = 1
<if test="example.earnToken != null">
AND earn_token = #{example.earnToken,jdbcType=CHAR}
</if>
<if test="example.startTime != null">
AND updated_at >= #{example.startTime,jdbcType=CHAR}
</if>
<if test="example.endTime != null">
AND updated_at <= #{example.endTime,jdbcType=CHAR}
</if>
GROUP BY
earn_token
</select>
</mapper>
在你的服务类中注入 UserStakingEarnMapper 并调用 countByEarnTokenGroup 方法。
ExampleService.java:
package com.kucoin.gemstakingfront.service;
import com.kucoin.gemstakingfront.common.dal.dataobject.StakingProductsDOExample;
import com.kucoin.gemstakingfront.common.dal.mapper.UserStakingEarnMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class ExampleService {
@Autowired
private UserStakingEarnMapper userStakingEarnMapper;
public List<Long> getEarnTokenCounts(StakingProductsDOExample example) {
return userStakingEarnMapper.countByEarnTokenGroup(example);
}
}
UserStakingEarnMapper 接口中声明 countByEarnTokenGroup 方法。UserStakingEarnMapper.xml 映射文件中定义 countByEarnTokenGroup 查询。UserStakingEarnMapper 并调用 countByEarnTokenGroup 方法。通过这些步骤,你可以在 Java 代码中使用 MyBatis 查询来统计每个 earn_token 组的记录数量。确保在调用这个查询时,传入的 StakingProductsDOExample 对象包含了必要的参数。
不传对象StakingProductsDOExample,改成map
如果你希望不传对象,而是传 Map 参数,可以按照以下步骤进行修改:
首先,修改 MyBatis 映射文件,以使用 Map 作为参数类型:
UserStakingEarnMapper.xml:
<mapper namespace="com.kucoin.gemstakingfront.common.dal.mapper.UserStakingEarnMapper">
<select id="countByEarnTokenGroup" parameterType="map" resultType="java.lang.Long">
SELECT
COUNT(*)
FROM
gem_staking.user_staking_earn
WHERE
user_id = #{userId,jdbcType=CHAR}
AND earn_state = 1
<if test="earnToken != null">
AND earn_token = #{earnToken,jdbcType=CHAR}
</if>
<if test="startTime != null">
AND updated_at >= #{startTime,jdbcType=CHAR}
</if>
<if test="endTime != null">
AND updated_at <= #{endTime,jdbcType=CHAR}
</if>
GROUP BY
earn_token
</select>
</mapper>
修改 Mapper 接口,以使用 Map<String, Object> 作为参数类型:
UserStakingEarnMapper.java:
package com.kucoin.gemstakingfront.common.dal.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;
@Mapper
public interface UserStakingEarnMapper {
List<Long> countByEarnTokenGroup(@Param("params") Map<String, Object> params);
}
在你的服务类中,构建 Map<String, Object> 参数,并调用 countByEarnTokenGroup 方法:
ExampleService.java:
package com.kucoin.gemstakingfront.service;
import com.kucoin.gemstakingfront.common.dal.mapper.UserStakingEarnMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Service
public class ExampleService {
@Autowired
private UserStakingEarnMapper userStakingEarnMapper;
public List<Long> getEarnTokenCounts(String userId, String earnToken, String startTime, String endTime) {
Map<String, Object> params = new HashMap<>();
params.put("userId", userId);
params.put("earnToken", earnToken);
params.put("startTime", startTime);
params.put("endTime", endTime);
return userStakingEarnMapper.countByEarnTokenGroup(params);
}
}
修改 MyBatis 映射文件:
parameterType="map"。#{paramName},例如 #{userId}, #{earnToken}, #{startTime}, #{endTime}。修改 Mapper 接口:
Map<String, Object> 作为参数类型。@Param("params") 注解来传递 Map 参数。使用 Mapper 接口:
Map<String, Object> 参数。countByEarnTokenGroup 方法,并传递构建的参数。通过这些步骤,你可以使用 Map 作为参数来调用 MyBatis 查询,统计每个 earn_token 组的记录数量。确保在调用这个查询时,传入的 Map 对象包含了必要的参数。
不指定parameterType,可以直接在UserStakingEarnMapper里的方法里加参数吗
是的,你可以直接在 UserStakingEarnMapper 接口的方法中添加多个参数,而不需要指定 parameterType。在这种情况下,可以使用 @Param 注解来标识每个参数,以便在 MyBatis 映射文件中引用它们。
以下是如何实现这一点的示例:
你的 MyBatis 映射文件可以保持不变,只需确保在引用参数时使用 @Param 注解中的名称:
UserStakingEarnMapper.xml:
<mapper namespace="com.kucoin.gemstakingfront.common.dal.mapper.UserStakingEarnMapper">
<select id="countByEarnTokenGroup" resultType="java.lang.Long">
SELECT
COUNT(*)
FROM
gem_staking.user_staking_earn
WHERE
user_id = #{userId,jdbcType=CHAR}
AND earn_state = 1
<if test="earnToken != null">
AND earn_token = #{earnToken,jdbcType=CHAR}
</if>
<if test="startTime != null">
AND updated_at >= #{startTime,jdbcType=CHAR}
</if>
<if test="endTime != null">
AND updated_at <= #{endTime,jdbcType=CHAR}
</if>
GROUP BY
earn_token
</select>
</mapper>
在 UserStakingEarnMapper 接口中添加多个参数,并使用 @Param 注解为每个参数命名:
UserStakingEarnMapper.java:
package com.kucoin.gemstakingfront.common.dal.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@Mapper
public interface UserStakingEarnMapper {
List<Long> countByEarnTokenGroup(
@Param("userId") String userId,
@Param("earnToken") String earnToken,
@Param("startTime") String startTime,
@Param("endTime") String endTime
);
}
在你的服务类中,直接传递多个参数调用 countByEarnTokenGroup 方法:
ExampleService.java:
package com.kucoin.gemstakingfront.service;
import com.kucoin.gemstakingfront.common.dal.mapper.UserStakingEarnMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class ExampleService {
@Autowired
private UserStakingEarnMapper userStakingEarnMapper;
public List<Long> getEarnTokenCounts(String userId, String earnToken, String startTime, String endTime) {
return userStakingEarnMapper.countByEarnTokenGroup(userId, earnToken, startTime, endTime);
}
}
MyBatis 映射文件:
parameterType,因为参数名称通过 @Param 注解直接在映射文件中引用。#{userId}, #{earnToken}, #{startTime}, #{endTime}。Mapper 接口:
@Param 注解为每个方法参数命名。服务类:
通过这些步骤,你可以使用多个参数调用 MyBatis 查询,而不需要指定 parameterType。确保在映射文件中正确引用参数名称,以便 MyBatis 能够正确地将参数传递给 SQL 查询。
select Count(*) countByEarnTokenGroup这个返回值应该是long吧?
是的,COUNT(*) 的返回值是一个数值类型(在 Java 中通常是 long),因为 COUNT 函数返回的结果是记录的数量,这个数量在大多数情况下应该是 long 类型来表示。
因此,countByEarnTokenGroup 方法的返回值类型应该是 long 而不是 List<Long>。此外,由于 GROUP BY 子句的存在,返回的结果将是多个值的集合,所以你可能需要返回一个 List<Long> 或者一个包含多个值的对象。
如果你只需要一个单独的计数值:
package com.kucoin.gemstakingfront.common.dal.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
@Mapper
public interface UserStakingEarnMapper {
Long countByEarnTokenGroup(
@Param("userId") String userId,
@Param("earnToken") String earnToken,
@Param("startTime") String startTime,
@Param("endTime") String endTime
);
}
如果你需要返回多个计数值(因为 GROUP BY 会产生多个分组),你可以返回一个 List<CountResult>,其中 CountResult 是一个包含计数值和分组字段的对象:
1. 定义 CountResult 类
package com.kucoin.gemstakingfront.common.dal.dataobject;
public class CountResult {
private String earnToken;
private Long count;
// Getters and Setters
public String getEarnToken() {
return earnToken;
}
public void setEarnToken(String earnToken) {
this.earnToken = earnToken;
}
public Long getCount() {
return count;
}
public void setCount(Long count) {
this.count = count;
}
}
2. 修改 Mapper 接口
package com.kucoin.gemstakingfront.common.dal.mapper;
import com.kucoin.gemstakingfront.common.dal.dataobject.CountResult;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@Mapper
public interface UserStakingEarnMapper {
List<CountResult> countByEarnTokenGroup(
@Param("userId") String userId,
@Param("earnToken") String earnToken,
@Param("startTime") String startTime,
@Param("endTime") String endTime
);
}
3. 修改 MyBatis 映射文件
<mapper namespace="com.kucoin.gemstakingfront.common.dal.mapper.UserStakingEarnMapper">
<select id="countByEarnTokenGroup" resultType="com.kucoin.gemstakingfront.common.dal.dataobject.CountResult">
SELECT
earn_token AS earnToken,
COUNT(*) AS count
FROM
gem_staking.user_staking_earn
WHERE
user_id = #{userId,jdbcType=CHAR}
AND earn_state = 1
<if test="earnToken != null">
AND earn_token = #{earnToken,jdbcType=CHAR}
</if>
<if test="startTime != null">
AND updated_at >= #{startTime,jdbcType=CHAR}
</if>
<if test="endTime != null">
AND updated_at <= #{endTime,jdbcType=CHAR}
</if>
GROUP BY
earn_token
</select>
</mapper>
在你的服务类中,调用 countByEarnTokenGroup 方法并处理返回的结果:
ExampleService.java:
package com.kucoin.gemstakingfront.service;
import com.kucoin.gemstakingfront.common.dal.dataobject.CountResult;
import com.kucoin.gemstakingfront.common.dal.mapper.UserStakingEarnMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class ExampleService {
@Autowired
private UserStakingEarnMapper userStakingEarnMapper;
public List<CountResult> getEarnTokenCounts(String userId, String earnToken, String startTime, String endTime) {
return userStakingEarnMapper.countByEarnTokenGroup(userId, earnToken, startTime, endTime);
}
}
Long 类型。CountResult 类来包含分组字段和计数值,并在 Mapper 接口中返回 List<CountResult>。CountResult 对象的字段。通过这些步骤,你可以正确地使用 MyBatis 查询来获取每个 earn_token 组的记录数量。确保在映射文件中正确引用参数名称和返回类型。
Long countByEarnTokenGroup(
@Param("userId") String userId,
@Param("earnToken") String earnToken,
@Param("startTime") Date startTime,
@Param("endTime") Date endTime
); <select id="countByEarnTokenGroup" resultType="java.lang.Long">
select count(*)
from gem_staking.user_staking_earn
where user_id = #{userId,jdbcType=CHAR}
and earn_state = 1
<if test="earnToken != null">
and earn_token = #{earnToken,jdbcType=CHAR}
</if>
<if test="startTime != null">
and updated_at >= #{startTime,jdbcType=CHAR}
</if>
<if test="endTime != null">
and updated_at <= #{endTime,jdbcType=CHAR}
</if>
GROUP BY earn_token
</select>
你的方法定义和 MyBatis 映射文件看起来基本上是正确的,但有一些细节需要注意:
GROUP BY 子句,count(*) 将返回多个分组的计数值。因此,返回类型应该是 List<Long> 而不是单个 Long。GROUP BY:如果你希望返回多个分组的计数值,并且每个分组的计数值是单独的记录,需要调整返回类型和查询逻辑。假设你希望返回每个 earn_token 的计数值,应该返回一个包含每个 earn_token 以及相应计数值的对象列表。
定义一个包含 earn_token 和计数值的对象:
package com.kucoin.gemstakingfront.common.dal.dataobject;
public class EarnTokenCount {
private String earnToken;
private Long count;
// Getters and Setters
public String getEarnToken() {
return earnToken;
}
public void setEarnToken(String earnToken) {
this.earnToken = earnToken;
}
public Long getCount() {
return count;
}
public void setCount(Long count) {
this.count = count;
}
}
修改 Mapper 接口以返回 List<EarnTokenCount>:
package com.kucoin.gemstakingfront.common.dal.mapper;
import com.kucoin.gemstakingfront.common.dal.dataobject.EarnTokenCount;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.Date;
import java.util.List;
@Mapper
public interface UserStakingEarnMapper {
List<EarnTokenCount> countByEarnTokenGroup(
@Param("userId") String userId,
@Param("earnToken") String earnToken,
@Param("startTime") Date startTime,
@Param("endTime") Date endTime
);
}
修改 MyBatis 映射文件以返回 EarnTokenCount 对象列表:
<mapper namespace="com.kucoin.gemstakingfront.common.dal.mapper.UserStakingEarnMapper">
<select id="countByEarnTokenGroup" resultType="com.kucoin.gemstakingfront.common.dal.dataobject.EarnTokenCount">
SELECT
earn_token AS earnToken,
COUNT(*) AS count
FROM
gem_staking.user_staking_earn
WHERE
user_id = #{userId,jdbcType=CHAR}
AND earn_state = 1
<if test="earnToken != null">
AND earn_token = #{earnToken,jdbcType=CHAR}
</if>
<if test="startTime != null">
AND updated_at >= #{startTime,jdbcType=TIMESTAMP}
</if>
<if test="endTime != null">
AND updated_at <= #{endTime,jdbcType=TIMESTAMP}
</if>
GROUP BY
earn_token
</select>
</mapper>
在你的服务类中,调用 countByEarnTokenGroup 方法并处理返回的结果:
package com.kucoin.gemstakingfront.service;
import com.kucoin.gemstakingfront.common.dal.dataobject.EarnTokenCount;
import com.kucoin.gemstakingfront.common.dal.mapper.UserStakingEarnMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
@Service
public class ExampleService {
@Autowired
private UserStakingEarnMapper userStakingEarnMapper;
public List<EarnTokenCount> getEarnTokenCounts(String userId, String earnToken, Date startTime, Date endTime) {
return userStakingEarnMapper.countByEarnTokenGroup(userId, earnToken, startTime, endTime);
}
}
EarnTokenCount 类,包含 earnToken 和计数值。List<EarnTokenCount>,并使用 @Param 注解传递参数。EarnTokenCount 对象列表,并确保使用正确的 JDBC 类型。EarnTokenCount 对象列表。通过这些步骤,你可以正确地使用 MyBatis 查询来获取每个 earn_token 组的记录数量,并返回结果列表。确保在映射文件中正确引用参数名称和返回类型。
你搞错了。我的sql是select count()
from gem_staking.user_staking_earn,SELECT
earn_token AS earnToken,
COUNT() AS count你这是什么东西
抱歉,我理解错了你的需求。你希望使用 COUNT(*) 并且返回单个计数值,但是因为你使用了 GROUP BY 子句,因此你会得到多个计数值。每个分组的计数值都是一个单独的记录。
如果你希望返回每个 earn_token 组的计数值,并且每个分组的计数值是单独的记录,你可以返回一个列表。你可以返回一个包含 earn_token 和计数值的对象列表,或者返回一个 List<Long>,然后你需要明确处理每个分组的计数值。
List<Long> 返回多个计数值如果你只需要返回计数值而不关心具体的 earn_token,你可以直接返回 List<Long>。以下是示例:
UserStakingEarnMapper.xml:
<mapper namespace="com.kucoin.gemstakingfront.common.dal.mapper.UserStakingEarnMapper">
<select id="countByEarnTokenGroup" resultType="java.lang.Long">
SELECT
COUNT(*)
FROM
gem_staking.user_staking_earn
WHERE
user_id = #{userId,jdbcType=CHAR}
AND earn_state = 1
<if test="earnToken != null">
AND earn_token = #{earnToken,jdbcType=CHAR}
</if>
<if test="startTime != null">
AND updated_at >= #{startTime,jdbcType=TIMESTAMP}
</if>
<if test="endTime != null">
AND updated_at <= #{endTime,jdbcType=TIMESTAMP}
</if>
GROUP BY
earn_token
</select>
</mapper>
UserStakingEarnMapper.java:
package com.kucoin.gemstakingfront.common.dal.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.Date;
import java.util.List;
@Mapper
public interface UserStakingEarnMapper {
List<Long> countByEarnTokenGroup(
@Param("userId") String userId,
@Param("earnToken") String earnToken,
@Param("startTime") Date startTime,
@Param("endTime") Date endTime
);
}
List<EarnTokenCount> 返回多个计数值和 earn_token如果你需要返回计数值和每个 earn_token,你可以返回一个包含 earn_token 和计数值的对象列表。
EarnTokenCount.java:
package com.kucoin.gemstakingfront.common.dal.dataobject;
public class EarnTokenCount {
private String earnToken;
private Long count;
// Getters and Setters
public String getEarnToken() {
return earnToken;
}
public void setEarnToken(String earnToken) {
this.earnToken = earnToken;
}
public Long getCount() {
return count;
}
public void setCount(Long count) {
this.count = count;
}
}
UserStakingEarnMapper.xml:
<mapper namespace="com.kucoin.gemstakingfront.common.dal.mapper.UserStakingEarnMapper">
<select id="countByEarnTokenGroup" resultType="com.kucoin.gemstakingfront.common.dal.dataobject.EarnTokenCount">
SELECT
earn_token AS earnToken,
COUNT(*) AS count
FROM
gem_staking.user_staking_earn
WHERE
user_id = #{userId,jdbcType=CHAR}
AND earn_state = 1
<if test="earnToken != null">
AND earn_token = #{earnToken,jdbcType=CHAR}
</if>
<if test="startTime != null">
AND updated_at >= #{startTime,jdbcType=TIMESTAMP}
</if>
<if test="endTime != null">
AND updated_at <= #{endTime,jdbcType=TIMESTAMP}
</if>
GROUP BY
earn_token
</select>
</mapper>
UserStakingEarnMapper.java:
package com.kucoin.gemstakingfront.common.dal.mapper;
import com.kucoin.gemstakingfront.common.dal.dataobject.EarnTokenCount;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.Date;
import java.util.List;
@Mapper
public interface UserStakingEarnMapper {
List<EarnTokenCount> countByEarnTokenGroup(
@Param("userId") String userId,
@Param("earnToken") String earnToken,
@Param("startTime") Date startTime,
@Param("endTime") Date endTime
);
}
在你的服务类中,调用 countByEarnTokenGroup 方法并处理返回的结果:
ExampleService.java:
package com.kucoin.gemstakingfront.service;
import com.kucoin.gemstakingfront.common.dal.dataobject.EarnTokenCount;
import com.kucoin.gemstakingfront.common.dal.mapper.UserStakingEarnMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
@Service
public class ExampleService {
@Autowired
private UserStakingEarnMapper userStakingEarnMapper;
public List<EarnTokenCount> getEarnTokenCounts(String userId, String earnToken, Date startTime, Date endTime) {
return userStakingEarnMapper.countByEarnTokenGroup(userId, earnToken, startTime, endTime);
}
}
EarnTokenCount 类,包含 earnToken 和计数值。List<EarnTokenCount>,并使用 @Param 注解传递参数。EarnTokenCount 对象列表,并确保使用正确你完全错了。我是先分组统计数量,然后分页分组统计结果。先解决分组统计数量
明白了,我理解错了你的需求。你是希望先统计每个 earn_token 的数量,然后进行分页查询。下面是如何实现这个需求的步骤:
earn_token 的数量我们首先需要编写一个 SQL 查询,统计每个 earn_token 的数量。
UserStakingEarnMapper.xml:
<mapper namespace="com.kucoin.gemstakingfront.common.dal.mapper.UserStakingEarnMapper">
<select id="countByEarnTokenGroup" resultType="java.lang.Long">
SELECT
COUNT(*)
FROM
gem_staking.user_staking_earn
WHERE
user_id = #{userId,jdbcType=CHAR}
AND earn_state = 1
<if test="earnToken != null">
AND earn_token = #{earnToken,jdbcType=CHAR}
</if>
<if test="startTime != null">
AND updated_at >= #{startTime,jdbcType=TIMESTAMP}
</if>
<if test="endTime != null">
AND updated_at <= #{endTime,jdbcType=TIMESTAMP}
</if>
GROUP BY
earn_token
</select>
</mapper>
UserStakingEarnMapper.java:
package com.kucoin.gemstakingfront.common.dal.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.Date;
import java.util.List;
@Mapper
public interface UserStakingEarnMapper {
List<Long> countByEarnTokenGroup(
@Param("userId") String userId,
@Param("earnToken") String earnToken,
@Param("startTime") Date startTime,
@Param("endTime") Date endTime
);
}
在你的服务类中,调用 countByEarnTokenGroup 方法并处理返回的结果:
ExampleService.java:
package com.kucoin.gemstakingfront.service;
import com.kucoin.gemstakingfront.common.dal.mapper.UserStakingEarnMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
@Service
public class ExampleService {
@Autowired
private UserStakingEarnMapper userStakingEarnMapper;
public List<Long> getEarnTokenCounts(String userId, String earnToken, Date startTime, Date endTime) {
return userStakingEarnMapper.countByEarnTokenGroup(userId, earnToken, startTime, endTime);
}
}
earn_token 的统计结果为了实现分页查询,我们需要修改 SQL 查询,以返回分页后的结果。
UserStakingEarnMapper.xml:
<mapper namespace="com.kucoin.gemstakingfront.common.dal.mapper.UserStakingEarnMapper">
<select id="selectPagedEarnTokenCount" resultType="com.kucoin.gemstakingfront.common.dal.dataobject.EarnTokenCount">
SELECT
earn_token AS earnToken,
COUNT(*) AS count
FROM
gem_staking.user_staking_earn
WHERE
user_id = #{userId,jdbcType=CHAR}
AND earn_state = 1
<if test="earnToken != null">
AND earn_token = #{earnToken,jdbcType=CHAR}
</if>
<if test="startTime != null">
AND updated_at >= #{startTime,jdbcType=TIMESTAMP}
</if>
<if test="endTime != null">
AND updated_at <= #{endTime,jdbcType=TIMESTAMP}
</if>
GROUP BY
earn_token
ORDER BY
earn_token
LIMIT #{offset}, #{pageSize}
</select>
</mapper>
UserStakingEarnMapper.java:
package com.kucoin.gemstakingfront.common.dal.mapper;
import com.kucoin.gemstakingfront.common.dal.dataobject.EarnTokenCount;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.Date;
import java.util.List;
@Mapper
public interface UserStakingEarnMapper {
List<Long> countByEarnTokenGroup(
@Param("userId") String userId,
@Param("earnToken") String earnToken,
@Param("startTime") Date startTime,
@Param("endTime") Date endTime
);
List<EarnTokenCount> selectPagedEarnTokenCount(
@Param("userId") String userId,
@Param("earnToken") String earnToken,
@Param("startTime") Date startTime,
@Param("endTime") Date endTime,
@Param("offset") int offset,
@Param("pageSize") int pageSize
);
}
在你的服务类中,调用 selectPagedEarnTokenCount 方法并处理返回的结果:
ExampleService.java:
package com.kucoin.gemstakingfront.service;
import com.kucoin.gemstakingfront.common.dal.dataobject.EarnTokenCount;
import com.kucoin.gemstakingfront.common.dal.mapper.UserStakingEarnMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
@Service
public class ExampleService {
@Autowired
private UserStakingEarnMapper userStakingEarnMapper;
public List<Long> getEarnTokenCounts(String userId, String earnToken, Date startTime, Date endTime) {
return userStakingEarnMapper.countByEarnTokenGroup(userId, earnToken, startTime, endTime);
}
public List<EarnTokenCount> getPagedEarnTokenCounts(String userId, String earnToken, Date startTime, Date endTime, int offset, int pageSize) {
return userStakingEarnMapper.selectPagedEarnTokenCount(userId, earnToken, startTime, endTime,
我的需求是想获得分组后有多少条记录
明白了,你的需求是想获得分组后的记录数,而不是每个分组内的记录数。也就是说,你希望知道有多少个不同的 earn_token 分组。
你可以编写一个 SQL 查询,使用 GROUP BY 和 COUNT(DISTINCT earn_token) 来获得分组后的记录数。
以下是一个示例查询,可以满足你的需求:
UserStakingEarnMapper.xml:
<mapper namespace="com.kucoin.gemstakingfront.common.dal.mapper.UserStakingEarnMapper">
<select id="countDistinctEarnTokenGroups" resultType="java.lang.Long">
SELECT
COUNT(DISTINCT earn_token)
FROM
gem_staking.user_staking_earn
WHERE
user_id = #{userId,jdbcType=CHAR}
AND earn_state = 1
<if test="earnToken != null">
AND earn_token = #{earnToken,jdbcType=CHAR}
</if>
<if test="startTime != null">
AND updated_at >= #{startTime,jdbcType=TIMESTAMP}
</if>
<if test="endTime != null">
AND updated_at <= #{endTime,jdbcType=TIMESTAMP}
</if>
</select>
</mapper>
UserStakingEarnMapper.java:
package com.kucoin.gemstakingfront.common.dal.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.Date;
@Mapper
public interface UserStakingEarnMapper {
Long countDistinctEarnTokenGroups(
@Param("userId") String userId,
@Param("earnToken") String earnToken,
@Param("startTime") Date startTime,
@Param("endTime") Date endTime
);
}
在你的服务类中,调用 countDistinctEarnTokenGroups 方法并处理返回的结果:
ExampleService.java:
package com.kucoin.gemstakingfront.service;
import com.kucoin.gemstakingfront.common.dal.mapper.UserStakingEarnMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Date;
@Service
public class ExampleService {
@Autowired
private UserStakingEarnMapper userStakingEarnMapper;
public Long getDistinctEarnTokenGroupCount(String userId, String earnToken, Date startTime, Date endTime) {
return userStakingEarnMapper.countDistinctEarnTokenGroups(userId, earnToken, startTime, endTime);
}
}
SQL 查询:
SELECT COUNT(DISTINCT earn_token):计算不同 earn_token 的数量。FROM gem_staking.user_staking_earn:从 user_staking_earn 表中查询数据。WHERE user_id = #{userId,jdbcType=CHAR} AND earn_state = 1:过滤符合条件的记录。AND earn_token = #{earnToken,jdbcType=CHAR}(如果 earnToken 不为空):按奖励币种过滤。AND updated_at >= #{startTime,jdbcType=TIMESTAMP}(如果 startTime 不为空):按开始时间过滤。AND updated_at <= #{endTime,jdbcType=TIMESTAMP}(如果 endTime 不为空):按结束时间过滤。Mapper 接口:
countDistinctEarnTokenGroups 方法,返回 Long 类型。@Param 注解传递参数。服务类:
countDistinctEarnTokenGroups 方法,并处理返回的结果。通过这些步骤,你可以获得分组后有多少条记录,即不同 earn_token 的数量。确保在调用这个查询时,传入的参数包含了必要的过滤条件。
List<StakingCampaignBonusTaskDO> bonusTaskDOS = bonusTaskMapper.selectByExample(bonusTaskDOExample);
遍历一下bonusTaskDOS,StakingCampaignBonusTaskDO有个taskType,0表示做题,要取做题的StakingCampaignBonusTaskDO
你可以通过遍历 bonusTaskDOS 列表,并检查每个 StakingCampaignBonusTaskDO 对象的 taskType 属性来过滤出 taskType 为 0 的对象。这可以使用传统的 for 循环或 Java 8 的 Streams API 来实现。
for 循环以下是使用传统的 for 循环来遍历列表并过滤出 taskType 为 0 的示例:
import java.util.ArrayList;
import java.util.List;
public class Example {
public static void main(String[] args) {
// 假设这是你的查询结果
List<StakingCampaignBonusTaskDO> bonusTaskDOS = bonusTaskMapper.selectByExample(bonusTaskDOExample);
// 创建一个新的列表来存储 taskType 为 0 的对象
List<StakingCampaignBonusTaskDO> filteredTaskDOS = new ArrayList<>();
for (StakingCampaignBonusTaskDO taskDO : bonusTaskDOS) {
if (taskDO.getTaskType() == 0) {
filteredTaskDOS.add(taskDO);
}
}
// 打印结果或其他处理
for (StakingCampaignBonusTaskDO taskDO : filteredTaskDOS) {
System.out.println(taskDO);
}
}
}
以下是使用 Java 8 Streams API 来实现相同功能的示例:
import java.util.List;
import java.util.stream.Collectors;
public class Example {
public static void main(String[] args) {
// 假设这是你的查询结果
List<StakingCampaignBonusTaskDO> bonusTaskDOS = bonusTaskMapper.selectByExample(bonusTaskDOExample);
// 使用 Streams API 过滤 taskType 为 0 的对象
List<StakingCampaignBonusTaskDO> filteredTaskDOS = bonusTaskDOS.stream()
.filter(taskDO -> taskDO.getTaskType() == 0)
.collect(Collectors.toList());
// 打印结果或其他处理
filteredTaskDOS.forEach(System.out::println);
}
}
确保你的 StakingCampaignBonusTaskDO 类具有 getTaskType 方法。例如:
public class StakingCampaignBonusTaskDO {
private int taskType;
// 其他属性和方法省略...
public int getTaskType() {
return taskType;
}
public void setTaskType(int taskType) {
this.taskType = taskType;
}
@Override
public String toString() {
return "StakingCampaignBonusTaskDO{" +
"taskType=" + taskType +
// 其他属性的 toString 方法
'}';
}
}
for 循环:遍历 bonusTaskDOS 列表,并检查每个对象的 taskType 属性。如果 taskType 为 0,则将对象添加到新的列表中。stream() 方法将 bonusTaskDOS 列表转换为流,使用 filter 方法过滤 taskType 为 0 的对象,并使用 collect(Collectors.toList()) 将流转换回列表。你可以根据项目的具体需求和代码风格选择适合的方法。
int questionNO = 1;
List<BonusTaskExamVO> bonusTaskExamVOS = bonusTaskDOS.stream().map(bonusTaskDO ->{
BonusTaskExamVO bonusTaskExamVO = new BonusTaskExamVO();
bonusTaskExamVO.setBusIsd(bonusTaskDO.getBusId());
JsonObject content = parseTranslationContent(lang, bonusTaskDO.getTranslationContent())
if (null != content) {
bonusTaskExamVO.setQuestion(content.get("question").getAsString());
bonusTaskExamVO.setAnswer1(content.get("answer1").getAsString());
bonusTaskExamVO.setAnswer2(content.get("answer2").getAsString());
bonusTaskExamVO.setAnswer3(content.get("answer3").getAsString());
bonusTaskExamVO.setAnswer4(content.get("answer4").getAsString());
}
bonusTaskExamVO.setQuestionNo(questionNO);
return bonusTaskExamVO;
}).collect(Collectors.toList());如何实现questionNO自增+1
在 Java Streams 中,变量 questionNO 是一个局部变量,不能在 lambda 表达式中直接修改。为了实现 questionNO 自增,你可以使用一个 AtomicInteger 来解决这个问题。AtomicInteger 是一个线程安全的整数变量,可以在 lambda 表达式中修改。
以下是如何使用 AtomicInteger 实现 questionNO 自增的示例:
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import com.google.gson.JsonObject;
public class Example {
public static void main(String[] args) {
// 假设这是你的查询结果
List<StakingCampaignBonusTaskDO> bonusTaskDOS = bonusTaskMapper.selectByExample(bonusTaskDOExample);
// 创建一个 AtomicInteger 变量来存储 questionNO
AtomicInteger questionNO = new AtomicInteger(1);
// 使用 Streams API 生成 BonusTaskExamVO 列表,并实现 questionNO 自增
List<BonusTaskExamVO> bonusTaskExamVOS = bonusTaskDOS.stream().map(bonusTaskDO -> {
BonusTaskExamVO bonusTaskExamVO = new BonusTaskExamVO();
bonusTaskExamVO.setBusIsd(bonusTaskDO.getBusId());
JsonObject content = parseTranslationContent(lang, bonusTaskDO.getTranslationContent());
if (content != null) {
bonusTaskExamVO.setQuestion(content.get("question").getAsString());
bonusTaskExamVO.setAnswer1(content.get("answer1").getAsString());
bonusTaskExamVO.setAnswer2(content.get("answer2").getAsString());
bonusTaskExamVO.setAnswer3(content.get("answer3").getAsString());
bonusTaskExamVO.setAnswer4(content.get("answer4").getAsString());
}
bonusTaskExamVO.setQuestionNo(questionNO.getAndIncrement());
return bonusTaskExamVO;
}).collect(Collectors.toList());
// 打印结果或其他处理
bonusTaskExamVOS.forEach(System.out::println);
}
private static JsonObject parseTranslationContent(String lang, String translationContent) {
// 假设这是一个解析 translationContent 的方法
// 返回一个 JsonObject
return new JsonObject();
}
}
使用 AtomicInteger:
AtomicInteger 变量 questionNO,初始值为 1。questionNO.getAndIncrement() 方法来获取当前值并递增。Streams API:
stream() 方法将 bonusTaskDOS 列表转换为流。map 方法将每个 StakingCampaignBonusTaskDO 对象转换为 BonusTaskExamVO 对象。collect(Collectors.toList()) 将流转换回列表。解析 translationContent:
parseTranslationContent 方法返回一个 JsonObject。JsonObject 中提取问题和答案,并设置到 BonusTaskExamVO 对象中。确保你的相关类具有适当的属性和方法,例如:
public class StakingCampaignBonusTaskDO {
private String busId;
private String translationContent;
// Getters and Setters
public String getBusId() {
return busId;
}
public void setBusId(String busId) {
this.busId = busId;
}
public String getTranslationContent() {
return translationContent;
}
public void setTranslationContent(String translationContent) {
this.translationContent = translationContent;
}
}
public class BonusTaskExamVO {
private String busIsd;
private String question;
private String answer1;
private String answer2;
private String answer3;
private String answer4;
private int questionNo;
// Getters and Setters
public String getBusIsd() {
return busIsd;
}
public void setBusIsd(String busIsd) {
this.busIsd = busIsd;
}
public String getQuestion() {
return question;
}
public void setQuestion(String question) {
this.question = question;
}
public String getAnswer1() {
return answer1;
}
public void setAnswer1(String answer1) {
this.answer1 = answer1;
}
public String getAnswer2() {
return answer2;
}
public void setAnswer2(String answer2) {
this.answer2 = answer2;
}
public String getAnswer3() {
return answer3;
}
public void setAnswer3(String answer3) {
this.answer3 = answer3;
}
public String getAnswer4() {
return answer4;
}
public void setAnswer4(String answer4) {
this.answer4 = answer4;
}
public int getQuestionNo() {
return questionNo;
}
public void setQuestionNo(int questionNo) {
this.questionNo = questionNo;
}
@Override
public String toString() {
return "BonusTaskExamVO{" +
"busIsd='" + busIsd + '\'' +
", question='" + question + '\'' +
", answer1='" + answer1 + '\'' +
", answer2='" + answer2 + '\'' +
", answer3='" + answer3 + '\'' +
", answer4='" + answer4 + '\'' +
", questionNo=" + questionNo +
'}';
}
}
通过这些代码,你可以实现 questionNO 自增,并生成 BonusTaskExamVO 列表。
List<AnswerBO> answerVOS = campaignExamSubmitRequest.getAnswers();这是用户答题的答案。@Data
public class AnswerBO {
/**
* 题号
/
private String busId;
private String answer;
}。List<StakingCampaignExamDO> bonusTaskDOS = campaignExamMapper.selectByExample(stakingCampaignExamDOExample);这个是题库,里面有答案,public class StakingCampaignExamDO {
/*
* 主键ID
*/
private Long id;
/**
* VIPconfig唯一ID
*/
private String busId;
/**
* taskID
*/
private String taskId;
/**
* 活动ID
*/
private String campaignId;
/**
* 考卷题目
*/
private String question;
/**
* 答案1
*/
private String answer1;
/**
* 答案2
*/
private String answer2;
/**
* 答案3
*/
private String answer3;
/**
* 答案4
*/
private String answer4;
/**
* 正确答案
*/
private String rightAnswer;
/**
* 0 草稿 1 生效
*/
private Integer status;
/**
* 创建时间
*/
private Date createdAt;
/**
* 更新时间
*/
private Date updatedAt;
/**
* 操作人
*/
private String operator;
/**
* 国际化内容: {zh_HK:{}}
*/
private String translationContent;}请帮我校验每一题是否正确,结果放到这里面List<AnswerCheckVO>,@Data
public class AnswerCheckVO {
/**
* --0表示有错,1表示全对
/
private int result;
/*
* 获得对加成系数
*/
private BigDecimal bonusCoefficient;
private List<AnswerVO> results;
}@Data
public class AnswerVO {
/**
* 题号
/
private String busId;
private String answer;
/*
* 0,答错,1答对
*/
private int result;
}
你可以通过遍历用户的答案列表 answerVOS 和题库 bonusTaskDOS 来校验每一题是否正确。然后,将校验结果放到 List<AnswerCheckVO> 中。以下是具体的实现步骤和示例代码:
answerVOS。bonusTaskDOS 中找到对应的题目。AnswerCheckVO 和 AnswerVO 对象中。import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Example {
public static void main(String[] args) {
// 假设这些是从数据库查询得到的结果
List<StakingCampaignExamDO> bonusTaskDOS = campaignExamMapper.selectByExample(stakingCampaignExamDOExample);
List<AnswerBO> answerVOS = campaignExamSubmitRequest.getAnswers();
// 创建一个 Map 来快速查找题库中的题目
Map<String, StakingCampaignExamDO> questionMap = new HashMap<>();
for (StakingCampaignExamDO examDO : bonusTaskDOS) {
questionMap.put(examDO.getBusId(), examDO);
}
// 创建 AnswerCheckVO 对象
AnswerCheckVO answerCheckVO = new AnswerCheckVO();
List<AnswerVO> results = new ArrayList<>();
int totalCorrect = 0;
// 遍历用户答案列表
for (AnswerBO answerBO : answerVOS) {
AnswerVO answerVO = new AnswerVO();
answerVO.setBusId(answerBO.getBusId());
answerVO.setAnswer(answerBO.getAnswer());
// 从题库中找到对应的题目
StakingCampaignExamDO examDO = questionMap.get(answerBO.getBusId());
if (examDO != null) {
// 比较答案
if (examDO.getRightAnswer().equals(answerBO.getAnswer())) {
answerVO.setResult(1);
totalCorrect++;
} else {
answerVO.setResult(0);
}
} else {
answerVO.setResult(0); // 如果题库中找不到对应的题目,默认为答错
}
results.add(answerVO);
}
// 设置 AnswerCheckVO 的属性
answerCheckVO.setResults(results);
answerCheckVO.setResult(totalCorrect == answerVOS.size() ? 1 : 0); // 全对为 1,有错为 0
answerCheckVO.setBonusCoefficient(new BigDecimal(totalCorrect)); // 示例:使用正确答案数量作为加成系数
// 创建一个列表来存放 AnswerCheckVO
List<AnswerCheckVO> answerCheckVOS = new ArrayList<>();
answerCheckVOS.add(answerCheckVO);
// 打印结果或其他处理
answerCheckVOS.forEach(System.out::println);
}
}
确保你的相关类具有适当的属性和方法,例如:
@Data
public class AnswerBO {
private String busId;
private String answer;
}
@Data
public class StakingCampaignExamDO {
private Long id;
private String busId;
private String taskId;
private String campaignId;
private String question;
private String answer1;
private String answer2;
private String answer3;
private String answer4;
private String rightAnswer;
private Integer status;
private Date createdAt;
private Date updatedAt;
private String operator;
private String translationContent;
}
@Data
public class AnswerCheckVO {
private int result;
private BigDecimal bonusCoefficient;
private List<AnswerVO> results;
}
@Data
public class AnswerVO {
private String busId;
private String answer;
private int result;
}
bonusTaskDOS 转换为 Map,以便快速查找题目。answerVOS,对于每个答案,从 questionMap 中找到对应的题目,并进行答案校验。AnswerCheckVO 和 AnswerVO 对象中,计算总的校验结果和加成系数。通过这些代码,你可以实现每一题的校验,并将结果放到 List<AnswerCheckVO> 中。
List<UserStakingTaskBonusDO> userStakingTaskBonusDOS = userStakingTaskBonusMapper.selectByExample(userStakingTaskBonusDOExample);
这是用户完成任务的记录。 List<StakingCampaignBonusTaskDO> bonusTaskDOS = campaignBonusTaskMapper.selectByExample(bonusTaskDOExample);
这是配置的任务。public class StakingCampaignBonusTaskDO {
/**
* 主键ID
*/
private Long id;
/**
* taskID
*/
private String taskId;
/**
* 活动ID
*/
private String campaignId;
/**
* 该任务奖励系数
*/
private BigDecimal bonusCoefficient;
/**
* 任务分类,0做题,1VIP
*/
private Integer taskType;
/**
* 记录状态 ,-1,逻辑删除,0生效
*/
private Integer status;
/**
* 创建时间
*/
private Date createdAt;
/**
* 更新时间
*/
private Date updatedAt;
/**
* 操作人
*/
private String operator;},public class UserStakingTaskBonusDO {
/**
* 主键ID
*/
private Long id;
/**
* 唯一ID
*/
private String busId;
/**
* 用户ID
*/
private String userId;
/**
* 活动ID
*/
private String campaignId;
/**
* 奖池任务ID
*/
private String taskId;
/**
* 0答题,1VIP
*/
private Integer taskType;
/**
* 完成状态,未完成1完成
*/
private Integer taskState;
/**
* 用户当前的奖励系数
*/
private BigDecimal bonusCoefficient;
/**
* 创建时间
*/
private Date createdAt;
/**
* 更新时间
*/
private Date updatedAt;}请帮我判断用户是否完成所有的任务。通过任务类型比较。
要判断用户是否完成所有的任务,可以通过以下步骤实现:
bonusTaskDOS。userStakingTaskBonusDOS 中是否存在对应的记录,并且任务状态为已完成。以下是实现这一逻辑的示例代码:
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class Example {
public static void main(String[] args) {
// 假设这些是从数据库查询得到的结果
List<UserStakingTaskBonusDO> userStakingTaskBonusDOS = userStakingTaskBonusMapper.selectByExample(userStakingTaskBonusDOExample);
List<StakingCampaignBonusTaskDO> bonusTaskDOS = campaignBonusTaskMapper.selectByExample(bonusTaskDOExample);
// 将用户完成任务记录转换为 Map,键为 taskId,值为 UserStakingTaskBonusDO
Map<String, UserStakingTaskBonusDO> userTaskMap = userStakingTaskBonusDOS.stream()
.collect(Collectors.toMap(UserStakingTaskBonusDO::getTaskId, task -> task));
// 遍历配置的任务列表,检查是否每个任务都已完成
boolean allTasksCompleted = true;
for (StakingCampaignBonusTaskDO bonusTask : bonusTaskDOS) {
UserStakingTaskBonusDO userTask = userTaskMap.get(bonusTask.getTaskId());
if (userTask == null || userTask.getTaskState() != 1) { // 1 表示任务已完成
allTasksCompleted = false;
break;
}
}
// 输出结果
if (allTasksCompleted) {
System.out.println("用户已完成所有任务");
} else {
System.out.println("用户未完成所有任务");
}
}
}
将用户完成任务记录转换为 Map:
Collectors.toMap 将 userStakingTaskBonusDOS 列表转换为 Map<String, UserStakingTaskBonusDO>,键为 taskId,值为 UserStakingTaskBonusDO 对象,以便快速查找。遍历配置的任务列表:
bonusTaskDOS 列表,对于每个 StakingCampaignBonusTaskDO 对象,从 userTaskMap 中查找对应的 UserStakingTaskBonusDO 对象。taskState == 1)。allTasksCompleted 为 false 并跳出循环。输出结果:
allTasksCompleted 的值,输出用户是否已完成所有任务。确保你的相关类具有适当的属性和方法,例如:
@Data
public class StakingCampaignBonusTaskDO {
private Long id;
private String taskId;
private String campaignId;
private BigDecimal bonusCoefficient;
private Integer taskType;
private Integer status;
private Date createdAt;
private Date updatedAt;
private String operator;
}
@Data
public class UserStakingTaskBonusDO {
private Long id;
private String busId;
private String userId;
private String campaignId;
private String taskId;
private Integer taskType;
private Integer taskState;
private BigDecimal bonusCoefficient;
private Date createdAt;
private Date updatedAt;
}
通过这些代码,你可以判断用户是否完成了所有配置的任务。确保在实现过程中正确处理每个任务的状态和类型。
mysql表存储年月日时分的字段用什么类型
在 MySQL 中,存储日期和时间的字段有多个选项,具体选择取决于你需要存储的精度和范围。以下是存储年月日时分的常见类型:
DATETIMEDATETIME 类型可以存储日期和时间,并且能够存储年月日时分秒。它通常用于存储不依赖时区的日期和时间。
示例:
CREATE TABLE example_table (
id INT AUTO_INCREMENT PRIMARY KEY,
event_time DATETIME NOT NULL
);
TIMESTAMPTIMESTAMP 类型也可以存储日期和时间,并且能够存储年月日时分秒。它会根据当前会话的时区转换存储的时间,并且通常用于存储依赖时区的日期和时间。
示例:
CREATE TABLE example_table (
id INT AUTO_INCREMENT PRIMARY KEY,
event_time TIMESTAMP NOT NULL
);
DATE 和 TIME如果你只需要存储日期部分或时间部分,可以分别使用 DATE 和 TIME 类型。
DATE 类型只存储日期部分(年月日),范围是 '1000-01-01' 到 '9999-12-31'。TIME 类型只存储时间部分(时分秒),范围是 '-838:59:59' 到 '838:59:59'。示例:
CREATE TABLE example_table (
id INT AUTO_INCREMENT PRIMARY KEY,
event_date DATE NOT NULL,
event_time TIME NOT NULL
);
在大多数情况下,如果你需要存储完整的日期和时间(包括年月日时分秒),DATETIME 类型是最常见的选择。如果你的应用程序需要处理时区转换,TIMESTAMP 可能更适合。
以下是一个包含 DATETIME 和 TIMESTAMP 字段的示例表:
CREATE TABLE example_table (
id INT AUTO_INCREMENT PRIMARY KEY,
created_at DATETIME NOT NULL,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);
created_at 字段使用 DATETIME 类型,通常用于记录创建时间。updated_at 字段使用 TIMESTAMP 类型,并设置默认值为当前时间戳,并在记录更新时自动更新。通过选择合适的数据类型,你可以确保日期和时间数据的精度和范围满足应用程序的需求。
TIMESTAMP和时区无关吗
TIMESTAMP 类型与时区有关,这是它与 DATETIME 类型的一个关键区别。
TIMESTAMP 类型TIMESTAMP 类型会根据当前会话的时区存储和检索数据。TIMESTAMP 字段可以自动初始化为当前时间戳,并在记录更新时自动更新。DATETIME 类型DATETIME 类型存储的是一个固定的日期和时间值,不会根据时区进行转换。假设你在 UTC 时区插入了一条记录,并且后来在不同时区检索它:
TIMESTAMPCREATE TABLE example_timestamp (
id INT AUTO_INCREMENT PRIMARY KEY,
event_time TIMESTAMP NOT NULL
);
-- 插入当前时间
INSERT INTO example_timestamp (event_time) VALUES (CURRENT_TIMESTAMP);
-- 在 UTC 时区检索
SET time_zone = '+00:00';
SELECT event_time FROM example_timestamp;
-- 在东八区(中国标准时间)检索
SET time_zone = '+08:00';
SELECT event_time FROM example_timestamp;
在 UTC 时区插入的时间可能是 2023-10-01 12:00:00,而在东八区检索时,时间会显示为 2023-10-01 20:00:00,因为 TIMESTAMP 类型会根据时区进行转换。
DATETIMECREATE TABLE example_datetime (
id INT AUTO_INCREMENT PRIMARY KEY,
event_time DATETIME NOT NULL
);
-- 插入当前时间
INSERT INTO example_datetime (event_time) VALUES (CURRENT_TIMESTAMP);
-- 在 UTC 时区检索
SET time_zone = '+00:00';
SELECT event_time FROM example_datetime;
-- 在东八区(中国标准时间)检索
SET time_zone = '+08:00';
SELECT event_time FROM example_datetime;
无论时区如何变化,DATETIME 字段都会显示插入时的固定值,例如 2023-10-01 12:00:00。
DATETIME。TIMESTAMP。以下是一个示例表,包含 DATETIME 和 TIMESTAMP 字段,分别用于不同的用途:
CREATE TABLE example_table (
id INT AUTO_INCREMENT PRIMARY KEY,
event_time DATETIME NOT NULL, -- 与时区无关的事件时间
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, -- 记录的创建时间(与时区相关)
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP -- 记录的最后更新时间(与时区相关)
);
通过选择合适的类型,你可以确保日期和时间数据的存储和检索方式满足应用需求。
CREATE TABLE gem_staking.user_reward_summary (
id BIGINT AUTO_INCREMENT COMMENT '主键ID',
user_id CHAR(24) NOT NULL DEFAULT '' COMMENT '用户ID',
pool_id CHAR(24) NOT NULL DEFAULT '' COMMENT '矿池ID',
staking_hold_token CHAR(24) NOT NULL DEFAULT '' COMMENT '质押币种',
staking_hold_amount_avg DECIMAL(38, 20) DEFAULT '0.00000000000000000000' NOT NULL COMMENT '持仓余额',
earn_token CHAR(24) NOT NULL DEFAULT '' COMMENT '挖的币种',
summary_stage INT NOT NULL default 1 COMMENT '汇总阶段,挖矿总时长/收益周期,从1开始',
cal_state INT NOT NULL default 0 COMMENT '是否算过收益,0表示没有,1表示算过了',
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (id),
KEY id_pool_stage_cal (pool_id,summary_stage,cal_state) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='用户持仓快照汇总表';如果这个表里有100000条数据,需要从这个表里一个用户一个用户的计算收益,将收益结果插入收益表里。如何高性能的实现。
为了高性能地从大量数据中计算收益并插入到收益表中,你可以考虑以下几种优化策略:
以下是一个示例代码,展示了如何高效地处理大量数据:
首先,确保你已经定义了收益表:
CREATE TABLE gem_staking.user_rewards (
id BIGINT AUTO_INCREMENT COMMENT '主键ID',
user_id CHAR(24) NOT NULL DEFAULT '' COMMENT '用户ID',
pool_id CHAR(24) NOT NULL DEFAULT '' COMMENT '矿池ID',
earn_token CHAR(24) NOT NULL DEFAULT '' COMMENT '收益币种',
reward_amount DECIMAL(38, 20) DEFAULT '0.00000000000000000000' NOT NULL COMMENT '收益金额',
summary_stage INT NOT NULL COMMENT '汇总阶段',
created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='用户收益表';
使用 Java 进行分批处理和多线程并发:
import java.math.BigDecimal;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class RewardCalculator {
private static final int BATCH_SIZE = 1000; // 每批处理的记录数
private static final int THREAD_POOL_SIZE = 10; // 线程池大小
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
try (Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/gem_staking", "username", "password")) {
int offset = 0;
List<UserRewardSummary> userRewardSummaries;
do {
userRewardSummaries = fetchUserRewardSummaries(connection, offset, BATCH_SIZE);
offset += BATCH_SIZE;
if (!userRewardSummaries.isEmpty()) {
executorService.submit(() -> {
List<UserReward> rewards = calculateRewards(userRewardSummaries);
insertRewards(connection, rewards);
});
}
} while (!userRewardSummaries.isEmpty());
} catch (SQLException e) {
e.printStackTrace();
} finally {
executorService.shutdown();
}
}
private static List<UserRewardSummary> fetchUserRewardSummaries(Connection connection, int offset, int batchSize) throws SQLException {
List<UserRewardSummary> summaries = new ArrayList<>();
String query = "SELECT * FROM gem_staking.user_reward_summary LIMIT ? OFFSET ?";
try (PreparedStatement ps = connection.prepareStatement(query)) {
ps.setInt(1, batchSize);
ps.setInt(2, offset);
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
UserRewardSummary summary = new UserRewardSummary();
summary.setId(rs.getLong("id"));
summary.setUserId(rs.getString("user_id"));
summary.setPoolId(rs.getString("pool_id"));
summary.setStakingHoldToken(rs.getString("staking_hold_token"));
summary.setStakingHoldAmountAvg(rs.getBigDecimal("staking_hold_amount_avg"));
summary.setEarnToken(rs.getString("earn_token"));
summary.setSummaryStage(rs.getInt("summary_stage"));
summary.setCalState(rs.getInt("cal_state"));
summary.setCreatedAt(rs.getTimestamp("created_at"));
summary.setUpdatedAt(rs.getTimestamp("updated_at"));
summaries.add(summary);
}
}
}
return summaries;
}
private static List<UserReward> calculateRewards(List<UserRewardSummary> summaries) {
List<UserReward> rewards = new ArrayList<>();
for (UserRewardSummary summary : summaries) {
UserReward reward = new UserReward();
reward.setUserId(summary.getUserId());
reward.setPoolId(summary.getPoolId());
reward.setEarnToken(summary.getEarnToken());
reward.setRewardAmount(summary.getStakingHoldAmountAvg().multiply(new BigDecimal("0.1"))); // 示例:收益计算逻辑
reward.setSummaryStage(summary.getSummaryStage());
rewards.add(reward);
}
return rewards;
}
private static void insertRewards(Connection connection, List<UserReward> rewards) {
String insertQuery = "INSERT INTO gem_staking.user_rewards (user_id, pool_id, earn_token, reward_amount, summary_stage) VALUES (?, ?, ?, ?, ?)";
try (PreparedStatement ps = connection.prepareStatement(insertQuery)) {
for (UserReward reward : rewards) {
ps.setString(1, reward.getUserId());
ps.setString(2, reward.getPoolId());
ps.setString(3, reward.getEarnToken());
ps.setBigDecimal(4, reward.getRewardAmount());
ps.setInt(5, reward.getSummaryStage());
ps.addBatch();
}
ps.executeBatch();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
LIMIT 和 OFFSET 分批获取数据,每次处理一批数据。ExecutorService 创建一个固定大小的线程池,并发执行收益计算和插入操作。PreparedStatement 的 addBatch 和 executeBatch 方法批量插入收益结果,减少单次插入的开销。确保你的相关类具有适当的属性和方法,例如:
public class UserRewardSummary {
private Long id;
private String userId;
private String poolId;
private String stakingHoldToken;
private BigDecimal stakingHoldAmountAvg;
private String earnToken;
private int summaryStage;
private int calState;
private Timestamp createdAt;
private Timestamp updatedAt;
// Getters and Setters
// ...
}
public class UserReward {
private String userId;
private String poolId;
private String earnToken;
private BigDecimal rewardAmount;
private int summaryStage;
// Getters and Setters
// ...
}
通过这些代码,你可以高效地从大量数据中计算收益,并将收益结果插入到收益表中。确保在实现过程中正确处理数据库连接和资源关闭。
还能更高效吗
当然,可以通过更多优化措施进一步提高效率,包括以下几个方面:
数据库层面的优化:
并发处理优化:
减少数据库交互次数:
以下是一些更深入的优化策略和示例:
游标可以帮助你在数据库层面进行分批处理,从而减少内存占用。以下是一个使用游标的示例:
你可以创建一个存储过程,使用游标批量处理数据:
DELIMITER //
CREATE PROCEDURE process_user_reward_summary()
BEGIN
DECLARE done INT DEFAULT FALSE;
DECLARE userId CHAR(24);
DECLARE poolId CHAR(24);
DECLARE stakingHoldToken CHAR(24);
DECLARE stakingHoldAmountAvg DECIMAL(38, 20);
DECLARE earnToken CHAR(24);
DECLARE summaryStage INT;
DECLARE calState INT;
DECLARE cur CURSOR FOR
SELECT user_id, pool_id, staking_hold_token, staking_hold_amount_avg, earn_token, summary_stage, cal_state
FROM gem_staking.user_reward_summary
WHERE cal_state = 0;
DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;
OPEN cur;
read_loop: LOOP
FETCH cur INTO userId, poolId, stakingHoldToken, stakingHoldAmountAvg, earnToken, summaryStage, calState;
IF done THEN
LEAVE read_loop;
END IF;
-- Perform reward calculation and insert into user_rewards
INSERT INTO gem_staking.user_rewards (user_id, pool_id, earn_token, reward_amount, summary_stage)
VALUES (userId, poolId, earnToken, stakingHoldAmountAvg * 0.1, summaryStage);
-- Update cal_state to mark as processed
UPDATE gem_staking.user_reward_summary
SET cal_state = 1
WHERE user_id = userId AND pool_id = poolId AND summary_stage = summaryStage;
END LOOP;
CLOSE cur;
END //
DELIMITER ;
在你的 Java 应用程序中调用存储过程:
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.CallableStatement;
import java.sql.SQLException;
public class RewardCalculator {
public static void main(String[] args) {
try (Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/gem_staking", "username", "password")) {
CallableStatement stmt = connection.prepareCall("{CALL process_user_reward_summary()}");
stmt.execute();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
Spring Batch 是一个用于处理大量数据的框架,支持分批处理、并发处理、重试等功能。
在 pom.xml 中添加 Spring Batch 依赖:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-batch</artifactId>
</dependency>
创建一个配置类来定义批处理作业:
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.core.step.tasklet.TaskletStep;
import org.springframework.batch.item.ItemProcessor;
import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.ItemWriter;
import org.springframework.batch.item.database.JdbcCursorItemReader;
import org.springframework.batch.item.database.builder.JdbcCursorItemReaderBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import javax.sql.DataSource;
@Configuration
@EnableBatchProcessing
public class BatchConfiguration {
@Bean
public DataSource dataSource() {
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/gem_staking");
dataSource.setUsername("username");
dataSource.setPassword("password");
return dataSource;
}
@Bean
public JdbcCursorItemReader<UserRewardSummary> reader(DataSource dataSource) {
return new JdbcCursorItemReaderBuilder<UserRewardSummary>()
.dataSource(dataSource)
.name("userRewardSummaryReader")
.sql("SELECT * FROM gem_staking.user_reward_summary WHERE cal_state = 0")
.rowMapper(new BeanPropertyRowMapper<>(UserRewardSummary.class))
.build();
}
@Bean
public ItemProcessor<UserRewardSummary, UserReward> processor() {
return summary -> {
UserReward reward = new UserReward();
reward.setUserId(summary.getUserId());
reward.setPoolId(summary.getPoolId());
reward.setEarnToken(summary.getEarnToken());
reward.setRewardAmount(summary.getStakingHoldAmountAvg().multiply(new BigDecimal("0.1"))); // 示例:收益计算逻辑
reward.setSummaryStage(summary.getSummaryStage());
return reward;
};
}
@Bean
public ItemWriter<UserReward> writer(DataSource dataSource) {
return items -> {
try (Connection connection = dataSource.getConnection()) {
String insertQuery = "INSERT INTO gem_staking.user_rewards (user_id, pool_id, earn_token, reward_amount, summary_stage) VALUES (?, ?, ?, ?, ?)";
try (PreparedStatement ps = connection.prepareStatement(insertQuery)) {
for (UserReward reward : items) {
ps.setString(1, reward.getUserId());
ps.setString(2, reward.getPoolId());
ps.setString(3, reward.getEarnToken());
ps.setBigDecimal(4, reward.getRewardAmount());
ps.setInt(5, reward.getSummaryStage());
ps.addBatch();
}
ps.executeBatch();
}
}
};
}
@Bean
public Job importUserRewardJob(JobBuilderFactory jobBuilderFactory, StepBuilderFactory stepBuilderFactory,
ItemReader<UserRewardSummary> reader, ItemProcessor<UserRewardSummary, UserReward> processor,
ItemWriter<UserReward> writer) {
Step step = stepBuilderFactory.get("step1")
.<UserRewardSummary, UserReward>chunk(1000)
.reader(reader)
.processor(processor)
.writer(writer)
.build();
return jobBuilderFactory.get("importUserRewardJob")
.incrementer(new RunIdIncrementer())
.flow(step)
.end()
.build();
}
}
创建一个启动类来运行批处理作业:
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobLauncher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class BatchApplication implements CommandLineRunner {
@Autowired
private JobLauncher jobLauncher;
@Autowired
private Job importUserRewardJob;
public static void main(String[] args) {
SpringApplication.run(BatchApplication.class, args);
}
@Override
public void run(String... args) throws Exception {
JobExecution execution = jobLauncher.run(importUserRewardJob, new JobParametersBuilder().toJobParameters());
System.out.println("Job Status : " + execution.getStatus());
}
}
确保你的相关类具有适当的属性和方法,例如:
public class UserRewardSummary {
// 属性和 Getters/Setters
}
public class UserReward {
// 属性和 Getters/Setters
}
通过这些代码,你可以利用 Spring Batch 进行高效的分批处理,并将处理结果插入到收益表中。Spring Batch 提供了更多的优化和扩展功能,可以根据需求进一步优化和定制。
我这边的需求还有其他信息补充,计算插入这个动作是周期性执行,比如1小时执行一次。我们这边用了elasticjob来调度任务
了解了,如果你需要周期性地执行计算和插入操作,并且使用 ElasticJob 来调度任务,这可以很好地实现高效的批量处理。ElasticJob 是一个分布式调度框架,可以帮助你定时和分布式执行任务。
以下是如何使用 ElasticJob 实现周期性任务调度的步骤:
在 pom.xml 中添加 ElasticJob 相关依赖:
<dependency>
<groupId>org.apache.shardingsphere.elasticjob</groupId>
<artifactId>elasticjob-lite-core</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.shardingsphere.elasticjob</groupId>
<artifactId>elasticjob-lite-spring-boot-starter</artifactId>
<version>3.0.0</version>
</dependency>
配置 ElasticJob 的调度器和作业:
import org.apache.shardingsphere.elasticjob.api.JobConfiguration;
import org.apache.shardingsphere.elasticjob.simple.job.SimpleJob;
import org.apache.shardingsphere.elasticjob.lite.api.bootstrap.impl.ScheduleJobBootstrap;
import org.apache.shardingsphere.elasticjob.lite.api.bootstrap.impl.SimpleJobBootstrap;
import org.apache.shardingsphere.elasticjob.lite.api.listener.ElasticJobListener;
import org.apache.shardingsphere.elasticjob.lite.spring.boot.job.ElasticJobLiteAutoConfiguration;
import org.apache.shardingsphere.elasticjob.lite.spring.boot.job.ElasticJobLiteConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class ElasticJobConfig {
@Bean
public ElasticJobLiteConfig elasticJobLiteConfig() {
return new ElasticJobLiteConfig();
}
@Bean
public ScheduleJobBootstrap scheduleJobBootstrap(SimpleJob job) {
JobConfiguration jobConfig = JobConfiguration.newBuilder("rewardCalculationJob", 1)
.cron("0 0 * * * ?") // 每小时执行一次
.build();
return new ScheduleJobBootstrap(elasticJobLiteConfig().getRegistryCenter(), job, jobConfig);
}
}
实现你的计算和插入逻辑作为一个 SimpleJob:
import org.apache.shardingsphere.elasticjob.simple.job.SimpleJob;
import org.apache.shardingsphere.elasticjob.api.ShardingContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class RewardCalculationJob implements SimpleJob {
@Autowired
private RewardCalculator rewardCalculator;
@Override
public void execute(ShardingContext shardingContext) {
rewardCalculator.calculateAndInsertRewards();
}
}
RewardCalculator 类中的 calculateAndInsertRewards 方法将包含你的计算和插入逻辑:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@Component
public class RewardCalculator {
@Autowired
private JdbcTemplate jdbcTemplate;
private static final int BATCH_SIZE = 1000; // 每批处理的记录数
private static final int THREAD_POOL_SIZE = 10; // 线程池大小
public void calculateAndInsertRewards() {
ExecutorService executorService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
try (Connection connection = jdbcTemplate.getDataSource().getConnection()) {
int offset = 0;
List<UserRewardSummary> userRewardSummaries;
do {
userRewardSummaries = fetchUserRewardSummaries(connection, offset, BATCH_SIZE);
offset += BATCH_SIZE;
if (!userRewardSummaries.isEmpty()) {
executorService.submit(() -> {
List<UserReward> rewards = calculateRewards(userRewardSummaries);
insertRewards(connection, rewards);
});
}
} while (!userRewardSummaries.isEmpty());
} catch (SQLException e) {
e.printStackTrace();
} finally {
executorService.shutdown();
}
}
private List<UserRewardSummary> fetchUserRewardSummaries(Connection connection, int offset, int batchSize) throws SQLException {
List<UserRewardSummary> summaries = new ArrayList<>();
String query = "SELECT * FROM gem_staking.user_reward_summary WHERE cal_state = 0 LIMIT ? OFFSET ?";
try (PreparedStatement ps = connection.prepareStatement(query)) {
ps.setInt(1, batchSize);
ps.setInt(2, offset);
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
UserRewardSummary summary = new UserRewardSummary();
summary.setId(rs.getLong("id"));
summary.setUserId(rs.getString("user_id"));
summary.setPoolId(rs.getString("pool_id"));
summary.setStakingHoldToken(rs.getString("staking_hold_token"));
summary.setStakingHoldAmountAvg(rs.getBigDecimal("staking_hold_amount_avg"));
summary.setEarnToken(rs.getString("earn_token"));
summary.setSummaryStage(rs.getInt("summary_stage"));
summary.setCalState(rs.getInt("cal_state"));
summary.setCreatedAt(rs.getTimestamp("created_at"));
summary.setUpdatedAt(rs.getTimestamp("updated_at"));
summaries.add(summary);
}
}
}
return summaries;
}
private List<UserReward> calculateRewards(List<UserRewardSummary> summaries) {
List<UserReward> rewards = new ArrayList<>();
for (UserRewardSummary summary : summaries) {
UserReward reward = new UserReward();
reward.setUserId(summary.getUserId());
reward.setPoolId(summary.getPoolId());
reward.setEarnToken(summary.getEarnToken());
reward.setRewardAmount(summary.getStakingHoldAmountAvg().multiply(new BigDecimal("0.1"))); // 示例:收益计算逻辑
reward.setSummaryStage(summary.getSummaryStage());
rewards.add(reward);
}
return rewards;
}
private void insertRewards(Connection connection, List<UserReward> rewards) {
String insertQuery = "INSERT INTO gem_staking.user_rewards (user_id, pool_id, earn_token, reward_amount, summary_stage) VALUES (?, ?, ?, ?, ?)";
try (PreparedStatement ps = connection.prepareStatement(insertQuery)) {
for (UserReward reward : rewards) {
ps.setString(1, reward.getUserId());
ps.setString(2, reward.getPoolId());
ps.setString(3, reward.getEarnToken());
ps.setBigDecimal(4, reward.getRewardAmount());
ps.setInt(5, reward.getSummaryStage());
ps.addBatch();
}
ps.executeBatch();
// 更新cal_state为1
updateCalState(connection, rewards);
} catch (SQLException e) {
e.printStackTrace();
}
}
private void updateCalState(Connection connection, List<UserReward> rewards) {
String updateQuery = "UPDATE gem_staking.user_reward_summary SET cal_state = 1 WHERE user_id = ? AND pool_id = ? AND summary_stage = ?";
try (PreparedStatement ps = connection.prepareStatement(updateQuery)) {
for (UserReward reward : rewards) {
ps.setString(1, reward.getUserId());
ps.setString(2, reward.getPoolId());
ps.setInt(3, reward.getSummaryStage());
ps.addBatch();
}
ps.executeBatch();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
启动 Spring Boot 应用程序,ElasticJob 将按照配置的调度策略每小时执行一次任务。
确保你的相关类具有适当的属性和方法,例如:
public class UserRewardSummary {
// 属性和 Getters/Setters
}
public class UserReward {
// 属性和 Getters/Setters
}
通过这些配置和代码,你可以利用 ElasticJob 实现周期性任务调度,并且高效地处理和插入收益数据。ElasticJob 提供了分布式调度的能力,可以进一步提升任务的可靠性和可扩展性。
部署了三个节点,有没有可能调度作业的时候重复执行同一个用户
在分布式环境中,部署多个节点时,确保任务不会被重复执行是一个关键问题。ElasticJob 提供了分布式调度的能力,并且有一些机制可以帮助确保任务不会被重复执行。
ElasticJob 通过分片和协调机制来确保任务在多个节点间均匀分布和协调执行。每个作业会被分成多个分片,每个分片由一个节点执行,避免了重复执行的问题。
以下是如何配置 ElasticJob 的分片机制和幂等操作的示例:
ElasticJobConfig.java:
import org.apache.shardingsphere.elasticjob.api.JobConfiguration;
import org.apache.shardingsphere.elasticjob.simple.job.SimpleJob;
import org.apache.shardingsphere.elasticjob.lite.api.bootstrap.impl.ScheduleJobBootstrap;
import org.apache.shardingsphere.elasticjob.lite.spring.boot.job.ElasticJobLiteAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class ElasticJobConfig {
@Bean
public ElasticJobLiteAutoConfiguration elasticJobLiteAutoConfiguration() {
return new ElasticJobLiteAutoConfiguration();
}
@Bean
public ScheduleJobBootstrap scheduleJobBootstrap(SimpleJob job) {
JobConfiguration jobConfig = JobConfiguration.newBuilder("rewardCalculationJob", 3) // 配置3个分片
.cron("0 0 * * * ?") // 每小时执行一次
.shardingItemParameters("0=0,1=1,2=2") // 分片项参数
.build();
return new ScheduleJobBootstrap(elasticJobLiteAutoConfiguration().getRegistryCenter(), job, jobConfig);
}
}
RewardCalculationJob.java:
import org.apache.shardingsphere.elasticjob.simple.job.SimpleJob;
import org.apache.shardingsphere.elasticjob.api.ShardingContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class RewardCalculationJob implements SimpleJob {
@Autowired
private RewardCalculator rewardCalculator;
@Override
public void execute(ShardingContext shardingContext) {
int shardingItem = shardingContext.getShardingItem();
rewardCalculator.calculateAndInsertRewards(shardingItem);
}
}
RewardCalculator.java:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@Component
public class RewardCalculator {
@Autowired
private JdbcTemplate jdbcTemplate;
private static final int BATCH_SIZE = 1000; // 每批处理的记录数
private static final int THREAD_POOL_SIZE = 10; // 线程池大小
public void calculateAndInsertRewards(int shardingItem) {
ExecutorService executorService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
try (Connection connection = jdbcTemplate.getDataSource().getConnection()) {
int offset = 0;
List<UserRewardSummary> userRewardSummaries;
do {
userRewardSummaries = fetchUserRewardSummaries(connection, offset, BATCH_SIZE, shardingItem);
offset += BATCH_SIZE;
if (!userRewardSummaries.isEmpty()) {
executorService.submit(() -> {
List<UserReward> rewards = calculateRewards(userRewardSummaries);
insertRewards(connection, rewards);
});
}
} while (!userRewardSummaries.isEmpty());
} catch (SQLException e) {
e.printStackTrace();
} finally {
executorService.shutdown();
}
}
private List<UserRewardSummary> fetchUserRewardSummaries(Connection connection, int offset, int batchSize, int shardingItem) throws SQLException {
List<UserRewardSummary> summaries = new ArrayList<>();
String query = "SELECT * FROM gem_staking.user_reward_summary WHERE cal_state = 0 AND MOD(id, 3) = ? LIMIT ? OFFSET ?";
try (PreparedStatement ps = connection.prepareStatement(query)) {
ps.setInt(1, shardingItem);
ps.setInt(2, batchSize);
ps.setInt(3, offset);
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
UserRewardSummary summary = new UserRewardSummary();
summary.setId(rs.getLong("id"));
summary.setUserId(rs.getString("user_id"));
summary.setPoolId(rs.getString("pool_id"));
summary.setStakingHoldToken(rs.getString("staking_hold_token"));
summary.setStakingHoldAmountAvg(rs.getBigDecimal("staking_hold_amount_avg"));
summary.setEarnToken(rs.getString("earn_token"));
summary.setSummaryStage(rs.getInt("summary_stage"));
summary.setCalState(rs.getInt("cal_state"));
summary.setCreatedAt(rs.getTimestamp("created_at"));
summary.setUpdatedAt(rs.getTimestamp("updated_at"));
summaries.add(summary);
}
}
}
return summaries;
}
private List<UserReward> calculateRewards(List<UserRewardSummary> summaries) {
List<UserReward> rewards = new ArrayList<>();
for (UserRewardSummary summary : summaries) {
UserReward reward = new UserReward();
reward.setUserId(summary.getUserId());
reward.setPoolId(summary.getPoolId());
reward.setEarnToken(summary.getEarnToken());
reward.setRewardAmount(summary.getStakingHoldAmountAvg().multiply(new BigDecimal("0.1"))); // 示例:收益计算逻辑
reward.setSummaryStage(summary.getSummaryStage());
rewards.add(reward);
}
return rewards;
}
private void insertRewards(Connection connection, List<UserReward> rewards) {
String insertQuery = "INSERT INTO gem_staking.user_rewards (user_id, pool_id, earn_token, reward_amount, summary_stage) VALUES (?, ?, ?, ?, ?)";
try (PreparedStatement ps = connection.prepareStatement(insertQuery)) {
for (UserReward reward : rewards) {
ps.setString(1, reward.getUserId());
ps.setString(2, reward.getPoolId());
ps.setString(3, reward.getEarnToken());
ps.setBigDecimal(4, reward.getRewardAmount());
ps.setInt(5, reward.getSummaryStage());
ps.addBatch();
}
ps.executeBatch();
// 更新cal_state为1
updateCalState(connection, rewards);
} catch (SQLException e) {
e.printStackTrace();
}
}
private void updateCalState(Connection connection, List<UserReward> rewards) {
String updateQuery = "UPDATE gem_staking.user_reward_summary SET cal_state = 1 WHERE user_id = ? AND pool_id = ? AND summary_stage = ?";
try (PreparedStatement ps = connection.prepareStatement(updateQuery)) {
for (UserReward reward : rewards) {
ps.setString(1, reward.getUserId());
ps.setString(2, reward.getPoolId());
ps.setInt(3, reward.getSummaryStage());
ps.addBatch();
}
ps.executeBatch();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
shardingItemParameters 将分片项参数传递给任务执行逻辑。cal_state 字段来记录任务状态,确保同一任务不会被重复处理。MOD(id, 3) 来分片查询数据,确保每个节点只处理自己分配到的分片。通过这些配置和代码,你可以确保在分布式环境中高效且准确地执行周期性任务,避免重复执行同一用户的任务。ElasticJob 提供了强大的分布式调度能力,可以帮助你实现高效的任务管理和执行。
查询条件里加一个函数运算对性能有影响吧?
是的,在查询条件中使用函数运算可能会对性能产生影响,尤其是在处理大数据量时。函数运算会导致数据库不能利用索引,从而导致全表扫描,性能会显著下降。
在你提供的示例中,使用 MOD(id, 3) = ? 作为分片条件确实会导致性能问题,因为这会使得数据库无法有效地利用索引。
为了优化查询性能,可以考虑以下几种策略:
在数据插入时预计算分片键,并将其存储在表中:
为预计算的分片键添加一个新列:
ALTER TABLE gem_staking.user_reward_summary
ADD COLUMN shard_key INT NOT NULL DEFAULT 0 COMMENT '预计算的分片键';
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class DataInserter {
public void insertData(Connection connection, String userId, String poolId, String stakingHoldToken, BigDecimal stakingHoldAmountAvg, String earnToken, int summaryStage) throws SQLException {
String insertQuery = "INSERT INTO gem_staking.user_reward_summary (user_id, pool_id, staking_hold_token, staking_hold_amount_avg, earn_token, summary_stage, shard_key) VALUES (?, ?, ?, ?, ?, ?, ?)";
try (PreparedStatement ps = connection.prepareStatement(insertQuery)) {
ps.setString(1, userId);
ps.setString(2, poolId);
ps.setString(3, stakingHoldToken);
ps.setBigDecimal(4, stakingHoldAmountAvg);
ps.setString(5, earnToken);
ps.setInt(6, summaryStage);
ps.setInt(7, calculateShardKey(userId, poolId)); // 预计算分片键
ps.executeUpdate();
}
}
private int calculateShardKey(String userId, String poolId) {
// 示例:根据 userId 和 poolId 计算分片键
return (userId.hashCode() ^ poolId.hashCode()) % 3;
}
}
在查询时直接使用预计算的分片键,而不是使用函数运算:
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
public class RewardCalculator {
// 其他代码省略...
private List<UserRewardSummary> fetchUserRewardSummaries(Connection connection, int offset, int batchSize, int shardKey) throws SQLException {
List<UserRewardSummary> summaries = new ArrayList<>();
String query = "SELECT * FROM gem_staking.user_reward_summary WHERE cal_state = 0 AND shard_key = ? LIMIT ? OFFSET ?";
try (PreparedStatement ps = connection.prepareStatement(query)) {
ps.setInt(1, shardKey);
ps.setInt(2, batchSize);
ps.setInt(3, offset);
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
UserRewardSummary summary = new UserRewardSummary();
summary.setId(rs.getLong("id"));
summary.setUserId(rs.getString("user_id"));
summary.setPoolId(rs.getString("pool_id"));
summary.setStakingHoldToken(rs.getString("staking_hold_token"));
summary.setStakingHoldAmountAvg(rs.getBigDecimal("staking_hold_amount_avg"));
summary.setEarnToken(rs.getString("earn_token"));
summary.setSummaryStage(rs.getInt("summary_stage"));
summary.setCalState(rs.getInt("cal_state"));
summary.setCreatedAt(rs.getTimestamp("created_at"));
summary.setUpdatedAt(rs.getTimestamp("updated_at"));
summaries.add(summary);
}
}
}
return summaries;
}
// 其他代码省略...
}
在任务执行时传递预计算的分片键:
import org.apache.shardingsphere.elasticjob.simple.job.SimpleJob;
import org.apache.shardingsphere.elasticjob.api.ShardingContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class RewardCalculationJob implements SimpleJob {
@Autowired
private RewardCalculator rewardCalculator;
@Override
public void execute(ShardingContext shardingContext) {
int shardingItem = shardingContext.getShardingItem();
rewardCalculator.calculateAndInsertRewards(shardingItem);
}
}
通过预计算分片键并将其存储在表中,可以避免在查询时使用函数运算,从而提高查询性能。此外,确保查询能够利用索引也非常重要,可以通过创建适当的索引来实现。
通过这些优化策略,可以显著提高查询性能,确保在分布式环境中高效地执行周期性任务。
elasticjob每个周期调度的时候,是轮训节点吗
ElasticJob 的工作原理并不是简单的轮询节点,而是通过分布式协调和分片机制来确保任务的分布式执行和均衡分配。以下是 ElasticJob 的工作方式和一些关键概念:
假设你有一个任务,分成 3 个分片,部署了 3 个节点。每个节点各自处理一个分片:
如果节点 B 失效,ElasticJob 会重新分配分片:
以下是如何配置 ElasticJob 的分片机制并确保任务均衡分配的示例:
ElasticJobConfig.java:
import org.apache.shardingsphere.elasticjob.api.JobConfiguration;
import org.apache.shardingsphere.elasticjob.simple.job.SimpleJob;
import org.apache.shardingsphere.elasticjob.lite.api.bootstrap.impl.ScheduleJobBootstrap;
import org.apache.shardingsphere.elasticjob.lite.spring.boot.job.ElasticJobLiteAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class ElasticJobConfig {
@Bean
public ElasticJobLiteAutoConfiguration elasticJobLiteAutoConfiguration() {
return new ElasticJobLiteAutoConfiguration();
}
@Bean
public ScheduleJobBootstrap scheduleJobBootstrap(SimpleJob job) {
JobConfiguration jobConfig = JobConfiguration.newBuilder("rewardCalculationJob", 3) // 配置3个分片
.cron("0 0 * * * ?") // 每小时执行一次
.shardingItemParameters("0=0,1=1,2=2") // 分片项参数
.build();
return new ScheduleJobBootstrap(elasticJobLiteAutoConfiguration().getRegistryCenter(), job, jobConfig);
}
}
RewardCalculationJob.java:
import org.apache.shardingsphere.elasticjob.simple.job.SimpleJob;
import org.apache.shardingsphere.elasticjob.api.ShardingContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class RewardCalculationJob implements SimpleJob {
@Autowired
private RewardCalculator rewardCalculator;
@Override
public void execute(ShardingContext shardingContext) {
int shardingItem = shardingContext.getShardingItem();
rewardCalculator.calculateAndInsertRewards(shardingItem);
}
}
RewardCalculator.java:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@Component
public class RewardCalculator {
@Autowired
private JdbcTemplate jdbcTemplate;
private static final int BATCH_SIZE = 1000; // 每批处理的记录数
private static final int THREAD_POOL_SIZE = 10; // 线程池大小
public void calculateAndInsertRewards(int shardingItem) {
ExecutorService executorService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
try (Connection connection = jdbcTemplate.getDataSource().getConnection()) {
int offset = 0;
List<UserRewardSummary> userRewardSummaries;
do {
userRewardSummaries = fetchUserRewardSummaries(connection, offset, BATCH_SIZE, shardingItem);
offset += BATCH_SIZE;
if (!userRewardSummaries.isEmpty()) {
executorService.submit(() -> {
List<UserReward> rewards = calculateRewards(userRewardSummaries);
insertRewards(connection, rewards);
});
}
} while (!userRewardSummaries.isEmpty());
} catch (SQLException e) {
e.printStackTrace();
} finally {
executorService.shutdown();
}
}
private List<UserRewardSummary> fetchUserRewardSummaries(Connection connection, int offset, int batchSize, int shardKey) throws SQLException {
List<UserRewardSummary> summaries = new ArrayList<>();
String query = "SELECT * FROM gem_staking.user_reward_summary WHERE cal_state = 0 AND shard_key = ? LIMIT ? OFFSET ?";
try (PreparedStatement ps = connection.prepareStatement(query)) {
ps.setInt(1, shardKey);
ps.setInt(2, batchSize);
ps.setInt(3, offset);
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
UserRewardSummary summary = new UserRewardSummary();
summary.setId(rs.getLong("id"));
summary.setUserId(rs.getString("user_id"));
summary.setPoolId(rs.getString("pool_id"));
summary.setStakingHoldToken(rs.getString("staking_hold_token"));
summary.setStakingHoldAmountAvg(rs.getBigDecimal("staking_hold_amount_avg"));
summary.setEarnToken(rs.getString("earn_token"));
summary.setSummaryStage(rs.getInt("summary_stage"));
summary.setCalState(rs.getInt("cal_state"));
summary.setCreatedAt(rs.getTimestamp("created_at"));
summary.setUpdatedAt(rs.getTimestamp("updated_at"));
summaries.add(summary);
}
}
}
return summaries;
}
private List<UserReward> calculateRewards(List<UserRewardSummary> summaries) {
List<UserReward> rewards = new ArrayList<>();
for (UserRewardSummary summary : summaries) {
UserReward reward = new UserReward();
reward.setUserId(summary.getUserId());
reward.setPoolId(summary.getPoolId());
reward.setEarnToken(summary.getEarnToken());
reward.setRewardAmount(summary.getStakingHoldAmountAvg().multiply(new BigDecimal("0.1"))); // 示例:收益计算逻辑
reward.setSummaryStage(summary.getSummaryStage());
rewards.add(reward);
}
return rewards;
}
private void insertRewards(Connection connection, List<UserReward> rewards) {
String insertQuery = "INSERT INTO gem_staking.user_rewards (user_id, pool_id, earn_token, reward_amount, summary_stage) VALUES (?, ?, ?, ?, ?)";
try (PreparedStatement ps = connection.prepareStatement(insertQuery)) {
for (UserReward reward : rewards) {
ps.setString(1, reward.getUserId());
ps.setString(2, reward.getPoolId());
ps.setString(3, reward.getEarnToken());
ps.setBigDecimal(4, reward.getRewardAmount());
ps.setInt(5, reward.getSummaryStage());
ps.addBatch();
}
ps.executeBatch();
// 更新cal_state为1
updateCalState(connection, rewards);
} catch (SQLException e) {
e.printStackTrace();
}
}
private void updateCalState(Connection connection, List<UserReward> rewards) {
String updateQuery = "UPDATE gem_staking.user_reward_summary SET cal_state = 1 WHERE user_id = ? AND pool_id = ? AND summary_stage = ?";
try (PreparedStatement ps = connection.prepareStatement(updateQuery)) {
for (UserReward reward : rewards) {
ps.setString(1, reward.getUserId());
ps.setString(2, reward.getPoolId());
ps.setInt(3, reward.getSummaryStage());
ps.addBatch();
}
ps.executeBatch();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
shardingItemParameters 将分片项参数传递给任务执行逻辑。cal_state 字段来记录任务状态,确保同一任务不会被重复处理。shard_key 来分片查询数据,确保每个节点只处理自己分配到的分片。通过这些配置和代码,你可以确保在分布式环境中高效且准确地执行周期性任务,避免重复执行同一用户的任务。ElasticJob 提供了强大的分布式调度能力,可以帮助你实现高效的任务管理和执行。
如果节点发生了增加或者减少,那么shard_key不就失效了吗
你提出的一个非常重要的问题:如果节点数量发生变化,预先计算的 shard_key 将无法适应新的分片方案,从而导致任务分配不均或重复计算。
为了解决这个问题,我们需要一种动态分片的方法,使得分片可以根据当前的节点数量进行调整。ElasticJob 提供了这种能力,可以动态地根据分片总数和当前活跃节点数进行分片。
在动态分片中,我们不再使用预先计算的 shard_key。相反,我们根据当前的分片总数和活跃节点数动态计算每个分片所处理的数据。
我们可以通过使用 ElasticJob 的 ShardingContext 来获取当前的分片项,并在查询时使用这个分片项来动态划分数据。
ElasticJobConfig.java:
import org.apache.shardingsphere.elasticjob.api.JobConfiguration;
import org.apache.shardingsphere.elasticjob.simple.job.SimpleJob;
import org.apache.shardingsphere.elasticjob.lite.api.bootstrap.impl.ScheduleJobBootstrap;
import org.apache.shardingsphere.elasticjob.lite.spring.boot.job.ElasticJobLiteAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class ElasticJobConfig {
@Bean
public ElasticJobLiteAutoConfiguration elasticJobLiteAutoConfiguration() {
return new ElasticJobLiteAutoConfiguration();
}
@Bean
public ScheduleJobBootstrap scheduleJobBootstrap(SimpleJob job) {
JobConfiguration jobConfig = JobConfiguration.newBuilder("rewardCalculationJob", 3) // 配置3个分片
.cron("0 0 * * * ?") // 每小时执行一次
.build();
return new ScheduleJobBootstrap(elasticJobLiteAutoConfiguration().getRegistryCenter(), job, jobConfig);
}
}
RewardCalculationJob.java:
import org.apache.shardingsphere.elasticjob.simple.job.SimpleJob;
import org.apache.shardingsphere.elasticjob.api.ShardingContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class RewardCalculationJob implements SimpleJob {
@Autowired
private RewardCalculator rewardCalculator;
@Override
public void execute(ShardingContext shardingContext) {
int shardingItem = shardingContext.getShardingItem();
int shardingTotalCount = shardingContext.getShardingTotalCount();
rewardCalculator.calculateAndInsertRewards(shardingItem, shardingTotalCount);
}
}
RewardCalculator.java:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@Component
public class RewardCalculator {
@Autowired
private JdbcTemplate jdbcTemplate;
private static final int BATCH_SIZE = 1000; // 每批处理的记录数
private static final int THREAD_POOL_SIZE = 10; // 线程池大小
public void calculateAndInsertRewards(int shardingItem, int shardingTotalCount) {
ExecutorService executorService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
try (Connection connection = jdbcTemplate.getDataSource().getConnection()) {
int offset = 0;
List<UserRewardSummary> userRewardSummaries;
do {
userRewardSummaries = fetchUserRewardSummaries(connection, offset, BATCH_SIZE, shardingItem, shardingTotalCount);
offset += BATCH_SIZE;
if (!userRewardSummaries.isEmpty()) {
executorService.submit(() -> {
List<UserReward> rewards = calculateRewards(userRewardSummaries);
insertRewards(connection, rewards);
});
}
} while (!userRewardSummaries.isEmpty());
} catch (SQLException e) {
e.printStackTrace();
} finally {
executorService.shutdown();
}
}
private List<UserRewardSummary> fetchUserRewardSummaries(Connection connection, int offset, int batchSize, int shardingItem, int shardingTotalCount) throws SQLException {
List<UserRewardSummary> summaries = new ArrayList<>();
String query = "SELECT * FROM gem_staking.user_reward_summary WHERE cal_state = 0 AND MOD(id, ?) = ? LIMIT ? OFFSET ?";
try (PreparedStatement ps = connection.prepareStatement(query)) {
ps.setInt(1, shardingTotalCount);
ps.setInt(2, shardingItem);
ps.setInt(3, batchSize);
ps.setInt(4, offset);
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
UserRewardSummary summary = new UserRewardSummary();
summary.setId(rs.getLong("id"));
summary.setUserId(rs.getString("user_id"));
summary.setPoolId(rs.getString("pool_id"));
summary.setStakingHoldToken(rs.getString("staking_hold_token"));
summary.setStakingHoldAmountAvg(rs.getBigDecimal("staking_hold_amount_avg"));
summary.setEarnToken(rs.getString("earn_token"));
summary.setSummaryStage(rs.getInt("summary_stage"));
summary.setCalState(rs.getInt("cal_state"));
summary.setCreatedAt(rs.getTimestamp("created_at"));
summary.setUpdatedAt(rs.getTimestamp("updated_at"));
summaries.add(summary);
}
}
}
return summaries;
}
private List<UserReward> calculateRewards(List<UserRewardSummary> summaries) {
List<UserReward> rewards = new ArrayList<>();
for (UserRewardSummary summary : summaries) {
UserReward reward = new UserReward();
reward.setUserId(summary.getUserId());
reward.setPoolId(summary.getPoolId());
reward.setEarnToken(summary.getEarnToken());
reward.setRewardAmount(summary.getStakingHoldAmountAvg().multiply(new BigDecimal("0.1"))); // 示例:收益计算逻辑
reward.setSummaryStage(summary.getSummaryStage());
rewards.add(reward);
}
return rewards;
}
private void insertRewards(Connection connection, List<UserReward> rewards) {
String insertQuery = "INSERT INTO gem_staking.user_rewards (user_id, pool_id, earn_token, reward_amount, summary_stage) VALUES (?, ?, ?, ?, ?)";
try (PreparedStatement ps = connection.prepareStatement(insertQuery)) {
for (UserReward reward : rewards) {
ps.setString(1, reward.getUserId());
ps.setString(2, reward.getPoolId());
ps.setString(3, reward.getEarnToken());
ps.setBigDecimal(4, reward.getRewardAmount());
ps.setInt(5, reward.getSummaryStage());
ps.addBatch();
}
ps.executeBatch();
// 更新cal_state为1
updateCalState(connection, rewards);
} catch (SQLException e) {
e.printStackTrace();
}
}
private void updateCalState(Connection connection, List<UserReward> rewards) {
String updateQuery = "UPDATE gem_staking.user_reward_summary SET cal_state = 1 WHERE user_id = ? AND pool_id = ? AND summary_stage = ?";
try (PreparedStatement ps = connection.prepareStatement(updateQuery)) {
for (UserReward reward : rewards) {
ps.setString(1, reward.getUserId());
ps.setString(2, reward.getPoolId());
ps.setInt(3, reward.getSummaryStage());
ps.addBatch();
}
ps.executeBatch();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
ShardingContext 获取当前分片项和分片总数。在查询时使用 MOD(id, ?) 来动态计算分片。通过这些配置和代码,你可以确保在分布式环境中高效且准确地执行周期性任务,即使节点数量发生变化,任务也能动态调整,以避免重复执行同一用户的任务。ElasticJob 提供了强大的分布式调度能力,可以帮助你实现高效的任务管理和执行。
同一时间,是不是只有一个节点被调度
在 ElasticJob 的分布式调度机制中,并不是同一时间只有一个节点被调度。相反,ElasticJob 通过分片机制将任务分配到多个节点上,并行执行,以提高任务的执行效率和处理能力。
假设你有一个任务分成 3 个分片,并且有 3 个节点(A、B、C)。任务被调度时,ElasticJob 会将分片分别分配给节点:
这三个节点会并行执行各自的分片任务。
以下是如何配置和实现分布式任务调度的示例:
ElasticJobConfig.java:
import org.apache.shardingsphere.elasticjob.api.JobConfiguration;
import org.apache.shardingsphere.elasticjob.simple.job.SimpleJob;
import org.apache.shardingsphere.elasticjob.lite.api.bootstrap.impl.ScheduleJobBootstrap;
import org.apache.shardingsphere.elasticjob.lite.spring.boot.job.ElasticJobLiteAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class ElasticJobConfig {
@Bean
public ElasticJobLiteAutoConfiguration elasticJobLiteAutoConfiguration() {
return new ElasticJobLiteAutoConfiguration();
}
@Bean
public ScheduleJobBootstrap scheduleJobBootstrap(SimpleJob job) {
// 配置3个分片,每小时执行一次
JobConfiguration jobConfig = JobConfiguration.newBuilder("rewardCalculationJob", 3)
.cron("0 0 * * * ?")
.build();
return new ScheduleJobBootstrap(elasticJobLiteAutoConfiguration().getRegistryCenter(), job, jobConfig);
}
}
RewardCalculationJob.java:
import org.apache.shardingsphere.elasticjob.simple.job.SimpleJob;
import org.apache.shardingsphere.elasticjob.api.ShardingContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class RewardCalculationJob implements SimpleJob {
@Autowired
private RewardCalculator rewardCalculator;
@Override
public void execute(ShardingContext shardingContext) {
int shardingItem = shardingContext.getShardingItem();
int shardingTotalCount = shardingContext.getShardingTotalCount();
rewardCalculator.calculateAndInsertRewards(shardingItem, shardingTotalCount);
}
}
RewardCalculator.java:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@Component
public class RewardCalculator {
@Autowired
private JdbcTemplate jdbcTemplate;
private static final int BATCH_SIZE = 1000; // 每批处理的记录数
private static final int THREAD_POOL_SIZE = 10; // 线程池大小
public void calculateAndInsertRewards(int shardingItem, int shardingTotalCount) {
ExecutorService executorService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
try (Connection connection = jdbcTemplate.getDataSource().getConnection()) {
int offset = 0;
List<UserRewardSummary> userRewardSummaries;
do {
userRewardSummaries = fetchUserRewardSummaries(connection, offset, BATCH_SIZE, shardingItem, shardingTotalCount);
offset += BATCH_SIZE;
if (!userRewardSummaries.isEmpty()) {
executorService.submit(() -> {
List<UserReward> rewards = calculateRewards(userRewardSummaries);
insertRewards(connection, rewards);
});
}
} while (!userRewardSummaries.isEmpty());
} catch (SQLException e) {
e.printStackTrace();
} finally {
executorService.shutdown();
}
}
private List<UserRewardSummary> fetchUserRewardSummaries(Connection connection, int offset, int batchSize, int shardingItem, int shardingTotalCount) throws SQLException {
List<UserRewardSummary> summaries = new ArrayList<>();
String query = "SELECT * FROM gem_staking.user_reward_summary WHERE cal_state = 0 AND MOD(id, ?) = ? LIMIT ? OFFSET ?";
try (PreparedStatement ps = connection.prepareStatement(query)) {
ps.setInt(1, shardingTotalCount);
ps.setInt(2, shardingItem);
ps.setInt(3, batchSize);
ps.setInt(4, offset);
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
UserRewardSummary summary = new UserRewardSummary();
summary.setId(rs.getLong("id"));
summary.setUserId(rs.getString("user_id"));
summary.setPoolId(rs.getString("pool_id"));
summary.setStakingHoldToken(rs.getString("staking_hold_token"));
summary.setStakingHoldAmountAvg(rs.getBigDecimal("staking_hold_amount_avg"));
summary.setEarnToken(rs.getString("earn_token"));
summary.setSummaryStage(rs.getInt("summary_stage"));
summary.setCalState(rs.getInt("cal_state"));
summary.setCreatedAt(rs.getTimestamp("created_at"));
summary.setUpdatedAt(rs.getTimestamp("updated_at"));
summaries.add(summary);
}
}
}
return summaries;
}
private List<UserReward> calculateRewards(List<UserRewardSummary> summaries) {
List<UserReward> rewards = new ArrayList<>();
for (UserRewardSummary summary : summaries) {
UserReward reward = new UserReward();
reward.setUserId(summary.getUserId());
reward.setPoolId(summary.getPoolId());
reward.setEarnToken(summary.getEarnToken());
reward.setRewardAmount(summary.getStakingHoldAmountAvg().multiply(new BigDecimal("0.1"))); // 示例:收益计算逻辑
reward.setSummaryStage(summary.getSummaryStage());
rewards.add(reward);
}
return rewards;
}
private void insertRewards(Connection connection, List<UserReward> rewards) {
String insertQuery = "INSERT INTO gem_staking.user_rewards (user_id, pool_id, earn_token, reward_amount, summary_stage) VALUES (?, ?, ?, ?, ?)";
try (PreparedStatement ps = connection.prepareStatement(insertQuery)) {
for (UserReward reward : rewards) {
ps.setString(1, reward.getUserId());
ps.setString(2, reward.getPoolId());
ps.setString(3, reward.getEarnToken());
ps.setBigDecimal(4, reward.getRewardAmount());
ps.setInt(5, reward.getSummaryStage());
ps.addBatch();
}
ps.executeBatch();
// 更新cal_state为1
updateCalState(connection, rewards);
} catch (SQLException e) {
e.printStackTrace();
}
}
private void updateCalState(Connection connection, List<UserReward> rewards) {
String updateQuery = "UPDATE gem_staking.user_reward_summary SET cal_state = 1 WHERE user_id = ? AND pool_id = ? AND summary_stage = ?";
try (PreparedStatement ps = connection.prepareStatement(updateQuery)) {
for (UserReward reward : rewards) {
ps.setString(1, reward.getUserId());
ps.setString(2, reward.getPoolId());
ps.setInt(3, reward.getSummaryStage());
ps.addBatch();
}
ps.executeBatch();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
ShardingContext 获取当前分片项和分片总数。在查询时使用 MOD(id, ?) 来动态计算分片。通过这些配置和代码,你可以确保在分布式环境中高效且准确地执行周期性任务,多个节点会并行处理任务,提高任务处理效率。ElasticJob 提供了强大的分布式调度能力,可以帮助你实现高效的任务管理和执行。
以上这种如果有50万数据要处理需要多久
处理50万条数据所需的时间取决于多个因素,包括数据库查询和写入的性能、网络延迟、计算资源(CPU、内存等)以及任务的复杂性。为了提供一个更精确的估计,我们可以考虑以下几个方面:
数据库查询和写入性能:
批量处理大小:
BATCH_SIZE)会影响处理速度。较大的批量可以减少数据库的往返次数,但也会增加内存占用。并行处理:
THREAD_POOL_SIZE)可以提高并行处理能力。网络延迟:
假设以下条件:
BATCH_SIZE = 1000)。THREAD_POOL_SIZE = 10)。我们可以大致估算处理时间:
总记录数 = 500,000
每批处理记录数 = 1,000
批次数 = 总记录数 / 每批处理记录数 = 500,000 / 1,000 = 500
每次批量处理时间 = 0.5秒
总处理时间(不并行) = 批次数 * 每次批量处理时间 = 500 * 0.5 = 250秒
并行处理:使用10个线程并行处理
总处理时间(并行) = 总处理时间(不并行) / 线程数 = 250 / 10 = 25秒
为了进一步优化处理时间,可以考虑以下建议:
优化数据库查询:
批量插入:
executeBatch)减少数据库写入的往返次数。合理配置批量大小和线程池:
数据库连接池:
以下是一个改进后的代码示例,包含上述优化建议:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@Component
public class RewardCalculator {
@Autowired
private JdbcTemplate jdbcTemplate;
private static final int BATCH_SIZE = 1000; // 每批处理的记录数
private static final int THREAD_POOL_SIZE = 10; // 线程池大小
public void calculateAndInsertRewards(int shardingItem, int shardingTotalCount) {
ExecutorService executorService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
try (Connection connection = jdbcTemplate.getDataSource().getConnection()) {
int offset = 0;
List<UserRewardSummary> userRewardSummaries;
do {
userRewardSummaries = fetchUserRewardSummaries(connection, offset, BATCH_SIZE, shardingItem, shardingTotalCount);
offset += BATCH_SIZE;
if (!userRewardSummaries.isEmpty()) {
executorService.submit(() -> {
List<UserReward> rewards = calculateRewards(userRewardSummaries);
insertRewards(connection, rewards);
});
}
} while (!userRewardSummaries.isEmpty());
} catch (SQLException e) {
e.printStackTrace();
} finally {
executorService.shutdown();
}
}
private List<UserRewardSummary> fetchUserRewardSummaries(Connection connection, int offset, int batchSize, int shardingItem, int shardingTotalCount) throws SQLException {
List<UserRewardSummary> summaries = new ArrayList<>();
String query = "SELECT * FROM gem_staking.user_reward_summary WHERE cal_state = 0 AND MOD(id, ?) = ? LIMIT ? OFFSET ?";
try (PreparedStatement ps = connection.prepareStatement(query)) {
ps.setInt(1, shardingTotalCount);
ps.setInt(2, shardingItem);
ps.setInt(3, batchSize);
ps.setInt(4, offset);
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
UserRewardSummary summary = new UserRewardSummary();
summary.setId(rs.getLong("id"));
summary.setUserId(rs.getString("user_id"));
summary.setPoolId(rs.getString("pool_id"));
summary.setStakingHoldToken(rs.getString("staking_hold_token"));
summary.setStakingHoldAmountAvg(rs.getBigDecimal("staking_hold_amount_avg"));
summary.setEarnToken(rs.getString("earn_token"));
summary.setSummaryStage(rs.getInt("summary_stage"));
summary.setCalState(rs.getInt("cal_state"));
summary.setCreatedAt(rs.getTimestamp("created_at"));
summary.setUpdatedAt(rs.getTimestamp("updated_at"));
summaries.add(summary);
}
}
}
return summaries;
}
private List<UserReward> calculateRewards(List<UserRewardSummary> summaries) {
List<UserReward> rewards = new ArrayList<>();
for (UserRewardSummary summary : summaries) {
UserReward reward = new UserReward();
reward.setUserId(summary.getUserId());
reward.setPoolId(summary.getPoolId());
reward.setEarnToken(summary.getEarnToken());
reward.setRewardAmount(summary.getStakingHoldAmountAvg().multiply(new BigDecimal("0.1"))); // 示例:收益计算逻辑
reward.setSummaryStage(summary.getSummaryStage());
rewards.add(reward);
}
return rewards;
}
private void insertRewards(Connection connection, List<UserReward> rewards) {
String insertQuery = "INSERT INTO gem_staking.user_rewards (user_id, pool_id, earn_token, reward_amount, summary_stage) VALUES (?, ?, ?, ?, ?)";
try (PreparedStatement ps = connection.prepareStatement(insertQuery)) {
for (UserReward reward : rewards) {
ps.setString(1, reward.getUserId());
ps.setString(2, reward.getPoolId());
ps.setString(3, reward.getEarnToken());
ps.setBigDecimal(4, reward.getRewardAmount());
ps.setInt(5, reward.getSummaryStage());
ps.addBatch();
}
ps.executeBatch();
// 更新cal_state为1
updateCalState(connection, rewards);
} catch (SQLException e) {
e.printStackTrace();
}
}
private void updateCalState(Connection connection, List<UserReward> rewards) {
String updateQuery = "UPDATE gem_staking.user_reward_summary SET cal_state = 1 WHERE user_id = ? AND pool_id = ? AND summary_stage = ?";
try (PreparedStatement ps = connection.prepareStatement(updateQuery)) {
for (UserReward reward : rewards) {
ps.setString(1, reward.getUserId());
ps.setString(2, reward.getPoolId());
ps.setInt(3, reward.getSummaryStage());
ps.addBatch();
}
ps.executeBatch();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
通过合理配置批量处理大小和线程池,并使用批量插入和索引优化,可以显著提高处理速度。尽管实际处理时间会受到多种因素的影响,但通过这些优化策略,处理50万条数据应该可以在合理的时间范围内完成。
如果不设置shardingItem, shardingTotalCount,部署三个节点,会怎样
如果你不设置 shardingItem 和 shardingTotalCount,ElasticJob 在默认情况下仍然会使用分片机制将任务分配到多个节点上。每个节点会根据总的分片数和当前的节点数来分配和处理任务。但是,这样做会失去精细控制分片的能力,可能会导致负载不均衡。
shardingItem 和 shardingTotalCount如果你不显式传递 shardingItem 和 shardingTotalCount,ElasticJob 会自动处理这些参数,并将其传递给每个节点的任务执行逻辑。每个节点会根据分片项处理自己分配到的任务。
shardingItem 和 shardingTotalCount以下是一个示例,展示如何在不显式传递 shardingItem 和 shardingTotalCount 的情况下使用 ElasticJob:
ElasticJobConfig.java:
import org.apache.shardingsphere.elasticjob.api.JobConfiguration;
import org.apache.shardingsphere.elasticjob.simple.job.SimpleJob;
import org.apache.shardingsphere.elasticjob.lite.api.bootstrap.impl.ScheduleJobBootstrap;
import org.apache.shardingsphere.elasticjob.lite.spring.boot.job.ElasticJobLiteAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class ElasticJobConfig {
@Bean
public ElasticJobLiteAutoConfiguration elasticJobLiteAutoConfiguration() {
return new ElasticJobLiteAutoConfiguration();
}
@Bean
public ScheduleJobBootstrap scheduleJobBootstrap(SimpleJob job) {
// 配置3个分片,每小时执行一次
JobConfiguration jobConfig = JobConfiguration.newBuilder("rewardCalculationJob", 3)
.cron("0 0 * * * ?")
.build();
return new ScheduleJobBootstrap(elasticJobLiteAutoConfiguration().getRegistryCenter(), job, jobConfig);
}
}
RewardCalculationJob.java:
import org.apache.shardingsphere.elasticjob.simple.job.SimpleJob;
import org.apache.shardingsphere.elasticjob.api.ShardingContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class RewardCalculationJob implements SimpleJob {
@Autowired
private RewardCalculator rewardCalculator;
@Override
public void execute(ShardingContext shardingContext) {
rewardCalculator.calculateAndInsertRewards(shardingContext);
}
}
RewardCalculator.java:
import org.apache.shardingsphere.elasticjob.api.ShardingContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@Component
public class RewardCalculator {
@Autowired
private JdbcTemplate jdbcTemplate;
private static final int BATCH_SIZE = 1000; // 每批处理的记录数
private static final int THREAD_POOL_SIZE = 10; // 线程池大小
public void calculateAndInsertRewards(ShardingContext shardingContext) {
int shardingItem = shardingContext.getShardingItem();
int shardingTotalCount = shardingContext.getShardingTotalCount();
ExecutorService executorService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
try (Connection connection = jdbcTemplate.getDataSource().getConnection()) {
int offset = 0;
List<UserRewardSummary> userRewardSummaries;
do {
userRewardSummaries = fetchUserRewardSummaries(connection, offset, BATCH_SIZE, shardingItem, shardingTotalCount);
offset += BATCH_SIZE;
if (!userRewardSummaries.isEmpty()) {
executorService.submit(() -> {
List<UserReward> rewards = calculateRewards(userRewardSummaries);
insertRewards(connection, rewards);
});
}
} while (!userRewardSummaries.isEmpty());
} catch (SQLException e) {
e.printStackTrace();
} finally {
executorService.shutdown();
}
}
private List<UserRewardSummary> fetchUserRewardSummaries(Connection connection, int offset, int batchSize, int shardingItem, int shardingTotalCount) throws SQLException {
List<UserRewardSummary> summaries = new ArrayList<>();
String query = "SELECT * FROM gem_staking.user_reward_summary WHERE cal_state = 0 AND MOD(id, ?) = ? LIMIT ? OFFSET ?";
try (PreparedStatement ps = connection.prepareStatement(query)) {
ps.setInt(1, shardingTotalCount);
ps.setInt(2, shardingItem);
ps.setInt(3, batchSize);
ps.setInt(4, offset);
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
UserRewardSummary summary = new UserRewardSummary();
summary.setId(rs.getLong("id"));
summary.setUserId(rs.getString("user_id"));
summary.setPoolId(rs.getString("pool_id"));
summary.setStakingHoldToken(rs.getString("staking_hold_token"));
summary.setStakingHoldAmountAvg(rs.getBigDecimal("staking_hold_amount_avg"));
summary.setEarnToken(rs.getString("earn_token"));
summary.setSummaryStage(rs.getInt("summary_stage"));
summary.setCalState(rs.getInt("cal_state"));
summary.setCreatedAt(rs.getTimestamp("created_at"));
summary.setUpdatedAt(rs.getTimestamp("updated_at"));
summaries.add(summary);
}
}
}
return summaries;
}
private List<UserReward> calculateRewards(List<UserRewardSummary> summaries) {
List<UserReward> rewards = new ArrayList<>();
for (UserRewardSummary summary : summaries) {
UserReward reward = new UserReward();
reward.setUserId(summary.getUserId());
reward.setPoolId(summary.getPoolId());
reward.setEarnToken(summary.getEarnToken());
reward.setRewardAmount(summary.getStakingHoldAmountAvg().multiply(new BigDecimal("0.1"))); // 示例:收益计算逻辑
reward.setSummaryStage(summary.getSummaryStage());
rewards.add(reward);
}
return rewards;
}
private void insertRewards(Connection connection, List<UserReward> rewards) {
String insertQuery = "INSERT INTO gem_staking.user_rewards (user_id, pool_id, earn_token, reward_amount, summary_stage) VALUES (?, ?, ?, ?, ?)";
try (PreparedStatement ps = connection.prepareStatement(insertQuery)) {
for (UserReward reward : rewards) {
ps.setString(1, reward.getUserId());
ps.setString(2, reward.getPoolId());
ps.setString(3, reward.getEarnToken());
ps.setBigDecimal(4, reward.getRewardAmount());
ps.setInt(5, reward.getSummaryStage());
ps.addBatch();
}
ps.executeBatch();
// 更新cal_state为1
updateCalState(connection, rewards);
} catch (SQLException e) {
e.printStackTrace();
}
}
private void updateCalState(Connection connection, List<UserReward> rewards) {
String updateQuery = "UPDATE gem_staking.user_reward_summary SET cal_state = 1 WHERE user_id = ? AND pool_id = ? AND summary_stage = ?";
try (PreparedStatement ps = connection.prepareStatement(updateQuery)) {
for (UserReward reward : rewards) {
ps.setString(1, reward.getUserId());
ps.setString(2, reward.getPoolId());
ps.setInt(3, reward.getSummaryStage());
ps.addBatch();
}
ps.executeBatch();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
ShardingContext 获取当前分片项和分片总数。通过 ElasticJob 的分布式调度机制,你可以高效地在多个节点上并行处理任务,即使没有显式地传递 shardingItem 和 shardingTotalCount。ElasticJob 会自动处理这些参数,并确保任务的均衡分配和高效执行。这样可以充分利用集群资源,提高任务处理的整体性能和可靠性。
我的执行代码不关心ShardingContext 获取当前分片项和分片总数会怎样呢,我们系统里很多定时任务都没有关心这个分片
如果你的定时任务没有关心 ShardingContext 来获取当前分片项和分片总数,ElasticJob 仍然会将任务分片并分配给各个节点,但你的任务逻辑将不会根据分片来处理数据。这意味着每个节点可能会处理相同的数据,导致数据重复处理和资源浪费。
为了避免上述问题,你需要在任务逻辑中处理分片,确保每个节点只处理自己分配到的分片数据。以下是一个示例,展示了如何在任务逻辑中处理分片:
ElasticJobConfig.java:
import org.apache.shardingsphere.elasticjob.api.JobConfiguration;
import org.apache.shardingsphere.elasticjob.simple.job.SimpleJob;
import org.apache.shardingsphere.elasticjob.lite.api.bootstrap.impl.ScheduleJobBootstrap;
import org.apache.shardingsphere.elasticjob.lite.spring.boot.job.ElasticJobLiteAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class ElasticJobConfig {
@Bean
public ElasticJobLiteAutoConfiguration elasticJobLiteAutoConfiguration() {
return new ElasticJobLiteAutoConfiguration();
}
@Bean
public ScheduleJobBootstrap scheduleJobBootstrap(SimpleJob job) {
// 配置3个分片,每小时执行一次
JobConfiguration jobConfig = JobConfiguration.newBuilder("rewardCalculationJob", 3)
.cron("0 0 * * * ?")
.build();
return new ScheduleJobBootstrap(elasticJobLiteAutoConfiguration().getRegistryCenter(), job, jobConfig);
}
}
RewardCalculationJob.java:
import org.apache.shardingsphere.elasticjob.simple.job.SimpleJob;
import org.apache.shardingsphere.elasticjob.api.ShardingContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class RewardCalculationJob implements SimpleJob {
@Autowired
private RewardCalculator rewardCalculator;
@Override
public void execute(ShardingContext shardingContext) {
int shardingItem = shardingContext.getShardingItem();
int shardingTotalCount = shardingContext.getShardingTotalCount();
rewardCalculator.calculateAndInsertRewards(shardingItem, shardingTotalCount);
}
}
RewardCalculator.java:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@Component
public class RewardCalculator {
@Autowired
private JdbcTemplate jdbcTemplate;
private static final int BATCH_SIZE = 1000; // 每批处理的记录数
private static final int THREAD_POOL_SIZE = 10; // 线程池大小
public void calculateAndInsertRewards(int shardingItem, int shardingTotalCount) {
ExecutorService executorService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
try (Connection connection = jdbcTemplate.getDataSource().getConnection()) {
int offset = 0;
List<UserRewardSummary> userRewardSummaries;
do {
userRewardSummaries = fetchUserRewardSummaries(connection, offset, BATCH_SIZE, shardingItem, shardingTotalCount);
offset += BATCH_SIZE;
if (!userRewardSummaries.isEmpty()) {
executorService.submit(() -> {
List<UserReward> rewards = calculateRewards(userRewardSummaries);
insertRewards(connection, rewards);
});
}
} while (!userRewardSummaries.isEmpty());
} catch (SQLException e) {
e.printStackTrace();
} finally {
executorService.shutdown();
}
}
private List<UserRewardSummary> fetchUserRewardSummaries(Connection connection, int offset, int batchSize, int shardingItem, int shardingTotalCount) throws SQLException {
List<UserRewardSummary> summaries = new ArrayList<>();
String query = "SELECT * FROM gem_staking.user_reward_summary WHERE cal_state = 0 AND MOD(id, ?) = ? LIMIT ? OFFSET ?";
try (PreparedStatement ps = connection.prepareStatement(query)) {
ps.setInt(1, shardingTotalCount);
ps.setInt(2, shardingItem);
ps.setInt(3, batchSize);
ps.setInt(4, offset);
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
UserRewardSummary summary = new UserRewardSummary();
summary.setId(rs.getLong("id"));
summary.setUserId(rs.getString("user_id"));
summary.setPoolId(rs.getString("pool_id"));
summary.setStakingHoldToken(rs.getString("staking_hold_token"));
summary.setStakingHoldAmountAvg(rs.getBigDecimal("staking_hold_amount_avg"));
summary.setEarnToken(rs.getString("earn_token"));
summary.setSummaryStage(rs.getInt("summary_stage"));
summary.setCalState(rs.getInt("cal_state"));
summary.setCreatedAt(rs.getTimestamp("created_at"));
summary.setUpdatedAt(rs.getTimestamp("updated_at"));
summaries.add(summary);
}
}
}
return summaries;
}
private List<UserReward> calculateRewards(List<UserRewardSummary> summaries) {
List<UserReward> rewards = new ArrayList<>();
for (UserRewardSummary summary : summaries) {
UserReward reward = new UserReward();
reward.setUserId(summary.getUserId());
reward.setPoolId(summary.getPoolId());
reward.setEarnToken(summary.getEarnToken());
reward.setRewardAmount(summary.getStakingHoldAmountAvg().multiply(new BigDecimal("0.1"))); // 示例:收益计算逻辑
reward.setSummaryStage(summary.getSummaryStage());
rewards.add(reward);
}
return rewards;
}
private void insertRewards(Connection connection, List<UserReward> rewards) {
String insertQuery = "INSERT INTO gem_staking.user_rewards (user_id, pool_id, earn_token, reward_amount, summary_stage) VALUES (?, ?, ?, ?, ?)";
try (PreparedStatement ps = connection.prepareStatement(insertQuery)) {
for (UserReward reward : rewards) {
ps.setString(1, reward.getUserId());
ps.setString(2, reward.getPoolId());
ps.setString(3, reward.getEarnToken());
ps.setBigDecimal(4, reward.getRewardAmount());
ps.setInt(5, reward.getSummaryStage());
ps.addBatch();
}
ps.executeBatch();
// 更新cal_state为1
updateCalState(connection, rewards);
} catch (SQLException e) {
e.printStackTrace();
}
}
private void updateCalState(Connection connection, List<UserReward> rewards) {
String updateQuery = "UPDATE gem_staking.user_reward_summary SET cal_state = 1 WHERE user_id = ? AND pool_id = ? AND summary_stage = ?";
try (PreparedStatement ps = connection.prepareStatement(updateQuery)) {
for (UserReward reward : rewards) {
ps.setString(1, reward.getUserId());
ps.setString(2, reward.getPoolId());
ps.setInt(3, reward.getSummaryStage());
ps.addBatch();
}
ps.executeBatch();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
ShardingContext 获取当前分片项(shardingItem)和分片总数(shardingTotalCount),并根据分片项处理数据。通过处理分片,可以确保任务在多个节点上均衡分配和高效执行。ElasticJob 提供了强大的分布式调度能力,通过分片机制可以避免数据重复处理和资源浪费。确保在任务逻辑中处理分片,可以充分利用 ElasticJob 的分布式调度能力,实现高效的任务管理和执行。
<job:simple id="userTradableSymbolApproveCheckTask"
job-ref="userTradableSymbolApproveCheckTask"
registry-center-ref="regCenter"
cron="${kucoin.job.userTradableSymbolApproveCheckCron}"
sharding-total-count="1"
overwrite="true"
description="用户可交易币对白名单审批状态检查任务"/>
你的配置显示了一个简单的 ElasticJob 任务 userTradableSymbolApproveCheckTask,它的分片总数 sharding-total-count 被设置为 1。这意味着这个任务实际上只会有一个分片,并且整个任务只会分配给一个节点来执行。因此,在这种配置下,即使你有多个节点,任务也不会被分片和并行处理。
<job:simple id="userTradableSymbolApproveCheckTask"
job-ref="userTradableSymbolApproveCheckTask"
registry-center-ref="regCenter"
cron="${kucoin.job.userTradableSymbolApproveCheckCron}"
sharding-total-count="1"
overwrite="true"
description="用户可交易币对白名单审批状态检查任务"/>
1 表示没有分片。sharding-total-count 被设置为 1,任务不会被分片。整个任务会被分配给一个节点来执行。如果你希望任务能够在多个节点上并行处理,可以增加 sharding-total-count 的值,并在任务实现中处理分片逻辑。以下是如何修改配置和实现分片的示例:
将 sharding-total-count 设置为大于 1 的值,例如 3:
<job:simple id="userTradableSymbolApproveCheckTask"
job-ref="userTradableSymbolApproveCheckTask"
registry-center-ref="regCenter"
cron="${kucoin.job.userTradableSymbolApproveCheckCron}"
sharding-total-count="3"
overwrite="true"
description="用户可交易币对白名单审批状态检查任务"/>
确保你的任务实现类处理分片逻辑:
UserTradableSymbolApproveCheckTask.java:
import org.apache.shardingsphere.elasticjob.simple.job.SimpleJob;
import org.apache.shardingsphere.elasticjob.api.ShardingContext;
import org.springframework.stereotype.Component;
@Component
public class UserTradableSymbolApproveCheckTask implements SimpleJob {
@Override
public void execute(ShardingContext shardingContext) {
int shardingItem = shardingContext.getShardingItem();
int shardingTotalCount = shardingContext.getShardingTotalCount();
// 根据分片项处理数据
processShard(shardingItem, shardingTotalCount);
}
private void processShard(int shardingItem, int shardingTotalCount) {
// 实现你的分片处理逻辑
System.out.println("Processing shard: " + shardingItem + " out of " + shardingTotalCount);
// 示例:根据分片项处理不同的数据
// 你的具体处理逻辑,例如数据库查询和处理
}
}
sharding-total-count 设置为大于 1 的值,表示任务将被分成多个分片。ShardingContext 获取当前分片项和分片总数,并根据分片项处理数据。1,意味着任务不会被分片,只会在一个节点上执行。sharding-total-count 的值,并在任务实现中处理分片逻辑。通过合理配置和实现分片逻辑,可以充分利用 ElasticJob 的分布式调度能力,实现高效的任务管理和执行。
sharding-total-count这个如果不指定会怎样
如果你在 ElasticJob 配置中没有指定 sharding-total-count,ElasticJob 将无法进行分片,因为 sharding-total-count 是定义任务分片总数的必要参数。没有这个参数,ElasticJob 将无法确定任务应该如何分片和分配给不同的节点。
sharding-total-count,ElasticJob 无法将任务分成多个分片,这意味着无法利用分布式调度的优势。sharding-total-count 参数来确定任务的分片配置,如果没有指定这个参数,任务可能无法启动,或者会抛出配置错误。sharding-total-count 是 ElasticJob 配置中的一个必需参数,用于定义任务的分片总数。通过这个参数,ElasticJob 可以将任务分成多个分片,并将这些分片均匀地分配给当前活跃的节点进行处理。
以下是一个完整的 ElasticJob 配置示例,包含 sharding-total-count 参数:
<job:simple id="userTradableSymbolApproveCheckTask"
job-ref="userTradableSymbolApproveCheckTask"
registry-center-ref="regCenter"
cron="${kucoin.job.userTradableSymbolApproveCheckCron}"
sharding-total-count="3"
overwrite="true"
description="用户可交易币对白名单审批状态检查任务"/>
UserTradableSymbolApproveCheckTask.java:
import org.apache.shardingsphere.elasticjob.simple.job.SimpleJob;
import org.apache.shardingsphere.elasticjob.api.ShardingContext;
import org.springframework.stereotype.Component;
@Component
public class UserTradableSymbolApproveCheckTask implements SimpleJob {
@Override
public void execute(ShardingContext shardingContext) {
int shardingItem = shardingContext.getShardingItem();
int shardingTotalCount = shardingContext.getShardingTotalCount();
// 根据分片项处理数据
processShard(shardingItem, shardingTotalCount);
}
private void processShard(int shardingItem, int shardingTotalCount) {
// 实现你的分片处理逻辑
System.out.println("Processing shard: " + shardingItem + " out of " + shardingTotalCount);
// 示例:根据分片项处理不同的数据
// 你的具体处理逻辑,例如数据库查询和处理
}
}
sharding-total-count="3" 将任务分成3个分片。ShardingContext 获取当前分片项和分片总数,并根据分片项处理数据。sharding-total-count:在 ElasticJob 配置中,sharding-total-count 是一个必需参数,用于定义任务的分片总数。如果没有指定,ElasticJob 将无法进行分片,任务可能无法启动。sharding-total-count,ElasticJob 可以将任务分片,并将分片均匀分配给多个节点,提高任务处理效率。确保在 ElasticJob 配置中指定 sharding-total-count 参数,并在任务实现中处理分片逻辑,以充分利用 ElasticJob 的分布式调度能力,实现高效的任务管理和执行。
overwrite="true"是什么作用
在 ElasticJob 的配置中,overwrite="true" 参数的作用是允许覆盖现有的任务配置。当你启动或重新启动任务时,新的配置将会覆盖之前已经存在的配置。
overwrite="true" 时,如果任务已经存在,新的配置会覆盖旧的配置。这对于更新任务的调度策略、分片数、Cron 表达式等非常有用。overwrite="true",当任务已经存在时,新的配置将不会生效,可能会导致配置冲突或不一致。overwrite="true" 非常有用,可以快速应用新的配置。overwrite="true" 可以确保新的配置及时生效。以下是一个包含 overwrite="true" 的 ElasticJob 配置示例:
<job:simple id="userTradableSymbolApproveCheckTask"
job-ref="userTradableSymbolApproveCheckTask"
registry-center-ref="regCenter"
cron="${kucoin.job.userTradableSymbolApproveCheckCron}"
sharding-total-count="3"
overwrite="true"
description="用户可交易币对白名单审批状态检查任务"/>
true,表示允许覆盖现有的任务配置。UserTradableSymbolApproveCheckTask.java:
import org.apache.shardingsphere.elasticjob.simple.job.SimpleJob;
import org.apache.shardingsphere.elasticjob.api.ShardingContext;
import org.springframework.stereotype.Component;
@Component
public class UserTradableSymbolApproveCheckTask implements SimpleJob {
@Override
public void execute(ShardingContext shardingContext) {
int shardingItem = shardingContext.getShardingItem();
int shardingTotalCount = shardingContext.getShardingTotalCount();
// 根据分片项处理数据
processShard(shardingItem, shardingTotalCount);
}
private void processShard(int shardingItem, int shardingTotalCount) {
// 实现你的分片处理逻辑
System.out.println("Processing shard: " + shardingItem + " out of " + shardingTotalCount);
// 示例:根据分片项处理不同的数据
// 你的具体处理逻辑,例如数据库查询和处理
}
}
sharding-total-count="3" 将任务分成3个分片。ShardingContext 获取当前分片项和分片总数,并根据分片项处理数据。overwrite="true" 的作用:允许覆盖现有的任务配置,确保新的配置能够生效。sharding-total-count,ElasticJob 可以将任务分片,并将分片均匀分配给多个节点,提高任务处理效率。确保在 ElasticJob 配置中合理使用 overwrite="true" 参数,以便能够动态调整任务配置,实现灵活、高效的任务管理和执行。
也就是说如果 sharding-total-count配置在Apollo这样的分布式配置中心里,是可以热更新的吗
是的,通过使用 overwrite="true" 配置,ElasticJob 可以支持热更新任务配置。这意味着如果你将 sharding-total-count 等配置参数存储在 Apollo 这样的分布式配置中心里,并且在运行时更新这些参数,ElasticJob 可以动态地应用新的配置,而无需重启整个应用程序。
sharding-total-count)存储在 Apollo 等分布式配置中心中。overwrite="true",确保新的配置能够动态覆盖旧的配置,任务会根据新的配置进行调度和分片。以下是如何配置 ElasticJob 和 Apollo 的示例:
首先,确保你的项目已经集成了 Apollo,并且可以从 Apollo 获取配置参数。
在 application.yml 中配置 Apollo:
apollo:
bootstrap:
enabled: true
meta: http://config-service-url:8080
将 ElasticJob 的配置参数存储在 Apollo 中,例如:
# Apollo 配置
kucoin.job.userTradableSymbolApproveCheckCron=0 0 * * * ?
kucoin.job.userTradableSymbolApproveCheckShardingTotalCount=3
在 Spring 配置中使用 Apollo 的配置:
spring:
profiles:
active: dev
elasticjob:
jobs:
userTradableSymbolApproveCheckTask:
cron: ${kucoin.job.userTradableSymbolApproveCheckCron}
sharding-total-count: ${kucoin.job.userTradableSymbolApproveCheckShardingTotalCount}
description: 用户可交易币对白名单审批状态检查任务
overwrite: true
ElasticJobConfig.java:
import org.apache.shardingsphere.elasticjob.api.JobConfiguration;
import org.apache.shardingsphere.elasticjob.simple.job.SimpleJob;
import org.apache.shardingsphere.elasticjob.lite.api.bootstrap.impl.ScheduleJobBootstrap;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class ElasticJobConfig {
@Value("${kucoin.job.userTradableSymbolApproveCheckCron}")
private String cron;
@Value("${kucoin.job.userTradableSymbolApproveCheckShardingTotalCount}")
private int shardingTotalCount;
@Bean
public ScheduleJobBootstrap scheduleJobBootstrap(SimpleJob job) {
JobConfiguration jobConfig = JobConfiguration.newBuilder("userTradableSymbolApproveCheckTask", shardingTotalCount)
.cron(cron)
.overwrite(true) // 确保新配置覆盖旧配置
.build();
return new ScheduleJobBootstrap(elasticJobLiteAutoConfiguration().getRegistryCenter(), job, jobConfig);
}
@Bean
public ElasticJobLiteAutoConfiguration elasticJobLiteAutoConfiguration() {
return new ElasticJobLiteAutoConfiguration();
}
}
UserTradableSymbolApproveCheckTask.java:
import org.apache.shardingsphere.elasticjob.simple.job.SimpleJob;
import org.apache.shardingsphere.elasticjob.api.ShardingContext;
import org.springframework.stereotype.Component;
@Component
public class UserTradableSymbolApproveCheckTask implements SimpleJob {
@Override
public void execute(ShardingContext shardingContext) {
int shardingItem = shardingContext.getShardingItem();
int shardingTotalCount = shardingContext.getShardingTotalCount();
// 根据分片项处理数据
processShard(shardingItem, shardingTotalCount);
}
private void processShard(int shardingItem, int shardingTotalCount) {
// 实现你的分片处理逻辑
System.out.println("Processing shard: " + shardingItem + " out of " + shardingTotalCount);
// 示例:根据分片项处理不同的数据
// 你的具体处理逻辑,例如数据库查询和处理
}
}
overwrite=true 确保新配置能够覆盖旧配置,任务会根据新的配置进行调度和分片。通过将 ElasticJob 的配置参数存储在 Apollo 等分布式配置中心,并使用 overwrite="true",你可以实现任务配置的热更新。这样,任务在运行时可以动态应用新的配置参数,无需重启应用程序,从而实现灵活、高效的任务管理和执行。确保在任务实现中处理分片逻辑,以充分利用 ElasticJob 的分布式调度能力。
CREATE TABLE user_reward_summary (
id bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
user_id char(24) NOT NULL DEFAULT '' COMMENT '用户ID',
pool_id char(24) NOT NULL DEFAULT '' COMMENT '矿池ID',
staking_hold_token char(24) NOT NULL DEFAULT '' COMMENT '质押币种',
staking_hold_amount_avg decimal(38,20) NOT NULL DEFAULT '0.00000000000000000000' COMMENT '持仓余额',
earn_token char(24) NOT NULL DEFAULT '' COMMENT '挖的币种',
summary_stage int(11) NOT NULL DEFAULT '1' COMMENT '汇总阶段,挖矿总时长/收益周期,从1开始',
cal_state int(11) NOT NULL DEFAULT '0' COMMENT '是否算过收益,0表示没有,1表示算过了',
created_at datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
updated_at datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (id),
KEY id_pool_stage_cal (pool_id,summary_stage,cal_state) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户持仓快照汇总表';CREATE TABLE user_staking_hold_snapshot (
id bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
user_id char(24) NOT NULL DEFAULT '' COMMENT '用户ID',
campaign_id char(24) NOT NULL DEFAULT '' COMMENT '活动ID',
pool_id char(24) NOT NULL DEFAULT '' COMMENT '矿池ID',
staking_hold_token char(24) NOT NULL DEFAULT '' COMMENT '质押币种',
staking_hold_amount decimal(38,20) NOT NULL DEFAULT '0.00000000000000000000' COMMENT '持仓余额',
bonus_coefficient decimal(20,2) NOT NULL DEFAULT '0.00' COMMENT '加成系数',
earn_token char(24) NOT NULL DEFAULT '' COMMENT '挖的币种',
st datetime NOT NULL DEFAULT '9970-01-01 00:00:00' COMMENT '快照执行的当时的时间',
summary_stage int(11) NOT NULL DEFAULT '1' COMMENT '汇总阶段,挖矿总时长/收益周期,从1开始',
created_at datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
updated_at datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (id),
KEY id_cam_pool_user (pool_id,summary_stage,st) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户持仓快照表';INSERT into gem_staking.user_reward_summary SELECT
user_id,pool_id,staking_hold_token,AVG(staking_hold_amount) as staking_hold_amount_avg,earn_token,summary_stage,0
FROM gem_staking.user_staking_hold_snapshot
WHERE
summary_stage = 1
and pool_id = 2
group by user_id,pool_id,staking_hold_token,earn_token,summary_stage这个sql有没有问题
你的 SQL 语句基本上是正确的,但是有一些需要注意的地方:
created_at 和 updated_at 列。这些列在目标表 user_reward_summary 中是必须的,并且有默认值。SELECT 子句中添加 NULL 来填充 id 列,因为 id 是 AUTO_INCREMENT 列,你不需要在 INSERT 中显式提供它。group by 子句中的列和 select 子句中的列一致。INSERT INTO gem_staking.user_reward_summary (
user_id,
pool_id,
staking_hold_token,
staking_hold_amount_avg,
earn_token,
summary_stage,
cal_state,
created_at,
updated_at
)
SELECT
user_id,
pool_id,
staking_hold_token,
AVG(staking_hold_amount) AS staking_hold_amount_avg,
earn_token,
summary_stage,
0 AS cal_state,
CURRENT_TIMESTAMP AS created_at,
CURRENT_TIMESTAMP AS updated_at
FROM gem_staking.user_staking_hold_snapshot
WHERE
summary_stage = 1
AND pool_id = '2' -- 假设 pool_id 是字符串类型,如果是数字类型则不需要引号
GROUP BY
user_id,
pool_id,
staking_hold_token,
earn_token,
summary_stage;
INSERT INTO 子句中显式指定插入的列名,以确保数据顺序和目标表的列顺序一致。id 列:你不需要在 INSERT 中显式提供 id 列,因为它是 AUTO_INCREMENT 列。created_at 和 updated_at 列:在 SELECT 子句中添加 CURRENT_TIMESTAMP 来填充这些列。GROUP BY 子句中的列和 SELECT 子句中的列一致:在 GROUP BY 子句中包含所有需要分组的列。pool_id 的数据类型一致。如果 pool_id 是字符串类型,确保在 WHERE 子句和 GROUP BY 子句中使用相同的引号。通过这些修正,你的 SQL 语句应该能够正确执行,并将计算结果插入到 user_reward_summary 表中。
如果有20万数据插入有问题吗
插入大量数据(例如20万条记录)时,可能会遇到一些性能问题以及潜在的锁竞争问题。为了确保插入操作高效且不会对系统产生负面影响,以下是一些优化建议和注意事项:
批量插入可以显著提高插入性能,减少数据库连接和事务的开销。MySQL 支持批量插入语法,可以将多条记录一次性插入:
INSERT INTO gem_staking.user_reward_summary (
user_id,
pool_id,
staking_hold_token,
staking_hold_amount_avg,
earn_token,
summary_stage,
cal_state,
created_at,
updated_at
)
SELECT
user_id,
pool_id,
staking_hold_token,
AVG(staking_hold_amount) AS staking_hold_amount_avg,
earn_token,
summary_stage,
0 AS cal_state,
CURRENT_TIMESTAMP AS created_at,
CURRENT_TIMESTAMP AS updated_at
FROM gem_staking.user_staking_hold_snapshot
WHERE
summary_stage = 1
AND pool_id = '2' -- 假设 pool_id 是字符串类型,如果是数字类型则不需要引号
GROUP BY
user_id,
pool_id,
staking_hold_token,
earn_token,
summary_stage;
如果一次性插入20万条记录仍然存在性能问题,可以考虑分批处理。分批处理可以减少每次插入的记录数,降低单次事务大小,从而减少锁竞争。以下是一个分批处理的示例:
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.List;
@Component
public class BatchInsertProcessor {
@Autowired
private JdbcTemplate jdbcTemplate;
private static final int BATCH_SIZE = 1000;
public void batchInsert(List<UserRewardSummary> rewardSummaries) {
int totalRecords = rewardSummaries.size();
int batches = (totalRecords + BATCH_SIZE - 1) / BATCH_SIZE;
for (int i = 0; i < batches; i++) {
int start = i * BATCH_SIZE;
int end = Math.min(start + BATCH_SIZE, totalRecords);
List<UserRewardSummary> batch = rewardSummaries.subList(start, end);
jdbcTemplate.batchUpdate(
"INSERT INTO gem_staking.user_reward_summary (user_id, pool_id, staking_hold_token, staking_hold_amount_avg, earn_token, summary_stage, cal_state, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
new BatchPreparedStatementSetter() {
@Override
public void setValues(PreparedStatement ps, int i) throws SQLException {
UserRewardSummary summary = batch.get(i);
ps.setString(1, summary.getUserId());
ps.setString(2, summary.getPoolId());
ps.setString(3, summary.getStakingHoldToken());
ps.setBigDecimal(4, summary.getStakingHoldAmountAvg());
ps.setString(5, summary.getEarnToken());
ps.setInt(6, summary.getSummaryStage());
ps.setInt(7, summary.getCalState());
ps.setTimestamp(8, summary.getCreatedAt());
ps.setTimestamp(9, summary.getUpdatedAt());
}
@Override
public int getBatchSize() {
return batch.size();
}
}
);
}
}
}
确保你的表有适当的索引,以提高查询性能。对于查询条件中的列(如 pool_id, summary_stage, cal_state),可以创建复合索引:
CREATE INDEX idx_pool_stage_cal ON gem_staking.user_reward_summary (pool_id, summary_stage, cal_state);
在插入大量数据时,可以暂时禁用索引,然后在插入完成后重新启用索引。这可以显著提高插入性能,但要确保在插入完成后重新启用索引:
-- 禁用索引
ALTER TABLE gem_staking.user_reward_summary DISABLE KEYS;
-- 执行插入操作
-- 启用索引
ALTER TABLE gem_staking.user_reward_summary ENABLE KEYS;
在批量插入时,使用事务可以确保数据的完整性和一致性。可以将多个批次的插入操作放在一个事务中:
import org.springframework.transaction.annotation.Transactional;
@Transactional
public void batchInsertWithTransaction(List<UserRewardSummary> rewardSummaries) {
batchInsert(rewardSummaries);
}
通过使用批量插入、分批处理、索引优化以及事务管理,可以显著提高大量数据插入的效率,减少对系统的影响。确保在插入操作前进行充分的测试,以找到最佳的批量大小和处理策略。
<insert id="snapshotToSummary">
INSERT INTO gem_staking.user_reward_summary (
user_id,
pool_id,
staking_hold_token,
staking_hold_amount_avg,
earn_token,
summary_stage,
cal_state,
created_at,
updated_at
)
SELECT
user_id,
pool_id,
staking_hold_token,
AVG(staking_hold_amount) AS staking_hold_amount_avg,
earn_token,
summary_stage,
0 AS cal_state,
CURRENT_TIMESTAMP AS created_at,
CURRENT_TIMESTAMP AS updated_at
FROM gem_staking.user_staking_hold_snapshot
WHERE
summary_stage = #{summaryStage,jdbcType=INT}
AND pool_id = #{poolId,jdbcType=CHAR}
GROUP BY
user_id,
pool_id,
staking_hold_token,
earn_token,
summary_stage;
</insert>这样可以吗
你的 MyBatis insert 语句看起来基本是正确的,能够将数据从 gem_staking.user_staking_hold_snapshot 表插入到 gem_staking.user_reward_summary 表中,并且在 SELECT 子句中使用了聚合函数和 GROUP BY 子句。
#{},这会使得 SQL 更加灵活和可重用。GROUP BY 子句来确保数据聚合正确。以下是你的 MyBatis insert 语句,它应该可以正常工作:
<insert id="snapshotToSummary">
INSERT INTO gem_staking.user_reward_summary (
user_id,
pool_id,
staking_hold_token,
staking_hold_amount_avg,
earn_token,
summary_stage,
cal_state,
created_at,
updated_at
)
SELECT
user_id,
pool_id,
staking_hold_token,
AVG(staking_hold_amount) AS staking_hold_amount_avg,
earn_token,
summary_stage,
0 AS cal_state,
CURRENT_TIMESTAMP AS created_at,
CURRENT_TIMESTAMP AS updated_at
FROM gem_staking.user_staking_hold_snapshot
WHERE
summary_stage = #{summaryStage,jdbcType=INTEGER}
AND pool_id = #{poolId,jdbcType=CHAR}
GROUP BY
user_id,
pool_id,
staking_hold_token,
earn_token,
summary_stage;
</insert>
INSERT INTO:指定了目标表 gem_staking.user_reward_summary 以及要插入的列。SELECT:从 gem_staking.user_staking_hold_snapshot 表中选择数据,并进行必要的计算和聚合。WHERE 子句:使用 MyBatis 参数占位符 #{summaryStage} 和 #{poolId} 来过滤数据。GROUP BY 子句:确保数据按指定的列进行聚合。gem_staking.user_staking_hold_snapshot 表上有适当的索引,以提高查询性能。下面是一个示例,展示如何在 Java 代码中使用这个 MyBatis insert 方法:
UserRewardSummaryMapper.java:
package com.kucoin.gemstaking.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
@Mapper
public interface UserRewardSummaryMapper {
void snapshotToSummary(@Param("summaryStage") int summaryStage, @Param("poolId") String poolId);
}
Service 类:
package com.kucoin.gemstaking.service;
import com.kucoin.gemstaking.mapper.UserRewardSummaryMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
public class UserRewardSummaryService {
@Autowired
private UserRewardSummaryMapper userRewardSummaryMapper;
@Transactional
public void processSnapshotToSummary(int summaryStage, String poolId) {
userRewardSummaryMapper.snapshotToSummary(summaryStage, poolId);
}
}
snapshotToSummary 方法,使用 @Param 注解传递参数。Service 类中调用 snapshotToSummary 方法,并使用 @Transactional 注解确保事务管理。通过这些配置和代码,你可以将数据从 gem_staking.user_staking_hold_snapshot 表插入到 gem_staking.user_reward_summary 表中,并且可以灵活地指定 summaryStage 和 poolId 参数。确保在实际使用中根据数据量和性能需求进行充分测试和优化。
@Service
@Slf4j
public class RewardSummaryServiceImpl implements RewardSummaryService {
@Autowired
private UserRewardSummaryMapper userRewardSummaryMapper;
@Override
@Transactional
public void snapshotToSummary(String poolId, int stage) {
userRewardSummaryMapper.snapshotToSummary(stage,poolId);
}
}. @Component
@Slf4j
public class RewardSummaryTask implements SimpleJob {
@Autowired
private SnapshotSummaryService snapshotSummaryService;
@Autowired
private RewardSummaryService rewardSummaryService;
@Override
public void execute(ShardingContext context) {
//遍历需要汇总的任务
List<SnapshotSummaryJobDO> summaryJobDOS = snapshotSummaryService.getSnapshotSummaryTasks();
for(SnapshotSummaryJobDO snapshotSummaryJobDO : summaryJobDOS) {
String poolId = snapshotSummaryJobDO.getPoolId();
//从snapshot表汇总数据到user_reward_summary
try {
rewardSummaryService.snapshotToSummary(poolId, snapshotSummaryJobDO.getSummaryStage());
snapshotSummaryService.updateTaskFinish(snapshotSummaryJobDO);
} catch (Exception e) {
log.error("RewardSummaryTask.error.task:{}",snapshotSummaryJobDO.getId());
}
}
}
}要是snapshotToSummary方法失败了。会抛异常吗?会全部会滚吗,这样是否保证即使一个任务失败了也不影响其他任务
在你提供的代码中,RewardSummaryServiceImpl 类的 snapshotToSummary 方法被 @Transactional 注解修饰,这意味着该方法是事务性的。如果 snapshotToSummary 方法中的任何操作失败并抛出异常,事务将回滚,保证数据的一致性。
@Transactional 注解:@Transactional 注解确保在 snapshotToSummary 方法内的所有数据库操作要么全部成功,要么全部回滚。snapshotToSummary 方法中的任何操作失败并抛出异常,Spring 的事务管理器会捕获异常并回滚事务。RewardSummaryServiceImpl 类@Service
@Slf4j
public class RewardSummaryServiceImpl implements RewardSummaryService {
@Autowired
private UserRewardSummaryMapper userRewardSummaryMapper;
@Override
@Transactional
public void snapshotToSummary(String poolId, int stage) {
userRewardSummaryMapper.snapshotToSummary(stage, poolId);
}
}
@Transactional 注解确保 snapshotToSummary 方法内的操作具有事务性。RewardSummaryTask 类@Component
@Slf4j
public class RewardSummaryTask implements SimpleJob {
@Autowired
private SnapshotSummaryService snapshotSummaryService;
@Autowired
private RewardSummaryService rewardSummaryService;
@Override
public void execute(ShardingContext context) {
// 遍历需要汇总的任务
List<SnapshotSummaryJobDO> summaryJobDOS = snapshotSummaryService.getSnapshotSummaryTasks();
for (SnapshotSummaryJobDO snapshotSummaryJobDO : summaryJobDOS) {
String poolId = snapshotSummaryJobDO.getPoolId();
// 从snapshot表汇总数据到user_reward_summary
try {
rewardSummaryService.snapshotToSummary(poolId, snapshotSummaryJobDO.getSummaryStage());
snapshotSummaryService.updateTaskFinish(snapshotSummaryJobDO);
} catch (Exception e) {
log.error("RewardSummaryTask.error.task:{}", snapshotSummaryJobDO.getId(), e);
}
}
}
}
execute 方法中,snapshotToSummary 方法的调用被包裹在 try-catch 块中。如果 snapshotToSummary 方法抛出任何异常,该异常将被捕获并记录日志,但不会影响其他任务的执行。当 snapshotToSummary 方法抛出异常时,事务将回滚,确保数据的一致性。由于异常被捕获并记录日志,其他任务不会受到影响,即使一个任务失败,也不会阻止其他任务的执行。
为了确保日志中包含异常信息,可以在日志记录中添加异常对象 e:
try {
rewardSummaryService.snapshotToSummary(poolId, snapshotSummaryJobDO.getSummaryStage());
snapshotSummaryService.updateTaskFinish(snapshotSummaryJobDO);
} catch (Exception e) {
log.error("RewardSummaryTask.error.task:{}", snapshotSummaryJobDO.getId(), e);
}
@Transactional 注解确保 snapshotToSummary 方法内的操作具有事务性,如果方法失败并抛出异常,事务将回滚。RewardSummaryTask 类的 execute 方法中,异常被捕获并记录日志,确保即使一个任务失败也不会影响其他任务的执行。通过这种方式,你可以确保任务的可靠执行,即使某个任务失败,其他任务也能继续执行。
log.info("this period job need execute task:{}",summaryJobDOS.stream().map(summaryJobDO->Long.toString(summaryJobDO::getId())));
你在日志记录中尝试将 summaryJobDOS 列表中的每个 SnapshotSummaryJobDO 对象的 id 转换为字符串并记录下来。但你的代码中有些语法错误,需要进行修正。
以下是修正后的代码,使用 Java 8 的 Stream 和 Collectors.joining 方法将 summaryJobDOS 列表中的每个 id 转换为字符串并连接成一个字符串记录到日志中:
import java.util.stream.Collectors;
log.info("This period job needs to execute tasks: {}",
summaryJobDOS.stream()
.map(summaryJobDO -> Long.toString(summaryJobDO.getId()))
.collect(Collectors.joining(", ")));
map 方法:使用 map 方法将每个 SnapshotSummaryJobDO 对象的 id 转换为字符串。Collectors.joining 方法:使用 Collectors.joining(", ") 方法将所有字符串连接成一个字符串,字符串之间用逗号和空格分隔。以下是完整的代码示例:
@Component
@Slf4j
public class RewardSummaryTask implements SimpleJob {
@Autowired
private SnapshotSummaryService snapshotSummaryService;
@Autowired
private RewardSummaryService rewardSummaryService;
@Override
public void execute(ShardingContext context) {
// 获取需要汇总的任务列表
List<SnapshotSummaryJobDO> summaryJobDOS = snapshotSummaryService.getSnapshotSummaryTasks();
// 记录日志
log.info("This period job needs to execute tasks: {}",
summaryJobDOS.stream()
.map(summaryJobDO -> Long.toString(summaryJobDO.getId()))
.collect(Collectors.joining(", ")));
// 遍历需要汇总的任务
for (SnapshotSummaryJobDO snapshotSummaryJobDO : summaryJobDOS) {
String poolId = snapshotSummaryJobDO.getPoolId();
// 从 snapshot 表汇总数据到 user_reward_summary
try {
rewardSummaryService.snapshotToSummary(poolId, snapshotSummaryJobDO.getSummaryStage());
snapshotSummaryService.updateTaskFinish(snapshotSummaryJobDO);
} catch (Exception e) {
log.error("RewardSummaryTask.error.task:{}", snapshotSummaryJobDO.getId(), e);
}
}
}
}
id 列表。summaryJobDOS 列表,执行每个任务,并在发生异常时记录错误日志。通过这种方式,你可以清晰地记录需要执行的任务列表,并确保在任务执行过程中发生异常时能够记录详细的错误信息。
上面这个方案mysql里用limit offset有没有性能问题
使用 LIMIT OFFSET 进行分页查询时,随着偏移量 (OFFSET) 的增大,性能可能会下降。这是因为 MySQL 需要扫描并跳过 OFFSET 之前的所有行,即使这些行不需要返回。这会导致扫描大量行,从而影响查询性能。
OFFSET 会导致 MySQL 扫描并跳过 OFFSET 之前的所有行。对于大表,这可能会导致大量的磁盘 I/O 操作和 CPU 开销。为了解决 LIMIT OFFSET 带来的性能问题,可以考虑以下优化方案:
OFFSET。假设你有一个自增主键 id,可以使用主键进行分页查询,而不是使用 OFFSET。
SELECT * FROM gem_staking.user_staking_hold_snapshot WHERE cal_state = 0 LIMIT 1000 OFFSET 20000;
使用主键进行分页:
SELECT * FROM gem_staking.user_staking_hold_snapshot WHERE cal_state = 0 AND id > ? ORDER BY id ASC LIMIT 1000;
在应用程序中,通过逐步增加主键的值来实现分页:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
@Component
public class RewardCalculator {
@Autowired
private JdbcTemplate jdbcTemplate;
private static final int BATCH_SIZE = 1000;
public void calculateAndInsertRewards() {
long lastId = 0;
List<UserRewardSummary> userRewardSummaries;
do {
userRewardSummaries = fetchUserRewardSummaries(lastId, BATCH_SIZE);
if (!userRewardSummaries.isEmpty()) {
// 处理数据
processRewards(userRewardSummaries);
// 更新最后处理的 ID
lastId = userRewardSummaries.get(userRewardSummaries.size() - 1).getId();
}
} while (!userRewardSummaries.isEmpty());
}
private List<UserRewardSummary> fetchUserRewardSummaries(long lastId, int batchSize) {
List<UserRewardSummary> summaries = new ArrayList<>();
String query = "SELECT * FROM gem_staking.user_staking_hold_snapshot WHERE cal_state = 0 AND id > ? ORDER BY id ASC LIMIT ?";
jdbcTemplate.query(query, new Object[]{lastId, batchSize}, (rs, rowNum) -> {
UserRewardSummary summary = new UserRewardSummary();
summary.setId(rs.getLong("id"));
summary.setUserId(rs.getString("user_id"));
summary.setPoolId(rs.getString("pool_id"));
summary.setStakingHoldToken(rs.getString("staking_hold_token"));
summary.setStakingHoldAmountAvg(rs.getBigDecimal("staking_hold_amount"));
summary.setEarnToken(rs.getString("earn_token"));
summary.setSummaryStage(rs.getInt("summary_stage"));
summary.setCalState(rs.getInt("cal_state"));
summary.setCreatedAt(rs.getTimestamp("created_at"));
summary.setUpdatedAt(rs.getTimestamp("updated_at"));
summaries.add(summary);
return summary;
});
return summaries;
}
private void processRewards(List<UserRewardSummary> userRewardSummaries) {
// 处理数据的逻辑
}
}
id 进行分页,而不是使用 OFFSET。这样可以避免扫描和跳过大量不需要的行。通过这种方式,可以显著提高大数据量分页查询的性能,避免 LIMIT OFFSET 带来的性能问题。在处理大量数据时,基于主键或唯一索引的分页查询是一种常见且有效的优化方案。
@Override
public void execute(ShardingContext context) {
//总共分片多少
int totalCount = context.getShardingTotalCount();
//当前节点是几号分片
int shardingItem = context.getShardingItem();
//遍历需要计算收益的任务
List<SummaryRewardJobDO> rewardJobDOS = summaryRewardJobService.getSummaryRewardJob();
if(CollectionUtils.isNotEmpty(rewardJobDOS)) {
log.info("this period job need execute task:{}", rewardJobDOS.stream()
.map(summaryJobDO -> Long.toString(summaryJobDO.getId()))
.collect(Collectors.joining(", ")));
for (SummaryRewardJobDO rewardJobDO : rewardJobDOS) {
long lastId = 0;
List<UserRewardSummaryDO> userRewardSummaries;
StakingCampaignPoolDO stakingCampaignPoolDO = campaignPoolService.getPoolInfoByPoolId(rewardJobDO.getPoolId());
GemStakingCampaignDO stakingCampaignDO = gemPoolCampaignService.getCampaignByCampaignId(stakingCampaignPoolDO.getCampaignId());
//把总额查出来
BigDecimal sumStakingAmount = userRewardSummaryMapper.getStageTotalReward(rewardJobDO.getPoolId(),rewardJobDO.getRewardStage());
AtomicBoolean taskFinish;
do {
userRewardSummaries = fetchUserRewardSummaries(rewardJobDO.getPoolId(),lastId,rewardJobDO.getRewardStage(),BATCH_SIZE,shardingItem,totalCount);
if (!userRewardSummaries.isEmpty()) {
List<UserRewardSummaryDO> finalUserRewardSummaries = userRewardSummaries;
summaryRewardJobExecutor.submit(() -> {
//计算奖励获取收益对象
List<UserStakingEarnDO> rewards = calculateRewards(finalUserRewardSummaries,stakingCampaignPoolDO,sumStakingAmount,stakingCampaignDO);
//入收益表
insertRewards(rewards);
//入收益表后说明已经完成计算,更新汇总记录的计算状态为完成
updateSummary2CalFinish(finalUserRewardSummaries,rewards);
});
lastId = userRewardSummaries.get(userRewardSummaries.size() - 1).getId();
}
} while (!userRewardSummaries.isEmpty());
//更新job状态
}
}
}。//计算奖励获取收益对象
List<UserStakingEarnDO> rewards = calculateRewards(finalUserRewardSummaries,stakingCampaignPoolDO,sumStakingAmount,stakingCampaignDO);
//入收益表
insertRewards(rewards);
//入收益表后说明已经完成计算,更新汇总记录的计算状态为完成
updateSummary2CalFinish(finalUserRewardSummaries,rewards);这三个能否放到一个事务里
要将多个操作放在一个事务中,确保它们要么全部成功,要么全部失败回滚,可以使用 Spring 的事务管理功能。你可以使用 @Transactional 注解来实现这一点。
以下是将计算奖励、插入收益表和更新汇总记录状态这三个操作放在一个事务中的方法。
创建一个新的 Service 方法:将这三个操作放在一个新的 Service 方法中,并使用 @Transactional 注解。
在原来的任务执行逻辑中调用这个新的 Service 方法。
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
public class RewardService {
@Autowired
private UserRewardSummaryMapper userRewardSummaryMapper;
@Autowired
private UserStakingEarnMapper userStakingEarnMapper;
@Transactional
public void processRewardsTransaction(List<UserRewardSummaryDO> userRewardSummaries,
StakingCampaignPoolDO stakingCampaignPoolDO,
BigDecimal sumStakingAmount,
GemStakingCampaignDO stakingCampaignDO) {
// 计算奖励获取收益对象
List<UserStakingEarnDO> rewards = calculateRewards(userRewardSummaries, stakingCampaignPoolDO, sumStakingAmount, stakingCampaignDO);
// 入收益表
insertRewards(rewards);
// 入收益表后说明已经完成计算,更新汇总记录的计算状态为完成
updateSummary2CalFinish(userRewardSummaries, rewards);
}
private List<UserStakingEarnDO> calculateRewards(List<UserRewardSummaryDO> userRewardSummaries,
StakingCampaignPoolDO stakingCampaignPoolDO,
BigDecimal sumStakingAmount,
GemStakingCampaignDO stakingCampaignDO) {
// 计算奖励逻辑
return new ArrayList<>();
}
private void insertRewards(List<UserStakingEarnDO> rewards) {
// 插入收益表逻辑
}
private void updateSummary2CalFinish(List<UserRewardSummaryDO> userRewardSummaries, List<UserStakingEarnDO> rewards) {
// 更新汇总记录的计算状态为完成的逻辑
}
}
在原来的任务执行逻辑中调用新的 Service 方法:
@Component
@Slf4j
public class RewardSummaryTask implements SimpleJob {
@Autowired
private SnapshotSummaryService snapshotSummaryService;
@Autowired
private RewardSummaryService rewardSummaryService;
@Autowired
private RewardService rewardService;
@Override
public void execute(ShardingContext context) {
//总共分片多少
int totalCount = context.getShardingTotalCount();
//当前节点是几号分片
int shardingItem = context.getShardingItem();
//遍历需要计算收益的任务
List<SummaryRewardJobDO> rewardJobDOS = summaryRewardJobService.getSummaryRewardJob();
if(CollectionUtils.isNotEmpty(rewardJobDOS)) {
log.info("This period job needs to execute tasks:{}", rewardJobDOS.stream()
.map(summaryJobDO -> Long.toString(summaryJobDO.getId()))
.collect(Collectors.joining(", ")));
for (SummaryRewardJobDO rewardJobDO : rewardJobDOS) {
long lastId = 0;
List<UserRewardSummaryDO> userRewardSummaries;
StakingCampaignPoolDO stakingCampaignPoolDO = campaignPoolService.getPoolInfoByPoolId(rewardJobDO.getPoolId());
GemStakingCampaignDO stakingCampaignDO = gemPoolCampaignService.getCampaignByCampaignId(stakingCampaignPoolDO.getCampaignId());
//把总额查出来
BigDecimal sumStakingAmount = userRewardSummaryMapper.getStageTotalReward(rewardJobDO.getPoolId(),rewardJobDO.getRewardStage());
AtomicBoolean taskFinish = new AtomicBoolean(false);
do {
userRewardSummaries = fetchUserRewardSummaries(rewardJobDO.getPoolId(),lastId,rewardJobDO.getRewardStage(),BATCH_SIZE,shardingItem,totalCount);
if (!userRewardSummaries.isEmpty()) {
List<UserRewardSummaryDO> finalUserRewardSummaries = userRewardSummaries;
summaryRewardJobExecutor.submit(() -> {
// 将计算奖励、插入收益表和更新汇总记录状态放在一个事务中
rewardService.processRewardsTransaction(finalUserRewardSummaries, stakingCampaignPoolDO, sumStakingAmount, stakingCampaignDO);
});
lastId = userRewardSummaries.get(userRewardSummaries.size() - 1).getId();
}
} while (!userRewardSummaries.isEmpty());
//更新job状态
}
}
}
}
RewardService 中创建一个新的 processRewardsTransaction 方法,并使用 @Transactional 注解,确保该方法内的操作具有事务性。RewardService 的 processRewardsTransaction 方法,将计算奖励、插入收益表和更新汇总记录状态这三个操作放在一个事务中。通过将计算奖励、插入收益表和更新汇总记录状态这三个操作放在一个带有 @Transactional 注解的方法中,可以确保这些操作要么全部成功,要么全部回滚,从而保证数据的一致性。同时,这种方式也能够在任务执行过程中处理事务的管理和异常处理,确保在一个任务失败时不影响其他任务的执行。
// 入收益表后说明已经完成计算,更新汇总记录的计算状态为完成
updateSummary2CalFinish(userRewardSummaries, rewards);这里mapper.xml的批量update怎么写
在 MyBatis 中进行批量更新可以通过 foreach 元素来实现。foreach 元素允许你在 SQL 语句中动态地生成多个更新语句,从而实现批量更新。
假设你有一个包含用户奖励信息的列表 userRewardSummaries,你希望根据这些信息更新汇总记录的计算状态。以下是如何在 MyBatis 的 mapper.xml 中实现批量更新的示例。
首先,在你的 Mapper 接口中定义批量更新的方法:
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@Mapper
public interface UserRewardSummaryMapper {
void updateSummary2CalFinish(@Param("userRewardSummaries") List<UserRewardSummaryDO> userRewardSummaries);
}
然后,在 mapper.xml 文件中定义批量更新的 SQL 语句:
<mapper namespace="com.example.mapper.UserRewardSummaryMapper">
<!-- 批量更新汇总记录的计算状态 -->
<update id="updateSummary2CalFinish">
<foreach collection="userRewardSummaries" item="item" index="index" separator=";">
UPDATE gem_staking.user_reward_summary
SET cal_state = 1
WHERE user_id = #{item.userId}
AND pool_id = #{item.poolId}
AND summary_stage = #{item.summaryStage}
</foreach>
</update>
</mapper>
在你的 Service 类中调用批量更新的方法:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@Service
public class RewardService {
@Autowired
private UserRewardSummaryMapper userRewardSummaryMapper;
@Transactional
public void processRewardsTransaction(List<UserRewardSummaryDO> userRewardSummaries,
StakingCampaignPoolDO stakingCampaignPoolDO,
BigDecimal sumStakingAmount,
GemStakingCampaignDO stakingCampaignDO) {
// 计算奖励获取收益对象
List<UserStakingEarnDO> rewards = calculateRewards(userRewardSummaries, stakingCampaignPoolDO, sumStakingAmount, stakingCampaignDO);
// 入收益表
insertRewards(rewards);
// 入收益表后说明已经完成计算,更新汇总记录的计算状态为完成
userRewardSummaryMapper.updateSummary2CalFinish(userRewardSummaries);
}
private List<UserStakingEarnDO> calculateRewards(List<UserRewardSummaryDO> userRewardSummaries,
StakingCampaignPoolDO stakingCampaignPoolDO,
BigDecimal sumStakingAmount,
GemStakingCampaignDO stakingCampaignDO) {
// 计算奖励逻辑
return new ArrayList<>();
}
private void insertRewards(List<UserStakingEarnDO> rewards) {
// 插入收益表逻辑
}
}
foreach 元素:在 mapper.xml 文件中使用 foreach 元素生成多个 UPDATE 语句,实现批量更新。foreach 元素遍历 userRewardSummaries 列表,每个元素生成一个 UPDATE 语句。updateSummary2CalFinish 方法,并使用 @Param 注解传递参数列表。updateSummary2CalFinish 方法,传递需要更新的 userRewardSummaries 列表。通过这种方式,你可以实现批量更新汇总记录的计算状态,确保在入收益表后更新汇总记录的状态为完成。
数据库是mysql,stakingStartTim数据类型是datetime,数据库数据类型是stakingEndTime,表里存储的值是2024-06-12 17:00:00,但是java程序打印出来是stakingStartTime=Thu Jan 01 17:00:00 CST 1970
你的问题可能是由于时区或数据类型转换的问题导致的。以下是一些检查和解决方案:
确保 stakingStartTime 和 stakingEndTime 字段在数据库中的类型是 DATETIME,并且存储格式正确。
确保数据库连接配置中,时区设置正确。可以在数据库连接 URL 中指定时区。
spring.datasource.url=jdbc:mysql://localhost:3306/your_database?serverTimezone=Asia/Shanghai
确保 Java 类中对应的字段类型是 java.util.Date 或 java.time.LocalDateTime,推荐使用 java.time.LocalDateTime,因为它更现代化且更容易处理时间和日期。
import java.time.LocalDateTime;
public class YourEntity {
private LocalDateTime stakingStartTime;
private LocalDateTime stakingEndTime;
// Getters and Setters
public LocalDateTime getStakingStartTime() {
return stakingStartTime;
}
public void setStakingStartTime(LocalDateTime stakingStartTime) {
this.stakingStartTime = stakingStartTime;
}
public LocalDateTime getStakingEndTime() {
return stakingEndTime;
}
public void setStakingEndTime(LocalDateTime stakingEndTime) {
this.stakingEndTime = stakingEndTime;
}
}
如果你使用的是 MyBatis,确保在 MyBatis 映射文件中正确配置了日期时间类型的映射。
<resultMap id="yourEntityResultMap" type="com.example.YourEntity">
<result property="stakingStartTime" column="staking_start_time" jdbcType="TIMESTAMP" javaType="java.time.LocalDateTime"/>
<result property="stakingEndTime" column="staking_end_time" jdbcType="TIMESTAMP" javaType="java.time.LocalDateTime"/>
</resultMap>
<select id="selectYourEntity" resultMap="yourEntityResultMap">
SELECT staking_start_time, staking_end_time
FROM your_table
WHERE id = #{id}
</select>
确保在获取和输出数据的逻辑中没有误操作。例如,确保没有错误地将日期时间类型转换为其他类型。
@Autowired
private YourEntityMapper yourEntityMapper;
public void printStakingTimes(int id) {
YourEntity entity = yourEntityMapper.selectYourEntity(id);
System.out.println("stakingStartTime=" + entity.getStakingStartTime());
System.out.println("stakingEndTime=" + entity.getStakingEndTime());
}
确保你的应用程序和数据库在相同的时区。可以在 JVM 启动参数中指定默认时区:
-Duser.timezone=Asia/Shanghai
通过检查和配置以上几个方面,你应该能够解决日期时间字段在数据库和 Java 程序之间转换的问题。确保时区设置一致,数据类型正确,并且在获取和输出数据时没有误操作。
date和date time是什么区别
在 MySQL 中,DATE 和 DATETIME 是两种不同的数据类型,用于存储日期和时间信息。它们之间有一些关键区别:
DATEDATE 类型仅存储日期部分(年、月、日)。YYYY-MM-DD。1000-01-01 到 9999-12-31。2024-06-12。DATETIMEDATETIME 类型存储日期和时间部分(年、月、日、时、分、秒)。YYYY-MM-DD HH:MM:SS。1000-01-01 00:00:00 到 9999-12-31 23:59:59。2024-06-12 17:00:00。DATE:适用于只需要存储日期信息的场景,如生日、注册日期等。DATETIME:适用于需要存储详细时间信息的场景,如订单创建时间、事件发生时间等。CREATE TABLE example_table (
id INT AUTO_INCREMENT PRIMARY KEY,
event_date DATE NOT NULL,
event_datetime DATETIME NOT NULL
);
INSERT INTO example_table (event_date, event_datetime) VALUES ('2024-06-12', '2024-06-12 17:00:00');
SELECT event_date, event_datetime FROM example_table;
在 Java 中,处理 DATE 和 DATETIME 类型的数据时,一般使用以下数据类型:
DATE:java.sql.Date 或 java.time.LocalDate。DATETIME:java.sql.Timestamp 或 java.time.LocalDateTime。import java.time.LocalDate;
import java.time.LocalDateTime;
public class ExampleEntity {
private LocalDate eventDate;
private LocalDateTime eventDatetime;
// Getters and Setters
public LocalDate getEventDate() {
return eventDate;
}
public void setEventDate(LocalDate eventDate) {
this.eventDate = eventDate;
}
public LocalDateTime getEventDatetime() {
return eventDatetime;
}
public void setEventDatetime(LocalDateTime eventDatetime) {
this.eventDatetime = eventDatetime;
}
}
<resultMap id="exampleEntityResultMap" type="com.example.ExampleEntity">
<result property="eventDate" column="event_date" javaType="java.time.LocalDate" jdbcType="DATE"/>
<result property="eventDatetime" column="event_datetime" javaType="java.time.LocalDateTime" jdbcType="TIMESTAMP"/>
</resultMap>
<select id="selectExampleEntity" resultMap="exampleEntityResultMap">
SELECT event_date, event_datetime
FROM example_table
WHERE id = #{id}
</select>
DATE:仅存储日期信息,格式为 YYYY-MM-DD。DATETIME:存储日期和时间信息,格式为 YYYY-MM-DD HH:MM:SS。DATE 和 DATETIME 数据。通过了解和正确使用 DATE 和 DATETIME 类型,可以更好地管理和处理数据库中的日期和时间信息。
024-06-15 17:06:15.266 WARN [http-nio-10241-exec-1] o.s.b.a.e.ElasticsearchRestHealthIndicator [GEM-STAKING-FRONT,gem-staking-front-7f779567c4-t6mns,10.40.91.53,,c8cc03233e312e1512bdd68448fc4ae3,71825758bacee646] Elasticsearch health check failed
java.net.ConnectException: Connection refused
at org.elasticsearch.client.RestClient.extractAndWrapCause(RestClient.java:823)
at org.elasticsearch.client.RestClient.performRequest(RestClient.java:248)
at org.elasticsearch.client.RestClient.performRequest(RestClient.java:235)
at org.springframework.boot.actuate.elasticsearch.ElasticsearchRestHealthIndicator.doHealthCheck(ElasticsearchRestHealthIndicator.java:60)
at org.springframework.boot.actuate.health.AbstractHealthIndicator.health(AbstractHealthIndicator.java:82)
at org.springframework.boot.actuate.health.HealthIndicator.getHealth(HealthIndicator.java:37)
at org.springframework.boot.actuate.health.HealthEndpointWebExtension.getHealth(HealthEndpointWebExtension.java:85)
at org.springframework.boot.actuate.health.HealthEndpointWebExtension.getHealth(HealthEndpointWebExtension.java:44)
at org.springframework.boot.actuate.health.HealthEndpointSupport.getContribution(HealthEndpointSupport.java:99)
at org.springframework.boot.actuate.health.HealthEndpointSupport.getAggregateHealth(HealthEndpointSupport.java:110)
at org.springframework.boot.actuate.health.HealthEndpointSupport.getContribution(HealthEndpointSupport.java:96)
at org.springframework.boot.actuate.health.HealthEndpointSupport.getHealth(HealthEndpointSupport.java:74)
at org.springframework.boot.actuate.health.HealthEndpointSupport.getHealth(HealthEndpointSupport.java:61)
at org.springframework.boot.actuate.health.HealthEndpointWebExtension.health(HealthEndpointWebExtension.java:71)
at org.springframework.boot.actuate.health.HealthEndpointWebExtension.health(HealthEndpointWebExtension.java:60)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at org.springframework.util.ReflectionUtils.invokeMethod(ReflectionUtils.java:282)
at org.springframework.boot.actuate.endpoint.invoke.reflect.ReflectiveOperationInvoker.invoke(ReflectiveOperationInvoker.java:77)
at org.springframework.boot.actuate.endpoint.annotation.AbstractDiscoveredOperation.invoke(AbstractDiscoveredOperation.java:60)
at org.springframework.boot.actuate.endpoint.web.servlet.AbstractWebMvcEndpointHandlerMappingOperationHandler.handle(AbstractWebMvcEndpointHandlerMapping.java:388)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at org.springframework.web.method.support.InvocableHandlerMethod.doInvoke(InvocableHandlerMethod.java:190)
at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:138)
at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:105)
at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:878)
at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:792)
at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:87)
at org.springframework.boot.actuate.autoconfigure.web.servlet.CompositeHandlerAdapter.handle(CompositeHandlerAdapter.java:58)
at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:1043)
at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:943)
at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:1006)
at org.springframework.web.servlet.FrameworkServlet.doGet(FrameworkServlet.java:898)
at javax.servlet.http.HttpServlet.service(HttpServlet.java:529)
at org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:883)
at javax.servlet.http.HttpServlet.service(HttpServlet.java:623)
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:209)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:153)
at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:168)
at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:90)
at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:481)
at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:130)
at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:93)
at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:74)
at org.apache.catalina.valves.AbstractAccessLogValve.invoke(AbstractAccessLogValve.java:670)
at org.apache.catalina.valves.RemoteIpValve.invoke(RemoteIpValve.java:765)
at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:342)
at org.apache.coyote.http11.Http11Processor.service(Http11Processor.java:390)
at org.apache.coyote.AbstractProcessorLight.process(AbstractProcessorLight.java:63)
at org.apache.coyote.AbstractProtocolSocketProcessor.doRun(NioEndpoint.java:1794)
at org.apache.tomcat.util.net.SocketProcessorBase.run(SocketProcessorBase.java:52)
at org.apache.tomcat.util.threads.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1191)
at org.apache.tomcat.util.threads.ThreadPoolExecutorWrappingRunnable.run(TaskThread.java:61)
at java.lang.Thread.run(Thread.java:748)
Caused by: java.net.ConnectException: Connection refused
at sun.nio.ch.SocketChannelImpl.checkConnect(Native Method)
at sun.nio.ch.SocketChannelImpl.finishConnect(SocketChannelImpl.java:717)
at org.apache.http.impl.nio.reactor.DefaultConnectingIOReactor.processEvent(DefaultConnectingIOReactor.java:174)
at org.apache.http.impl.nio.reactor.DefaultConnectingIOReactor.processEvents(DefaultConnectingIOReactor.java:148)
at org.apache.http.impl.nio.reactor.AbstractMultiworkerIOReactor.execute(AbstractMultiworkerIOReactor.java:351)
at org.apache.http.impl.nio.conn.PoolingNHttpClientConnectionManager.execute(PoolingNHttpClientConnectionManager.java:221)
at org.apache.http.impl.nio.client.CloseableHttpAsyncClientBase$1.run(CloseableHttpAsyncClientBase.java:64)
... 1 common frames omitted
从你的日志输出来看,问题是你的 Spring Boot 应用程序无法连接到 Elasticsearch。这种情况通常是由于以下原因之一:
确保 Elasticsearch 服务已启动并正在运行。你可以通过以下命令检查其状态:
sudo service elasticsearch status
或者,如果你使用的是 Docker:
docker ps
查看 Elasticsearch 服务的日志,看是否有任何错误或警告:
sudo journalctl -u elasticsearch
或者,如果你使用的是 Docker:
docker logs <elasticsearch_container_id>
检查你的 Spring Boot 配置文件(application.properties 或 application.yml),确保配置了正确的 Elasticsearch 连接参数。
spring.elasticsearch.rest.uris=http://localhost:9200
spring:
elasticsearch:
rest:
uris: http://localhost:9200
确保你的应用程序所在的服务器可以访问 Elasticsearch 服务。你可以使用 curl 命令进行简单的测试:
curl http://localhost:9200
如果 Elasticsearch 服务运行在远程服务器上,请确保你使用了正确的 IP 地址或主机名,并且中间没有防火墙或网络策略阻止访问。
确保没有防火墙或网络策略阻止应用程序访问 Elasticsearch 服务。你可以暂时禁用防火墙进行测试:
sudo ufw disable
假设你的 Elasticsearch 服务运行在本地,以下是一个完整的 application.properties 配置示例:
spring.elasticsearch.rest.uris=http://localhost:9200
如果你的 Elasticsearch 服务运行在远程服务器上:
spring.elasticsearch.rest.uris=http://<elasticsearch_server_ip>:9200
完成上述检查和配置后,重新启动你的 Spring Boot 应用程序:
mvn spring-boot:run
或者,如果你使用的是 Docker:
docker-compose up --build
通过上述步骤,你应该能够排查并解决 Spring Boot 应用程序无法连接到 Elasticsearch 服务的问题。确保 Elasticsearch 服务运行正常,配置正确,并且网络畅通。
Caused by: org.apache.ibatis.reflection.ReflectionException: There is no getter for property named 'oredCriteria' in 'class com.kucoin.gemstakingfront.common.dal.dataobject.UserStakingEarnDOExample$Criteria'。package com.kucoin.gemstakingfront.common.dal.dataobject;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class UserStakingEarnDOExample {
protected String orderByClause;
protected boolean distinct;
protected List<Criteria> oredCriteria;
public UserStakingEarnDOExample() {
oredCriteria = new ArrayList<Criteria>();
}
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
public String getOrderByClause() {
return orderByClause;
}
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
public boolean isDistinct() {
return distinct;
}
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
/**
* This class was generated by MyBatis Generator.
* This class corresponds to the database table user_staking_earn
*/
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
public boolean isValid() {
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
return criteria;
}
public List<Criterion> getCriteria() {
return criteria;
}
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value));
}
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value1, value2));
}
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Long value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Long value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Long value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Long value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Long value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Long value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Long> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Long> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Long value1, Long value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Long value1, Long value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andBusIdIsNull() {
addCriterion("bus_id is null");
return (Criteria) this;
}
public Criteria andBusIdIsNotNull() {
addCriterion("bus_id is not null");
return (Criteria) this;
}
public Criteria andBusIdEqualTo(String value) {
addCriterion("bus_id =", value, "busId");
return (Criteria) this;
}
public Criteria andBusIdNotEqualTo(String value) {
addCriterion("bus_id <>", value, "busId");
return (Criteria) this;
}
public Criteria andBusIdGreaterThan(String value) {
addCriterion("bus_id >", value, "busId");
return (Criteria) this;
}
public Criteria andBusIdGreaterThanOrEqualTo(String value) {
addCriterion("bus_id >=", value, "busId");
return (Criteria) this;
}
public Criteria andBusIdLessThan(String value) {
addCriterion("bus_id <", value, "busId");
return (Criteria) this;
}
public Criteria andBusIdLessThanOrEqualTo(String value) {
addCriterion("bus_id <=", value, "busId");
return (Criteria) this;
}
public Criteria andBusIdLike(String value) {
addCriterion("bus_id like", value, "busId");
return (Criteria) this;
}
public Criteria andBusIdNotLike(String value) {
addCriterion("bus_id not like", value, "busId");
return (Criteria) this;
}
public Criteria andBusIdIn(List<String> values) {
addCriterion("bus_id in", values, "busId");
return (Criteria) this;
}
public Criteria andBusIdNotIn(List<String> values) {
addCriterion("bus_id not in", values, "busId");
return (Criteria) this;
}
public Criteria andBusIdBetween(String value1, String value2) {
addCriterion("bus_id between", value1, value2, "busId");
return (Criteria) this;
}
public Criteria andBusIdNotBetween(String value1, String value2) {
addCriterion("bus_id not between", value1, value2, "busId");
return (Criteria) this;
}
public Criteria andUserIdIsNull() {
addCriterion("user_id is null");
return (Criteria) this;
}
public Criteria andUserIdIsNotNull() {
addCriterion("user_id is not null");
return (Criteria) this;
}
public Criteria andUserIdEqualTo(String value) {
addCriterion("user_id =", value, "userId");
return (Criteria) this;
}
public Criteria andUserIdNotEqualTo(String value) {
addCriterion("user_id <>", value, "userId");
return (Criteria) this;
}
public Criteria andUserIdGreaterThan(String value) {
addCriterion("user_id >", value, "userId");
return (Criteria) this;
}
public Criteria andUserIdGreaterThanOrEqualTo(String value) {
addCriterion("user_id >=", value, "userId");
return (Criteria) this;
}
public Criteria andUserIdLessThan(String value) {
addCriterion("user_id <", value, "userId");
return (Criteria) this;
}
public Criteria andUserIdLessThanOrEqualTo(String value) {
addCriterion("user_id <=", value, "userId");
return (Criteria) this;
}
public Criteria andUserIdLike(String value) {
addCriterion("user_id like", value, "userId");
return (Criteria) this;
}
public Criteria andUserIdNotLike(String value) {
addCriterion("user_id not like", value, "userId");
return (Criteria) this;
}
public Criteria andUserIdIn(List<String> values) {
addCriterion("user_id in", values, "userId");
return (Criteria) this;
}
public Criteria andUserIdNotIn(List<String> values) {
addCriterion("user_id not in", values, "userId");
return (Criteria) this;
}
public Criteria andUserIdBetween(String value1, String value2) {
addCriterion("user_id between", value1, value2, "userId");
return (Criteria) this;
}
public Criteria andUserIdNotBetween(String value1, String value2) {
addCriterion("user_id not between", value1, value2, "userId");
return (Criteria) this;
}
public Criteria andCampaignIdIsNull() {
addCriterion("campaign_id is null");
return (Criteria) this;
}
public Criteria andCampaignIdIsNotNull() {
addCriterion("campaign_id is not null");
return (Criteria) this;
}
public Criteria andCampaignIdEqualTo(String value) {
addCriterion("campaign_id =", value, "campaignId");
return (Criteria) this;
}
public Criteria andCampaignIdNotEqualTo(String value) {
addCriterion("campaign_id <>", value, "campaignId");
return (Criteria) this;
}
public Criteria andCampaignIdGreaterThan(String value) {
addCriterion("campaign_id >", value, "campaignId");
return (Criteria) this;
}
public Criteria andCampaignIdGreaterThanOrEqualTo(String value) {
addCriterion("campaign_id >=", value, "campaignId");
return (Criteria) this;
}
public Criteria andCampaignIdLessThan(String value) {
addCriterion("campaign_id <", value, "campaignId");
return (Criteria) this;
}
public Criteria andCampaignIdLessThanOrEqualTo(String value) {
addCriterion("campaign_id <=", value, "campaignId");
return (Criteria) this;
}
public Criteria andCampaignIdLike(String value) {
addCriterion("campaign_id like", value, "campaignId");
return (Criteria) this;
}
public Criteria andCampaignIdNotLike(String value) {
addCriterion("campaign_id not like", value, "campaignId");
return (Criteria) this;
}
public Criteria andCampaignIdIn(List<String> values) {
addCriterion("campaign_id in", values, "campaignId");
return (Criteria) this;
}
public Criteria andCampaignIdNotIn(List<String> values) {
addCriterion("campaign_id not in", values, "campaignId");
return (Criteria) this;
}
public Criteria andCampaignIdBetween(String value1, String value2) {
addCriterion("campaign_id between", value1, value2, "campaignId");
return (Criteria) this;
}
public Criteria andCampaignIdNotBetween(String value1, String value2) {
addCriterion("campaign_id not between", value1, value2, "campaignId");
return (Criteria) this;
}
public Criteria andPoolIdIsNull() {
addCriterion("pool_id is null");
return (Criteria) this;
}
public Criteria andPoolIdIsNotNull() {
addCriterion("pool_id is not null");
return (Criteria) this;
}
public Criteria andPoolIdEqualTo(String value) {
addCriterion("pool_id =", value, "poolId");
return (Criteria) this;
}
public Criteria andPoolIdNotEqualTo(String value) {
addCriterion("pool_id <>", value, "poolId");
return (Criteria) this;
}
public Criteria andPoolIdGreaterThan(String value) {
addCriterion("pool_id >", value, "poolId");
return (Criteria) this;
}
public Criteria andPoolIdGreaterThanOrEqualTo(String value) {
addCriterion("pool_id >=", value, "poolId");
return (Criteria) this;
}
public Criteria andPoolIdLessThan(String value) {
addCriterion("pool_id <", value, "poolId");
return (Criteria) this;
}
public Criteria andPoolIdLessThanOrEqualTo(String value) {
addCriterion("pool_id <=", value, "poolId");
return (Criteria) this;
}
public Criteria andPoolIdLike(String value) {
addCriterion("pool_id like", value, "poolId");
return (Criteria) this;
}
public Criteria andPoolIdNotLike(String value) {
addCriterion("pool_id not like", value, "poolId");
return (Criteria) this;
}
public Criteria andPoolIdIn(List<String> values) {
addCriterion("pool_id in", values, "poolId");
return (Criteria) this;
}
public Criteria andPoolIdNotIn(List<String> values) {
addCriterion("pool_id not in", values, "poolId");
return (Criteria) this;
}
public Criteria andPoolIdBetween(String value1, String value2) {
addCriterion("pool_id between", value1, value2, "poolId");
return (Criteria) this;
}
public Criteria andPoolIdNotBetween(String value1, String value2) {
addCriterion("pool_id not between", value1, value2, "poolId");
return (Criteria) this;
}
public Criteria andStakingHoldAmountIsNull() {
addCriterion("staking_hold_amount is null");
return (Criteria) this;
}
public Criteria andStakingHoldAmountIsNotNull() {
addCriterion("staking_hold_amount is not null");
return (Criteria) this;
}
public Criteria andStakingHoldAmountEqualTo(BigDecimal value) {
addCriterion("staking_hold_amount =", value, "stakingHoldAmount");
return (Criteria) this;
}
public Criteria andStakingHoldAmountNotEqualTo(BigDecimal value) {
addCriterion("staking_hold_amount <>", value, "stakingHoldAmount");
return (Criteria) this;
}
public Criteria andStakingHoldAmountGreaterThan(BigDecimal value) {
addCriterion("staking_hold_amount >", value, "stakingHoldAmount");
return (Criteria) this;
}
public Criteria andStakingHoldAmountGreaterThanOrEqualTo(BigDecimal value) {
addCriterion("staking_hold_amount >=", value, "stakingHoldAmount");
return (Criteria) this;
}
public Criteria andStakingHoldAmountLessThan(BigDecimal value) {
addCriterion("staking_hold_amount <", value, "stakingHoldAmount");
return (Criteria) this;
}
public Criteria andStakingHoldAmountLessThanOrEqualTo(BigDecimal value) {
addCriterion("staking_hold_amount <=", value, "stakingHoldAmount");
return (Criteria) this;
}
public Criteria andStakingHoldAmountIn(List<BigDecimal> values) {
addCriterion("staking_hold_amount in", values, "stakingHoldAmount");
return (Criteria) this;
}
public Criteria andStakingHoldAmountNotIn(List<BigDecimal> values) {
addCriterion("staking_hold_amount not in", values, "stakingHoldAmount");
return (Criteria) this;
}
public Criteria andStakingHoldAmountBetween(BigDecimal value1, BigDecimal value2) {
addCriterion("staking_hold_amount between", value1, value2, "stakingHoldAmount");
return (Criteria) this;
}
public Criteria andStakingHoldAmountNotBetween(BigDecimal value1, BigDecimal value2) {
addCriterion("staking_hold_amount not between", value1, value2, "stakingHoldAmount");
return (Criteria) this;
}
public Criteria andEarnAmountIsNull() {
addCriterion("earn_amount is null");
return (Criteria) this;
}
public Criteria andEarnAmountIsNotNull() {
addCriterion("earn_amount is not null");
return (Criteria) this;
}
public Criteria andEarnAmountEqualTo(BigDecimal value) {
addCriterion("earn_amount =", value, "earnAmount");
return (Criteria) this;
}
public Criteria andEarnAmountNotEqualTo(BigDecimal value) {
addCriterion("earn_amount <>", value, "earnAmount");
return (Criteria) this;
}
public Criteria andEarnAmountGreaterThan(BigDecimal value) {
addCriterion("earn_amount >", value, "earnAmount");
return (Criteria) this;
}
public Criteria andEarnAmountGreaterThanOrEqualTo(BigDecimal value) {
addCriterion("earn_amount >=", value, "earnAmount");
return (Criteria) this;
}
public Criteria andEarnAmountLessThan(BigDecimal value) {
addCriterion("earn_amount <", value, "earnAmount");
return (Criteria) this;
}
public Criteria andEarnAmountLessThanOrEqualTo(BigDecimal value) {
addCriterion("earn_amount <=", value, "earnAmount");
return (Criteria) this;
}
public Criteria andEarnAmountIn(List<BigDecimal> values) {
addCriterion("earn_amount in", values, "earnAmount");
return (Criteria) this;
}
public Criteria andEarnAmountNotIn(List<BigDecimal> values) {
addCriterion("earn_amount not in", values, "earnAmount");
return (Criteria) this;
}
public Criteria andEarnAmountBetween(BigDecimal value1, BigDecimal value2) {
addCriterion("earn_amount between", value1, value2, "earnAmount");
return (Criteria) this;
}
public Criteria andEarnAmountNotBetween(BigDecimal value1, BigDecimal value2) {
addCriterion("earn_amount not between", value1, value2, "earnAmount");
return (Criteria) this;
}
public Criteria andEarnTokenIsNull() {
addCriterion("earn_token is null");
return (Criteria) this;
}
public Criteria andEarnTokenIsNotNull() {
addCriterion("earn_token is not null");
return (Criteria) this;
}
public Criteria andEarnTokenEqualTo(String value) {
addCriterion("earn_token =", value, "earnToken");
return (Criteria) this;
}
public Criteria andEarnTokenNotEqualTo(String value) {
addCriterion("earn_token <>", value, "earnToken");
return (Criteria) this;
}
public Criteria andEarnTokenGreaterThan(String value) {
addCriterion("earn_token >", value, "earnToken");
return (Criteria) this;
}
public Criteria andEarnTokenGreaterThanOrEqualTo(String value) {
addCriterion("earn_token >=", value, "earnToken");
return (Criteria) this;
}
public Criteria andEarnTokenLessThan(String value) {
addCriterion("earn_token <", value, "earnToken");
return (Criteria) this;
}
public Criteria andEarnTokenLessThanOrEqualTo(String value) {
addCriterion("earn_token <=", value, "earnToken");
return (Criteria) this;
}
public Criteria andEarnTokenLike(String value) {
addCriterion("earn_token like", value, "earnToken");
return (Criteria) this;
}
public Criteria andEarnTokenNotLike(String value) {
addCriterion("earn_token not like", value, "earnToken");
return (Criteria) this;
}
public Criteria andEarnTokenIn(List<String> values) {
addCriterion("earn_token in", values, "earnToken");
return (Criteria) this;
}
public Criteria andEarnTokenNotIn(List<String> values) {
addCriterion("earn_token not in", values, "earnToken");
return (Criteria) this;
}
public Criteria andEarnTokenBetween(String value1, String value2) {
addCriterion("earn_token between", value1, value2, "earnToken");
return (Criteria) this;
}
public Criteria andEarnTokenNotBetween(String value1, String value2) {
addCriterion("earn_token not between", value1, value2, "earnToken");
return (Criteria) this;
}
public Criteria andEarnTokenLogoIsNull() {
addCriterion("earn_token_logo is null");
return (Criteria) this;
}
public Criteria andEarnTokenLogoIsNotNull() {
addCriterion("earn_token_logo is not null");
return (Criteria) this;
}
public Criteria andEarnTokenLogoEqualTo(String value) {
addCriterion("earn_token_logo =", value, "earnTokenLogo");
return (Criteria) this;
}
public Criteria andEarnTokenLogoNotEqualTo(String value) {
addCriterion("earn_token_logo <>", value, "earnTokenLogo");
return (Criteria) this;
}
public Criteria andEarnTokenLogoGreaterThan(String value) {
addCriterion("earn_token_logo >", value, "earnTokenLogo");
return (Criteria) this;
}
public Criteria andEarnTokenLogoGreaterThanOrEqualTo(String value) {
addCriterion("earn_token_logo >=", value, "earnTokenLogo");
return (Criteria) this;
}
public Criteria andEarnTokenLogoLessThan(String value) {
addCriterion("earn_token_logo <", value, "earnTokenLogo");
return (Criteria) this;
}
public Criteria andEarnTokenLogoLessThanOrEqualTo(String value) {
addCriterion("earn_token_logo <=", value, "earnTokenLogo");
return (Criteria) this;
}
public Criteria andEarnTokenLogoLike(String value) {
addCriterion("earn_token_logo like", value, "earnTokenLogo");
return (Criteria) this;
}
public Criteria andEarnTokenLogoNotLike(String value) {
addCriterion("earn_token_logo not like", value, "earnTokenLogo");
return (Criteria) this;
}
public Criteria andEarnTokenLogoIn(List<String> values) {
addCriterion("earn_token_logo in", values, "earnTokenLogo");
return (Criteria) this;
}
public Criteria andEarnTokenLogoNotIn(List<String> values) {
addCriterion("earn_token_logo not in", values, "earnTokenLogo");
return (Criteria) this;
}
public Criteria andEarnTokenLogoBetween(String value1, String value2) {
addCriterion("earn_token_logo between", value1, value2, "earnTokenLogo");
return (Criteria) this;
}
public Criteria andEarnTokenLogoNotBetween(String value1, String value2) {
addCriterion("earn_token_logo not between", value1, value2, "earnTokenLogo");
return (Criteria) this;
}
public Criteria andStakingTokenIsNull() {
addCriterion("staking_token is null");
return (Criteria) this;
}
public Criteria andStakingTokenIsNotNull() {
addCriterion("staking_token is not null");
return (Criteria) this;
}
public Criteria andStakingTokenEqualTo(String value) {
addCriterion("staking_token =", value, "stakingToken");
return (Criteria) this;
}
public Criteria andStakingTokenNotEqualTo(String value) {
addCriterion("staking_token <>", value, "stakingToken");
return (Criteria) this;
}
public Criteria andStakingTokenGreaterThan(String value) {
addCriterion("staking_token >", value, "stakingToken");
return (Criteria) this;
}
public Criteria andStakingTokenGreaterThanOrEqualTo(String value) {
addCriterion("staking_token >=", value, "stakingToken");
return (Criteria) this;
}
public Criteria andStakingTokenLessThan(String value) {
addCriterion("staking_token <", value, "stakingToken");
return (Criteria) this;
}
public Criteria andStakingTokenLessThanOrEqualTo(String value) {
addCriterion("staking_token <=", value, "stakingToken");
return (Criteria) this;
}
public Criteria andStakingTokenLike(String value) {
addCriterion("staking_token like", value, "stakingToken");
return (Criteria) this;
}
public Criteria andStakingTokenNotLike(String value) {
addCriterion("staking_token not like", value, "stakingToken");
return (Criteria) this;
}
public Criteria andStakingTokenIn(List<String> values) {
addCriterion("staking_token in", values, "stakingToken");
return (Criteria) this;
}
public Criteria andStakingTokenNotIn(List<String> values) {
addCriterion("staking_token not in", values, "stakingToken");
return (Criteria) this;
}
public Criteria andStakingTokenBetween(String value1, String value2) {
addCriterion("staking_token between", value1, value2, "stakingToken");
return (Criteria) this;
}
public Criteria andStakingTokenNotBetween(String value1, String value2) {
addCriterion("staking_token not between", value1, value2, "stakingToken");
return (Criteria) this;
}
public Criteria andStakingTokenLogoIsNull() {
addCriterion("staking_token_logo is null");
return (Criteria) this;
}
public Criteria andStakingTokenLogoIsNotNull() {
addCriterion("staking_token_logo is not null");
return (Criteria) this;
}
public Criteria andStakingTokenLogoEqualTo(String value) {
addCriterion("staking_token_logo =", value, "stakingTokenLogo");
return (Criteria) this;
}
public Criteria andStakingTokenLogoNotEqualTo(String value) {
addCriterion("staking_token_logo <>", value, "stakingTokenLogo");
return (Criteria) this;
}
public Criteria andStakingTokenLogoGreaterThan(String value) {
addCriterion("staking_token_logo >", value, "stakingTokenLogo");
return (Criteria) this;
}
public Criteria andStakingTokenLogoGreaterThanOrEqualTo(String value) {
addCriterion("staking_token_logo >=", value, "stakingTokenLogo");
return (Criteria) this;
}
public Criteria andStakingTokenLogoLessThan(String value) {
addCriterion("staking_token_logo <", value, "stakingTokenLogo");
return (Criteria) this;
}
public Criteria andStakingTokenLogoLessThanOrEqualTo(String value) {
addCriterion("staking_token_logo <=", value, "stakingTokenLogo");
return (Criteria) this;
}
public Criteria andStakingTokenLogoLike(String value) {
addCriterion("staking_token_logo like", value, "stakingTokenLogo");
return (Criteria) this;
}
public Criteria andStakingTokenLogoNotLike(String value) {
addCriterion("staking_token_logo not like", value, "stakingTokenLogo");
return (Criteria) this;
}
public Criteria andStakingTokenLogoIn(List<String> values) {
addCriterion("staking_token_logo in", values, "stakingTokenLogo");
return (Criteria) this;
}
public Criteria andStakingTokenLogoNotIn(List<String> values) {
addCriterion("staking_token_logo not in", values, "stakingTokenLogo");
return (Criteria) this;
}
public Criteria andStakingTokenLogoBetween(String value1, String value2) {
addCriterion("staking_token_logo between", value1, value2, "stakingTokenLogo");
return (Criteria) this;
}
public Criteria andStakingTokenLogoNotBetween(String value1, String value2) {
addCriterion("staking_token_logo not between", value1, value2, "stakingTokenLogo");
return (Criteria) this;
}
public Criteria andEarnStateIsNull() {
addCriterion("earn_state is null");
return (Criteria) this;
}
public Criteria andEarnStateIsNotNull() {
addCriterion("earn_state is not null");
return (Criteria) this;
}
public Criteria andEarnStateEqualTo(Integer value) {
addCriterion("earn_state =", value, "earnState");
return (Criteria) this;
}
public Criteria andEarnStateNotEqualTo(Integer value) {
addCriterion("earn_state <>", value, "earnState");
return (Criteria) this;
}
public Criteria andEarnStateGreaterThan(Integer value) {
addCriterion("earn_state >", value, "earnState");
return (Criteria) this;
}
public Criteria andEarnStateGreaterThanOrEqualTo(Integer value) {
addCriterion("earn_state >=", value, "earnState");
return (Criteria) this;
}
public Criteria andEarnStateLessThan(Integer value) {
addCriterion("earn_state <", value, "earnState");
return (Criteria) this;
}
public Criteria andEarnStateLessThanOrEqualTo(Integer value) {
addCriterion("earn_state <=", value, "earnState");
return (Criteria) this;
}
public Criteria andEarnStateIn(List<Integer> values) {
addCriterion("earn_state in", values, "earnState");
return (Criteria) this;
}
public Criteria andEarnStateNotIn(List<Integer> values) {
addCriterion("earn_state not in", values, "earnState");
return (Criteria) this;
}
public Criteria andEarnStateBetween(Integer value1, Integer value2) {
addCriterion("earn_state between", value1, value2, "earnState");
return (Criteria) this;
}
public Criteria andEarnStateNotBetween(Integer value1, Integer value2) {
addCriterion("earn_state not between", value1, value2, "earnState");
return (Criteria) this;
}
public Criteria andEarnTypeIsNull() {
addCriterion("earn_type is null");
return (Criteria) this;
}
public Criteria andEarnTypeIsNotNull() {
addCriterion("earn_type is not null");
return (Criteria) this;
}
public Criteria andEarnTypeEqualTo(Integer value) {
addCriterion("earn_type =", value, "earnType");
return (Criteria) this;
}
public Criteria andEarnTypeNotEqualTo(Integer value) {
addCriterion("earn_type <>", value, "earnType");
return (Criteria) this;
}
public Criteria andEarnTypeGreaterThan(Integer value) {
addCriterion("earn_type >", value, "earnType");
return (Criteria) this;
}
public Criteria andEarnTypeGreaterThanOrEqualTo(Integer value) {
addCriterion("earn_type >=", value, "earnType");
return (Criteria) this;
}
public Criteria andEarnTypeLessThan(Integer value) {
addCriterion("earn_type <", value, "earnType");
return (Criteria) this;
}
public Criteria andEarnTypeLessThanOrEqualTo(Integer value) {
addCriterion("earn_type <=", value, "earnType");
return (Criteria) this;
}
public Criteria andEarnTypeIn(List<Integer> values) {
addCriterion("earn_type in", values, "earnType");
return (Criteria) this;
}
public Criteria andEarnTypeNotIn(List<Integer> values) {
addCriterion("earn_type not in", values, "earnType");
return (Criteria) this;
}
public Criteria andEarnTypeBetween(Integer value1, Integer value2) {
addCriterion("earn_type between", value1, value2, "earnType");
return (Criteria) this;
}
public Criteria andEarnTypeNotBetween(Integer value1, Integer value2) {
addCriterion("earn_type not between", value1, value2, "earnType");
return (Criteria) this;
}
public Criteria andCreatedAtIsNull() {
addCriterion("created_at is null");
return (Criteria) this;
}
public Criteria andCreatedAtIsNotNull() {
addCriterion("created_at is not null");
return (Criteria) this;
}
public Criteria andCreatedAtEqualTo(Date value) {
addCriterion("created_at =", value, "createdAt");
return (Criteria) this;
}
public Criteria andCreatedAtNotEqualTo(Date value) {
addCriterion("created_at <>", value, "createdAt");
return (Criteria) this;
}
public Criteria andCreatedAtGreaterThan(Date value) {
addCriterion("created_at >", value, "createdAt");
return (Criteria) this;
}
public Criteria andCreatedAtGreaterThanOrEqualTo(Date value) {
addCriterion("created_at >=", value, "createdAt");
return (Criteria) this;
}
public Criteria andCreatedAtLessThan(Date value) {
addCriterion("created_at <", value, "createdAt");
return (Criteria) this;
}
public Criteria andCreatedAtLessThanOrEqualTo(Date value) {
addCriterion("created_at <=", value, "createdAt");
return (Criteria) this;
}
public Criteria andCreatedAtIn(List<Date> values) {
addCriterion("created_at in", values, "createdAt");
return (Criteria) this;
}
public Criteria andCreatedAtNotIn(List<Date> values) {
addCriterion("created_at not in", values, "createdAt");
return (Criteria) this;
}
public Criteria andCreatedAtBetween(Date value1, Date value2) {
addCriterion("created_at between", value1, value2, "createdAt");
return (Criteria) this;
}
public Criteria andCreatedAtNotBetween(Date value1, Date value2) {
addCriterion("created_at not between", value1, value2, "createdAt");
return (Criteria) this;
}
public Criteria andUpdatedAtIsNull() {
addCriterion("updated_at is null");
return (Criteria) this;
}
public Criteria andUpdatedAtIsNotNull() {
addCriterion("updated_at is not null");
return (Criteria) this;
}
public Criteria andUpdatedAtEqualTo(Date value) {
addCriterion("updated_at =", value, "updatedAt");
return (Criteria) this;
}
public Criteria andUpdatedAtNotEqualTo(Date value) {
addCriterion("updated_at <>", value, "updatedAt");
return (Criteria) this;
}
public Criteria andUpdatedAtGreaterThan(Date value) {
addCriterion("updated_at >", value, "updatedAt");
return (Criteria) this;
}
public Criteria andUpdatedAtGreaterThanOrEqualTo(Date value) {
addCriterion("updated_at >=", value, "updatedAt");
return (Criteria) this;
}
public Criteria andUpdatedAtLessThan(Date value) {
addCriterion("updated_at <", value, "updatedAt");
return (Criteria) this;
}
public Criteria andUpdatedAtLessThanOrEqualTo(Date value) {
addCriterion("updated_at <=", value, "updatedAt");
return (Criteria) this;
}
public Criteria andUpdatedAtIn(List<Date> values) {
addCriterion("updated_at in", values, "updatedAt");
return (Criteria) this;
}
public Criteria andUpdatedAtNotIn(List<Date> values) {
addCriterion("updated_at not in", values, "updatedAt");
return (Criteria) this;
}
public Criteria andUpdatedAtBetween(Date value1, Date value2) {
addCriterion("updated_at between", value1, value2, "updatedAt");
return (Criteria) this;
}
public Criteria andUpdatedAtNotBetween(Date value1, Date value2) {
addCriterion("updated_at not between", value1, value2, "updatedAt");
return (Criteria) this;
}
}
/**
* This class was generated by MyBatis Generator.
* This class corresponds to the database table user_staking_earn
*/
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
super();
}
}
/**
* This class was generated by MyBatis Generator.
* This class corresponds to the database table user_staking_earn
*/
public static class Criterion {
private String condition;
private Object value;
private Object secondValue;
private boolean noValue;
private boolean singleValue;
private boolean betweenValue;
private boolean listValue;
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
}
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}
你的问题是由于 MyBatis 试图通过反射访问 oredCriteria 属性,但它找不到该属性的 getter 方法。根据 MyBatis 的要求,所有需要访问的属性都必须有对应的 getter 和 setter 方法。
确保你的 UserStakingEarnDOExample 类中有 getOredCriteria 方法。你已经定义了这个方法,但请确保它没有被注释掉,并且其定义是正确的。
getOredCriteria 方法:确保 getOredCriteria 方法存在且没有拼写错误。public List<Criteria> getOredCriteria() {
return oredCriteria;
}
oredCriteria 是正确初始化的:在构造函数中初始化 oredCriteria。public UserStakingEarnDOExample() {
oredCriteria = new ArrayList<Criteria>();
}
以下是你的类的完整代码检查,确保有 getter 方法:
package com.kucoin.gemstakingfront.common.dal.dataobject;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class UserStakingEarnDOExample {
protected String orderByClause;
protected boolean distinct;
protected List<Criteria> oredCriteria;
public UserStakingEarnDOExample() {
oredCriteria = new ArrayList<Criteria>();
}
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
public String getOrderByClause() {
return orderByClause;
}
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
public boolean isDistinct() {
return distinct;
}
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
public boolean isValid() {
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
return criteria;
}
public List<Criterion> getCriteria() {
return criteria;
}
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value));
}
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value1, value2));
}
// Add your criteria methods here
// Example
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
// Add more criteria methods here
}
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition;
private Object value;
private Object secondValue;
private boolean noValue;
private boolean singleValue;
private boolean betweenValue;
private boolean listValue;
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
this(condition, value, secondValue, typeHandler);
this.betweenValue = true;
}
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}
如果以上检查没有发现问题,请确保你的 MyBatis 配置文件正确,尤其是映射文件和 resultMap 配置。
通过确保 getOredCriteria 方法存在且正确,你应该能够解决 ReflectionException 的问题。确保所有需要访问的属性都有对应的 getter 和 setter 方法,符合 MyBatis 的要求。
UserStakingEarnDOExample userStakingEarnDOCountExample = new UserStakingEarnDOExample();
UserStakingEarnDOExample.Criteria countCriteria = userStakingEarnDOCountExample.createCriteria();
countCriteria.andUserIdEqualTo(rewardsHistoryRequest.getUserId()).andEarnStateEqualTo(1);
if(StringUtils.isNotEmpty(rewardsHistoryRequest.getEarnToken())) {
countCriteria.andEarnTokenEqualTo(rewardsHistoryRequest.getEarnToken());
}
if(null != rewardsHistoryRequest.getStartTime()) {
countCriteria.andUpdatedAtGreaterThanOrEqualTo(rewardsHistoryRequest.getStartTime());
}
if(null != rewardsHistoryRequest.getEndTime()) {
countCriteria.andUpdatedAtGreaterThanOrEqualTo(rewardsHistoryRequest.getEndTime());
}
//将审核通过的且现在已经到了展示时间的活动查出来
Long count = userStakingEarnMapper.countByExample(userStakingEarnDOCountExample); 上面构造条件的写法有没有问题
你的条件构造看起来基本上是正确的,但是在处理日期时间条件时,有一个小错误:
countCriteria.andUpdatedAtGreaterThanOrEqualTo,而不是一个是 GreaterThanOrEqualTo,另一个是 LessThanOrEqualTo。以下是修正后的代码,确保日期时间条件的正确性:
UserStakingEarnDOExample userStakingEarnDOCountExample = new UserStakingEarnDOExample();
UserStakingEarnDOExample.Criteria countCriteria = userStakingEarnDOCountExample.createCriteria();
countCriteria.andUserIdEqualTo(rewardsHistoryRequest.getUserId()).andEarnStateEqualTo(1);
if (StringUtils.isNotEmpty(rewardsHistoryRequest.getEarnToken())) {
countCriteria.andEarnTokenEqualTo(rewardsHistoryRequest.getEarnToken());
}
if (rewardsHistoryRequest.getStartTime() != null) {
countCriteria.andUpdatedAtGreaterThanOrEqualTo(rewardsHistoryRequest.getStartTime());
}
if (rewardsHistoryRequest.getEndTime() != null) {
countCriteria.andUpdatedAtLessThanOrEqualTo(rewardsHistoryRequest.getEndTime());
}
// 将审核通过的且现在已经到了展示时间的活动查出来
Long count = userStakingEarnMapper.countByExample(userStakingEarnDOCountExample);
用户ID和收益状态条件:
countCriteria.andUserIdEqualTo(rewardsHistoryRequest.getUserId()).andEarnStateEqualTo(1);:确保 userId 和 earnState 条件正确。收益币种条件:
if (StringUtils.isNotEmpty(rewardsHistoryRequest.getEarnToken())) { countCriteria.andEarnTokenEqualTo(rewardsHistoryRequest.getEarnToken()); }:如果 earnToken 不为空,则添加该条件。时间条件:
if (rewardsHistoryRequest.getStartTime() != null) { countCriteria.andUpdatedAtGreaterThanOrEqualTo(rewardsHistoryRequest.getStartTime()); }:如果 startTime 不为空,则添加该条件。if (rewardsHistoryRequest.getEndTime() != null) { countCriteria.andUpdatedAtLessThanOrEqualTo(rewardsHistoryRequest.getEndTime()); }:如果 endTime 不为空,则添加该条件。确保你的 MyBatis 映射文件中正确映射了 updatedAt 字段,例如:
<resultMap id="BaseResultMap" type="com.kucoin.gemstakingfront.common.dal.dataobject.UserStakingEarnDO">
<id column="id" property="id" jdbcType="BIGINT"/>
<result column="user_id" property="userId" jdbcType="CHAR"/>
<result column="earn_state" property="earnState" jdbcType="INTEGER"/>
<result column="earn_token" property="earnToken" jdbcType="CHAR"/>
<result column="updated_at" property="updatedAt" jdbcType="TIMESTAMP"/>
<!-- 其他字段映射 -->
</resultMap>
通过修正日期时间条件的使用,你的条件构造代码应该能够正确工作。确保条件逻辑正确,同时确保 MyBatis 映射文件中的字段映射正确,以避免任何可能的错误。通过这些调整,你应该能够正确查询并统计符合条件的记录数量。
Caused by: org.apache.ibatis.reflection.ReflectionException: There is no getter for property named 'distinct' in 'class com.kucoin.gemstakingfront.common.dal.dataobject.UserStakingEarnDOExample$Criteria'
这个错误提示 org.apache.ibatis.reflection.ReflectionException: There is no getter for property named 'distinct' in 'class com.kucoin.gemstakingfront.common.dal.dataobject.UserStakingEarnDOExample$Criteria' 表明 MyBatis 在尝试访问 distinct 属性时找不到对应的 getter 方法。但根据你提供的代码,distinct 属性是在 UserStakingEarnDOExample 类中,而不是在 UserStakingEarnDOExample.Criteria 类中,这表明可能有地方错误地引用了 distinct 属性。
distinct 属性。UserStakingEarnDOExample 类中 distinct 属性有对应的 getter 方法。以下是你的 UserStakingEarnDOExample 类的完整代码检查,确保 distinct 属性有 getter 方法:
package com.kucoin.gemstakingfront.common.dal.dataobject;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class UserStakingEarnDOExample {
protected String orderByClause;
protected boolean distinct;
protected List<Criteria> oredCriteria;
public UserStakingEarnDOExample() {
oredCriteria = new ArrayList<Criteria>();
}
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
public String getOrderByClause() {
return orderByClause;
}
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
public boolean isDistinct() {
return distinct;
}
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
public boolean isValid() {
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
return criteria;
}
public List<Criterion> getCriteria() {
return criteria;
}
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value));
}
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value1, value2));
}
// Criteria methods
}
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition;
private Object value;
private Object secondValue;
private boolean noValue;
private boolean singleValue;
private boolean betweenValue;
private boolean listValue;
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
}
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}
确保你的 MyBatis 映射文件中没有错误地引用 distinct 属性。
<mapper namespace="com.kucoin.gemstakingfront.common.dal.mapper.UserStakingEarnMapper">
<select id="countByExample" resultType="java.lang.Long" parameterType="com.kucoin.gemstakingfront.common.dal.dataobject.UserStakingEarnDOExample">
SELECT COUNT(*)
FROM user_staking_earn
<where>
<if test="oredCriteria != null">
<foreach collection="oredCriteria" item="criteria" separator="OR">
<if test="criteria.valid">
<trim prefix="(" suffix=")" prefixOverrides="AND">
<foreach collection="criteria.criteria" item="criterion">
<choose>
<when test="criterion.noValue">
AND ${criterion.condition}
</when>
<when test="criterion.singleValue">
AND ${criterion.condition} #{criterion.value}
</when>
<when test="criterion.betweenValue">
AND ${criterion.condition} #{criterion.value} AND #{criterion.secondValue}
</when>
<when test="criterion.listValue">
AND ${criterion.condition}
<foreach collection="criterion.value" item="listItem" open="(" separator="," close=")">
#{listItem}
</foreach>
</when>
</choose>
</foreach>
</trim>
</if>
</foreach>
</if>
</where>
</select>
</mapper>
通过上述检查和修改,你应该能够解决 ReflectionException 的问题。确保所有需要访问的属性都有对应的 getter 方法,并且 MyBatis 映射文件中没有错误地引用属性。
<select id="getEarnTokenByEarnTokenGroup" resultType="com.kucoin.gemstakingfront.common.dal.dataobject.manual.EarnTokenDO">
SELECT
earn_token ,sum(earn_amount) as total_reward_amount
FROM
gem_staking.user_staking_earn
WHERE
user_id = #{userId,jdbcType=CHAR}
AND earn_state = 1
<if test="earnToken != null">
AND earn_token = #{earnToken,jdbcType=CHAR}
</if>
<if test="startTime != null">
AND updated_at >= #{startTime,jdbcType=TIMESTAMP}
</if>
<if test="endTime != null">
AND updated_at <= #{endTime,jdbcType=TIMESTAMP}
</if>
group by
earn_token
</select>List<EarnTokenDO> getEarnTokenByEarnTokenGroup(@Param("userId") String userId,
@Param("earnToken") String earnToken,
@Param("startTime") Date startTime,
@Param("endTime") Date endTime); package com.kucoin.gemstakingfront.common.dal.dataobject.manual;
import lombok.Data;
import java.math.BigDecimal;
import java.util.List;
@Data
public class EarnTokenDO {
String earnToken;
BigDecimal totalRewardAmount;
public String getEarnToken() {
return earnToken;
}
public void setEarnToken(String earnToken) {
this.earnToken = earnToken;
}
public BigDecimal getTotalRewardAmount() {
return totalRewardAmount;
}
public void setTotalRewardAmount(BigDecimal totalRewardAmount) {
this.totalRewardAmount = totalRewardAmount;
}
@Override
public String toString() {
return "EarnTokenDO{" +
"earnToken='" + earnToken + '\'' +
", totalRewardAmount=" + totalRewardAmount +
'}';
}
}
List<EarnTokenDO> earnTokenDOList = userStakingEarnMapper.getEarnTokenByEarnTokenGroup(rewardsHistoryRequest.getUserId(),rewardsHistoryRequest.getEarnToken(),rewardsHistoryRequest.getStartTime(),rewardsHistoryRequest.getEndTime());
log.info("getRewardsHistorySummary.earnTokenDOList:{}",earnTokenDOList); getRewardsHistorySummary.earnTokenDOList:Page{count=true, pageNum=1, pageSize=50, startRow=0, endRow=50, total=1, pages=1, reasonable=false, pageSizeZero=false}[null]
从你的描述中可以看出,你正在使用 MyBatis 查询来获取用户的奖励信息,并且你遇到了一个问题,即日志信息中显示的结果是 [null],这意味着查询结果中的元素是 null。可能原因有以下几种:
确保 SQL 查询返回的列名与 EarnTokenDO 类中的字段名匹配。你可以在 SQL 查询中使用别名来确保列名与字段名一致。
确保 MyBatis 映射配置是正确的。你可以使用 resultMap 来明确指定列名和字段名的映射关系。
修改 SQL 查询,确保列名与字段名一致:
<select id="getEarnTokenByEarnTokenGroup" resultType="com.kucoin.gemstakingfront.common.dal.dataobject.manual.EarnTokenDO">
SELECT
earn_token AS earnToken,
SUM(earn_amount) AS totalRewardAmount
FROM
gem_staking.user_staking_earn
WHERE
user_id = #{userId,jdbcType=CHAR}
AND earn_state = 1
<if test="earnToken != null">
AND earn_token = #{earnToken,jdbcType=CHAR}
</if>
<if test="startTime != null">
AND updated_at >= #{startTime,jdbcType=TIMESTAMP}
</if>
<if test="endTime != null">
AND updated_at <= #{endTime,jdbcType=TIMESTAMP}
</if>
GROUP BY
earn_token
</select>
确保你的 Mapper 接口正确:
package com.kucoin.gemstakingfront.common.dal.mapper;
import com.kucoin.gemstakingfront.common.dal.dataobject.manual.EarnTokenDO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.Date;
import java.util.List;
@Mapper
public interface UserStakingEarnMapper {
List<EarnTokenDO> getEarnTokenByEarnTokenGroup(@Param("userId") String userId,
@Param("earnToken") String earnToken,
@Param("startTime") Date startTime,
@Param("endTime") Date endTime);
}
确保你的数据对象 EarnTokenDO 的字段名和 SQL 查询返回的列名一致,并且存在 getter 和 setter 方法:
package com.kucoin.gemstakingfront.common.dal.dataobject.manual;
import lombok.Data;
import java.math.BigDecimal;
@Data
public class EarnTokenDO {
private String earnToken;
private BigDecimal totalRewardAmount;
@Override
public String toString() {
return "EarnTokenDO{" +
"earnToken='" + earnToken + '\'' +
", totalRewardAmount=" + totalRewardAmount +
'}';
}
}
确保在调用方法时传递了正确的参数,并且日志打印的结果正确:
List<EarnTokenDO> earnTokenDOList = userStakingEarnMapper.getEarnTokenByEarnTokenGroup(
rewardsHistoryRequest.getUserId(),
rewardsHistoryRequest.getEarnToken(),
rewardsHistoryRequest.getStartTime(),
rewardsHistoryRequest.getEndTime()
);
log.info("getRewardsHistorySummary.earnTokenDOList: {}", earnTokenDOList);
确保 SQL 查询在数据库中返回正确的结果。你可以将生成的 SQL 查询直接在数据库中运行,确保它返回预期的结果。
通过确保 SQL 查询返回的列名与 EarnTokenDO 类中的字段名一致,并正确配置 MyBatis 映射,你应该能够解决查询结果为 null 的问题。通过上述修改和检查,你应该能够正确地从数据库中查询数据并打印日志。
GenericPageResult<GemPoolCampaignHisVO> getHisCampaignAndPoolInfo(
@RequestParam(value = "lang", defaultValue = "en_US") String lang,
@RequestParam(required = false) @Min(value = 1, require = false) Integer currentPage,
@RequestParam(required = false) @Range(min = 1, max = 30, require = false) Integer pageSize);currentPage如果不传给默认值1
为了在不传递 currentPage 参数时给它一个默认值,你可以在方法参数中直接给它指定默认值。另外,@RequestParam 的 required 属性已经默认为 true,所以你不需要显式地设置 required 属性。
通过在方法参数中直接指定默认值,确保在参数未传递时使用默认值:
GenericPageResult<GemPoolCampaignHisVO> getHisCampaignAndPoolInfo(
@RequestParam(value = "lang", defaultValue = "en_US") String lang,
@RequestParam(required = false, defaultValue = "1") @Min(1) Integer currentPage,
@RequestParam(required = false) @Range(min = 1, max = 30) Integer pageSize);
@RequestParam 的 defaultValue 属性:defaultValue 属性用于在请求参数缺失时提供默认值。@Min 注解:@Min(1) 注解用于验证 currentPage 是否大于或等于 1,但是它不允许 require 属性。require 应该在 @RequestParam 注解中使用。@Range 注解:@Range(min = 1, max = 30) 注解用于验证 pageSize 是否在 1 到 30 的范围内。import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.validation.constraints.Min;
import javax.validation.constraints.Range;
@RestController
@Validated
public class YourController {
@GetMapping("/getHisCampaignAndPoolInfo")
public GenericPageResult<GemPoolCampaignHisVO> getHisCampaignAndPoolInfo(
@RequestParam(value = "lang", defaultValue = "en_US") String lang,
@RequestParam(value = "currentPage", required = false, defaultValue = "1") @Min(1) Integer currentPage,
@RequestParam(value = "pageSize", required = false) @Range(min = 1, max = 30) Integer pageSize) {
// 方法实现
// 如果 pageSize 为空,提供一个默认值,例如 10
if (pageSize == null) {
pageSize = 10;
}
// 返回结果
return new GenericPageResult<>();
}
}
@RequestParam 的 defaultValue 属性:通过设置 defaultValue = "1",确保在 currentPage 参数未传递时,默认值为 1。@Min 注解:确保 currentPage 至少为 1。@Range 注解:确保 pageSize 在 1 到 30 的范围内。pageSize 参数未传递,手动设置一个默认值,例如 10。通过这种方式,你可以确保在未传递 currentPage 参数时,使用默认值 1,并且在未传递 pageSize 参数时,使用默认值 10。这样可以保证分页参数的正确性和健壮性。
pageSize也在不传的时候给个默认值
为了确保在不传递 pageSize 参数时给它一个默认值,你可以在方法参数中直接指定默认值,类似于 currentPage。这样可以确保在请求参数缺失的情况下使用默认值。
通过在方法参数中直接指定默认值,确保在参数未传递时使用默认值:
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.validation.constraints.Min;
import javax.validation.constraints.Max;
import javax.validation.constraints.NotNull;
@RestController
@Validated
public class YourController {
@GetMapping("/getHisCampaignAndPoolInfo")
public GenericPageResult<GemPoolCampaignHisVO> getHisCampaignAndPoolInfo(
@RequestParam(value = "lang", defaultValue = "en_US") String lang,
@RequestParam(value = "currentPage", required = false, defaultValue = "1") @Min(1) Integer currentPage,
@RequestParam(value = "pageSize", required = false, defaultValue = "10") @Min(1) @Max(30) Integer pageSize) {
// 方法实现
// 返回结果
return new GenericPageResult<>();
}
}
@RequestParam 的 defaultValue 属性:通过设置 defaultValue = "1" 和 defaultValue = "10",确保在 currentPage 和 pageSize 参数未传递时,使用默认值 1 和 10。@Min 和 @Max 注解:确保 currentPage 至少为 1,pageSize 在 1 到 30 的范围内。@Validated 注解:确保启用 Spring 的验证功能。以下是一个完整的示例,展示了如何在 Spring Boot 控制器中处理分页参数:
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.validation.constraints.Min;
import javax.validation.constraints.Max;
@RestController
@Validated
public class YourController {
@GetMapping("/getHisCampaignAndPoolInfo")
public GenericPageResult<GemPoolCampaignHisVO> getHisCampaignAndPoolInfo(
@RequestParam(value = "lang", defaultValue = "en_US") String lang,
@RequestParam(value = "currentPage", required = false, defaultValue = "1") @Min(1) Integer currentPage,
@RequestParam(value = "pageSize", required = false, defaultValue = "10") @Min(1) @Max(30) Integer pageSize) {
// 方法实现
// 返回结果
return new GenericPageResult<>();
}
}
确保在调用方法时,如果未传递 currentPage 或 pageSize 参数,控制器会使用默认值:
public GenericPageResult<GemPoolCampaignHisVO> getHisCampaignAndPoolInfo(
@RequestParam(value = "lang", defaultValue = "en_US") String lang,
@RequestParam(value = "currentPage", required = false, defaultValue = "1") @Min(1) Integer currentPage,
@RequestParam(value = "pageSize", required = false, defaultValue = "10") @Min(1) @Max(30) Integer pageSize) {
// 示例逻辑
System.out.println("Language: " + lang);
System.out.println("Current Page: " + currentPage);
System.out.println("Page Size: " + pageSize);
// 返回结果
return new GenericPageResult<>();
}
通过这种方式,你可以确保在未传递 currentPage 和 pageSize 参数时,使用默认值 1 和 10。这样可以保证分页参数的正确性和健壮性。
@ApiOperation(value = "获取活动详情", httpMethod = "GET")
@GetMapping(value = "/gempool/staking/campaign/details")
GenericResult<GemPoolCampaignVO> getCampaignDetails(@RequestParam(value = "lang", defaultValue = "en_US") String lang,@RequestParam(value = "earnToken") String earnToken);
你的代码片段展示了使用 Spring Boot 和 Swagger 注解来定义一个 RESTful API 接口。这个接口用于获取活动详情,并且支持通过请求参数传递语言和收益币种。
@ApiOperation:用于描述接口的用途和请求方法。@GetMapping:指定请求路径和方法类型(GET)。@RequestParam:用于获取请求参数,其中 lang 参数有默认值 en_US,earnToken 参数是必须的。以下是一个完整的 Spring Boot 控制器示例,展示了如何使用 Swagger 注解和 Spring 的注解来定义和处理请求。
确保你的项目中已经包含了 Spring Boot 和 Swagger 的依赖。如果没有,可以在 pom.xml 中添加以下依赖:
<!-- Spring Boot Starter Web -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Swagger -->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-boot-starter</artifactId>
<version>3.0.0</version>
</dependency>
创建一个配置类来启用和配置 Swagger:
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@Configuration
@EnableSwagger2
public class SwaggerConfig {
@Bean
public Docket api() {
return new Docket(DocumentationType.SWAGGER_2)
.select()
.apis(RequestHandlerSelectors.basePackage("com.kucoin.gemstakingfront.controller"))
.paths(PathSelectors.any())
.build();
}
}
创建一个控制器类,定义 API 接口:
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class GemPoolController {
@ApiOperation(value = "获取活动详情", httpMethod = "GET")
@GetMapping(value = "/gempool/staking/campaign/details")
public GenericResult<GemPoolCampaignVO> getCampaignDetails(
@RequestParam(value = "lang", defaultValue = "en_US") String lang,
@RequestParam(value = "earnToken") String earnToken) {
// 模拟业务逻辑
GemPoolCampaignVO campaignDetails = new GemPoolCampaignVO();
campaignDetails.setLang(lang);
campaignDetails.setEarnToken(earnToken);
campaignDetails.setCampaignName("Sample Campaign");
// 返回结果
return new GenericResult<>(campaignDetails);
}
}
定义返回的数据对象 GenericResult 和 GemPoolCampaignVO:
public class GenericResult<T> {
private T data;
private String message;
private int code;
public GenericResult() {
}
public GenericResult(T data) {
this.data = data;
this.message = "Success";
this.code = 200;
}
// Getters and Setters
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public int getCode() {
return code;
}
public void setCode(int code) {
this.code = code;
}
}
public class GemPoolCampaignVO {
private String lang;
private String earnToken;
private String campaignName;
// Getters and Setters
public String getLang() {
return lang;
}
public void setLang(String lang) {
this.lang = lang;
}
public String getEarnToken() {
return earnToken;
}
public void setEarnToken(String earnToken) {
this.earnToken = earnToken;
}
public String getCampaignName() {
return campaignName;
}
public void setCampaignName(String campaignName) {
this.campaignName = campaignName;
}
}
启动 Spring Boot 应用程序,访问 Swagger UI 进行测试,默认情况下,Swagger UI 可以在 http://localhost:8080/swagger-ui/ 访问。你可以看到刚才定义的 API 接口,并可以在界面上进行测试。
@ApiOperation:描述 API 的用途和 HTTP 方法。@GetMapping:定义 GET 请求路径。@RequestParam:获取请求参数,其中 lang 参数有默认值 en_US,earnToken 参数是必须的。getCampaignDetails 方法中模拟业务逻辑,返回活动详情。GenericResult 包装返回的活动详情对象 GemPoolCampaignVO。通过这种方式,你可以定义一个带有默认参数值的 API 接口,并使用 Swagger 进行文档化和测试。
for (GemStakingCampaignDO campaign : newAndComingCampaignsDO) {
if(StringUtils.isEmpty(userId)) {
if(campaign.getInnerTest() == 1 && CollectionUtils.isNotEmpty(whitelist) &&whitelist.contains(userId)) {
//登陆用户,活动是内测的,但是当前用户又不在白名单,不可见
continue;
}
} else {
//非登陆用户,内测活动也不可见
if(campaign.getInnerTest() == 1) continue;;
}}请帮我简化一下
你的代码逻辑是对 newAndComingCampaignsDO 列表进行遍历,根据用户是否登录和活动是否为内测活动来决定是否跳过当前活动。可以简化和优化代码逻辑。以下是简化版的代码:
for (GemStakingCampaignDO campaign : newAndComingCampaignsDO) {
boolean isInnerTest = campaign.getInnerTest() == 1;
boolean isUserLoggedIn = StringUtils.isNotEmpty(userId);
boolean isUserInWhitelist = CollectionUtils.isNotEmpty(whitelist) && whitelist.contains(userId);
if (isInnerTest && (!isUserLoggedIn || !isUserInWhitelist)) {
// 内测活动并且用户未登录或用户不在白名单中,跳过
continue;
}
}
提取公共逻辑:
campaign.getInnerTest() == 1 为 isInnerTest。StringUtils.isNotEmpty(userId) 为 isUserLoggedIn。CollectionUtils.isNotEmpty(whitelist) && whitelist.contains(userId) 为 isUserInWhitelist。简化条件判断:
if 语句来处理所有情况:
isInnerTest 为 true),并且用户未登录 (!isUserLoggedIn) 或用户不在白名单中 (!isUserInWhitelist),则跳过该活动。isInnerTest 为 true。!isUserLoggedIn || !isUserInWhitelist。通过这种方式,可以使代码更加简洁清晰,同时保持原有逻辑不变。
List<PoolHisVO> poolVOS = campaignPools.stream()
.map(pool -> PoolHisVO.builder()
.poolId(pool.getPoolId())
.earnTokenAmount(pool.getEarnTokenAmount())
.stakingStartDate(pool.getStakingStartDate().getTime())
.stakingToken(pool.getStakingToken())
.totalStakingParticipants(pool.getBaseStakingParticipants()+ pool.getRealStakingParticipants())
.stakingTokenLogo(pool.getStakingTokenLogo())
.totalStakingAmount(pool.getBaseStakingAmount().add(pool.getRealStakingAmount()))
.stakingEndDate(pool.getStakingEndDate().getTime())
.build())
.collect(Collectors.toList());这个写法是不是就没有办法在里面写逻辑了,我需要写逻辑给PoolHisVO塞值
虽然 Java Streams 和 map 方法提供了简洁的方式来转换集合中的元素,但在某些情况下,你可能需要在 map 方法中添加逻辑来处理每个元素。这是完全可以做到的。你可以在 map 方法中编写更复杂的逻辑来处理每个元素并生成新的对象。
以下是一个示例,展示了如何在 map 方法中添加逻辑来处理每个元素并生成 PoolHisVO 对象:
import java.util.List;
import java.util.stream.Collectors;
public class Example {
public static void main(String[] args) {
// 假设 campaignPools 是你的原始数据列表
List<CampaignPool> campaignPools = getCampaignPools();
// 使用 Stream 和 map 方法处理每个元素,并生成新的 PoolHisVO 对象
List<PoolHisVO> poolVOS = campaignPools.stream()
.map(pool -> {
PoolHisVO.PoolHisVOBuilder builder = PoolHisVO.builder()
.poolId(pool.getPoolId())
.earnTokenAmount(pool.getEarnTokenAmount())
.stakingStartDate(pool.getStakingStartDate().getTime())
.stakingToken(pool.getStakingToken())
.totalStakingParticipants(pool.getBaseStakingParticipants() + pool.getRealStakingParticipants())
.stakingTokenLogo(pool.getStakingTokenLogo())
.totalStakingAmount(pool.getBaseStakingAmount().add(pool.getRealStakingAmount()))
.stakingEndDate(pool.getStakingEndDate().getTime());
// 在这里添加你的逻辑
if (/* some condition */) {
builder.someField(someValue);
} else {
builder.someOtherField(someOtherValue);
}
return builder.build();
})
.collect(Collectors.toList());
// 打印结果
poolVOS.forEach(System.out::println);
}
// 示例方法:获取原始数据列表
private static List<CampaignPool> getCampaignPools() {
// 返回示例数据
return List.of(
new CampaignPool(/* 初始化参数 */),
new CampaignPool(/* 初始化参数 */)
);
}
}
map 方法:使用 map 方法将原始数据列表 campaignPools 转换为新的 PoolHisVO 对象列表。PoolHisVO.PoolHisVOBuilder:使用 PoolHisVO 的 Builder 模式来生成对象,这样可以在构建对象的过程中添加逻辑。map 方法内部编写逻辑,根据需要设置 PoolHisVO 对象的字段值。collect(Collectors.toList()) 将流转换为列表。以下是一个完整的示例,包括所有相关类的定义:
CampaignPool 类import java.math.BigDecimal;
import java.util.Date;
public class CampaignPool {
private String poolId;
private BigDecimal earnTokenAmount;
private Date stakingStartDate;
private String stakingToken;
private int baseStakingParticipants;
private int realStakingParticipants;
private String stakingTokenLogo;
private BigDecimal baseStakingAmount;
private BigDecimal realStakingAmount;
private Date stakingEndDate;
// Getters and setters
// 示例构造器
public CampaignPool(String poolId, BigDecimal earnTokenAmount, Date stakingStartDate, String stakingToken,
int baseStakingParticipants, int realStakingParticipants, String stakingTokenLogo,
BigDecimal baseStakingAmount, BigDecimal realStakingAmount, Date stakingEndDate) {
this.poolId = poolId;
this.earnTokenAmount = earnTokenAmount;
this.stakingStartDate = stakingStartDate;
this.stakingToken = stakingToken;
this.baseStakingParticipants = baseStakingParticipants;
this.realStakingParticipants = realStakingParticipants;
this.stakingTokenLogo = stakingTokenLogo;
this.baseStakingAmount = baseStakingAmount;
this.realStakingAmount = realStakingAmount;
this.stakingEndDate = stakingEndDate;
}
// Getters...
}
PoolHisVO 类import java.math.BigDecimal;
public class PoolHisVO {
private String poolId;
private BigDecimal earnTokenAmount;
private long stakingStartDate;
private String stakingToken;
private int totalStakingParticipants;
private String stakingTokenLogo;
private BigDecimal totalStakingAmount;
private long stakingEndDate;
// Getters and setters
// Builder pattern
public static PoolHisVOBuilder builder() {
return new PoolHisVOBuilder();
}
public static class PoolHisVOBuilder {
private String poolId;
private BigDecimal earnTokenAmount;
private long stakingStartDate;
private String stakingToken;
private int totalStakingParticipants;
private String stakingTokenLogo;
private BigDecimal totalStakingAmount;
private long stakingEndDate;
public PoolHisVOBuilder poolId(String poolId) {
this.poolId = poolId;
return this;
}
public PoolHisVOBuilder earnTokenAmount(BigDecimal earnTokenAmount) {
this.earnTokenAmount = earnTokenAmount;
return this;
}
public PoolHisVOBuilder stakingStartDate(long stakingStartDate) {
this.stakingStartDate = stakingStartDate;
return this;
}
public PoolHisVOBuilder stakingToken(String stakingToken) {
this.stakingToken = stakingToken;
return this;
}
public PoolHisVOBuilder totalStakingParticipants(int totalStakingParticipants) {
this.totalStakingParticipants = totalStakingParticipants;
return this;
}
public PoolHisVOBuilder stakingTokenLogo(String stakingTokenLogo) {
this.stakingTokenLogo = stakingTokenLogo;
return this;
}
public PoolHisVOBuilder totalStakingAmount(BigDecimal totalStakingAmount) {
this.totalStakingAmount = totalStakingAmount;
return this;
}
public PoolHisVOBuilder stakingEndDate(long stakingEndDate) {
this.stakingEndDate = stakingEndDate;
return this;
}
public PoolHisVO build() {
PoolHisVO poolHisVO = new PoolHisVO();
poolHisVO.poolId = this.poolId;
poolHisVO.earnTokenAmount = this.earnTokenAmount;
poolHisVO.stakingStartDate = this.stakingStartDate;
poolHisVO.stakingToken = this.stakingToken;
poolHisVO.totalStakingParticipants = this.totalStakingParticipants;
poolHisVO.stakingTokenLogo = this.stakingTokenLogo;
poolHisVO.totalStakingAmount = this.totalStakingAmount;
poolHisVO.stakingEndDate = this.stakingEndDate;
return poolHisVO;
}
}
@Override
public String toString() {
return "PoolHisVO{" +
"poolId='" + poolId + '\'' +
", earnTokenAmount=" + earnTokenAmount +
", stakingStartDate=" + stakingStartDate +
", stakingToken='" + stakingToken + '\'' +
", totalStakingParticipants=" + totalStakingParticipants +
", stakingTokenLogo='" + stakingTokenLogo + '\'' +
", totalStakingAmount=" + totalStakingAmount +
", stakingEndDate=" + stakingEndDate +
'}';
}
}
通过像这样在 map 方法中添加逻辑,可以在转换过程中对数据进行处理,并生成包含所需值的新对象。
//挖矿结束时间大于现在并且挖矿结束时间在结束的24小时内
StakingCampaignPoolDOExample stakingCampaignPoolDOExample = new StakingCampaignPoolDOExample();
Date now = DateTimeUtils.getNowDateUTC8();
stakingCampaignPoolDOExample.createCriteria()
.andStakingEndTimeLessThanOrEqualTo(now);
List<StakingCampaignPoolDO> stakingCampaignPoolDOS = stakingCampaignPoolMapper.selectByExample(stakingCampaignPoolDOExample); 怎么实现查结束时间小于现在但是,现在没有超过结束后1小时
要实现查询挖矿结束时间小于当前时间但未超过结束后1小时的记录,你需要两个条件:
now。oneHourAgo。andStakingEndTimeLessThanOrEqualTo(now) 和 andStakingEndTimeGreaterThan(oneHourAgo)。以下是实现上述逻辑的示例代码:
import java.util.Date;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Service;
@Service
public class StakingService {
@Autowired
private StakingCampaignPoolMapper stakingCampaignPoolMapper;
public List<StakingCampaignPoolDO> getEndingPools() {
// 获取当前时间
Date now = DateTimeUtils.getNowDateUTC8();
// 计算当前时间减去1小时的时间
Date oneHourAgo = new Date(now.getTime() - 3600 * 1000);
// 构建查询条件
StakingCampaignPoolDOExample stakingCampaignPoolDOExample = new StakingCampaignPoolDOExample();
stakingCampaignPoolDOExample.createCriteria()
.andStakingEndTimeLessThanOrEqualTo(now)
.andStakingEndTimeGreaterThan(oneHourAgo);
// 执行查询
return stakingCampaignPoolMapper.selectByExample(stakingCampaignPoolDOExample);
}
}
Date now = DateTimeUtils.getNowDateUTC8();Date oneHourAgo = new Date(now.getTime() - 3600 * 1000);andStakingEndTimeLessThanOrEqualTo(now):挖矿结束时间小于当前时间。andStakingEndTimeGreaterThan(oneHourAgo):挖矿结束时间大于当前时间减去1小时。stakingCampaignPoolMapper.selectByExample(stakingCampaignPoolDOExample);确保你的 MyBatis Mapper 配置正确:
<mapper namespace="com.example.mapper.StakingCampaignPoolMapper">
<select id="selectByExample" resultType="com.example.domain.StakingCampaignPoolDO" parameterType="com.example.domain.StakingCampaignPoolDOExample">
SELECT
pool_id, staking_end_time, ...
FROM
gem_staking.staking_campaign_pool
<where>
<if test="oredCriteria != null">
<foreach collection="oredCriteria" item="criteria" separator="OR">
<if test="criteria.valid">
<trim prefix="(" suffix=")" prefixOverrides="AND">
<foreach collection="criteria.criteria" item="criterion">
<choose>
<when test="criterion.noValue">
AND ${criterion.condition}
</when>
<when test="criterion.singleValue">
AND ${criterion.condition} #{criterion.value}
</when>
<when test="criterion.betweenValue">
AND ${criterion.condition} #{criterion.value} AND #{criterion.secondValue}
</when>
<when test="criterion.listValue">
AND ${criterion.condition}
<foreach collection="criterion.value" item="listItem" open="(" separator="," close=")">
#{listItem}
</foreach>
</when>
</choose>
</foreach>
</trim>
</if>
</foreach>
</if>
</where>
</select>
</mapper>
通过使用两个条件构建查询,你可以查询到挖矿结束时间小于当前时间但未超过结束后1小时的记录。确保在查询条件中正确使用 andStakingEndTimeLessThanOrEqualTo(now) 和 andStakingEndTimeGreaterThan(oneHourAgo)。
错了。挖矿结束时间小于现在是对的。表示挖矿已经结束。但是还需要查出当前时间不要超过(挖矿结束时间+1小时)
明白了,你的需求是查询挖矿结束时间小于当前时间,并且当前时间不超过挖矿结束时间再加上1小时。换句话说,你需要找到那些挖矿刚刚结束且在结束后的1小时内的记录。
now。oneHourAgo。andStakingEndTimeLessThanOrEqualTo(now) 和 andStakingEndTimeGreaterThan(oneHourAgo)。以下是实现上述逻辑的示例代码:
import java.util.Date;
import java.util.List;
@Service
public class StakingService {
@Autowired
private StakingCampaignPoolMapper stakingCampaignPoolMapper;
public List<StakingCampaignPoolDO> getEndingPools() {
// 获取当前时间
Date now = DateTimeUtils.getNowDateUTC8();
// 计算挖矿结束时间加1小时的时间
Date oneHourLater = new Date(now.getTime() + 3600 * 1000);
// 构建查询条件
StakingCampaignPoolDOExample stakingCampaignPoolDOExample = new StakingCampaignPoolDOExample();
stakingCampaignPoolDOExample.createCriteria()
.andStakingEndTimeLessThanOrEqualTo(now)
.andStakingEndTimeGreaterThan(new Date(now.getTime() - 3600 * 1000)); // 挖矿结束时间大于当前时间减去1小时
// 执行查询
return stakingCampaignPoolMapper.selectByExample(stakingCampaignPoolDOExample);
}
}
Date now = DateTimeUtils.getNowDateUTC8();Date oneHourAgo = new Date(now.getTime() - 3600 * 1000);andStakingEndTimeLessThanOrEqualTo(now):挖矿结束时间在当前时间之前。andStakingEndTimeGreaterThan(oneHourAgo):挖矿结束时间在当前时间减去1小时之后。stakingCampaignPoolMapper.selectByExample(stakingCampaignPoolDOExample);确保你的 MyBatis Mapper 配置正确:
<mapper namespace="com.example.mapper.StakingCampaignPoolMapper">
<select id="selectByExample" resultType="com.example.domain.StakingCampaignPoolDO" parameterType="com.example.domain.StakingCampaignPoolDOExample">
SELECT
pool_id, staking_end_time, ...
FROM
gem_staking.staking_campaign_pool
<where>
<if test="oredCriteria != null">
<foreach collection="oredCriteria" item="criteria" separator="OR">
<if test="criteria.valid">
<trim prefix="(" suffix=")" prefixOverrides="AND">
<foreach collection="criteria.criteria" item="criterion">
<choose>
<when test="criterion.noValue">
AND ${criterion.condition}
</when>
<when test="criterion.singleValue">
AND ${criterion.condition} #{criterion.value}
</when>
<when test="criterion.betweenValue">
AND ${criterion.condition} #{criterion.value} AND #{criterion.secondValue}
</when>
<when test="criterion.listValue">
AND ${criterion.condition}
<foreach collection="criterion.value" item="listItem" open="(" separator="," close=")">
#{listItem}
</foreach>
</when>
</choose>
</foreach>
</trim>
</if>
</foreach>
</if>
</where>
</select>
</mapper>
通过使用两个条件构建查询,你可以查询到挖矿结束时间小于当前时间,但当前时间不超过挖矿结束时间再加上1小时的记录。确保在查询条件中正确使用 andStakingEndTimeLessThanOrEqualTo(now) 和 andStakingEndTimeGreaterThan(oneHourAgo)。
public static Date addMinutesToDate(Date date, int minutes) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(Calendar.MINUTE, minutes);
return calendar.getTime();
}按照这个方法写一个减5分钟的方法
你可以使用类似的方法来编写一个减去5分钟的方法。通过使用 Java 的 Calendar 类,你可以轻松地对日期进行加减操作。
以下是一个减去5分钟的方法:
import java.util.Calendar;
import java.util.Date;
public class DateTimeUtils {
public static Date subtractMinutesFromDate(Date date, int minutes) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(Calendar.MINUTE, -minutes);
return calendar.getTime();
}
public static void main(String[] args) {
Date now = new Date();
System.out.println("Current Time: " + now);
Date fiveMinutesAgo = subtractMinutesFromDate(now, 5);
System.out.println("Five Minutes Ago: " + fiveMinutesAgo);
}
}
方法定义:
public static Date subtractMinutesFromDate(Date date, int minutes): 定义一个静态方法,接受一个 Date 对象和一个整数 minutes,返回减去指定分钟数后的 Date 对象。使用 Calendar 类:
Calendar calendar = Calendar.getInstance();:获取一个 Calendar 实例。calendar.setTime(date);:将 Calendar 的时间设置为传入的 Date 对象。calendar.add(Calendar.MINUTE, -minutes);:使用 add 方法减去指定的分钟数。注意这里传递的是负值 -minutes。返回结果:
return calendar.getTime();:返回减去指定分钟数后的 Date 对象。在 main 方法中,你可以看到如何使用这个方法来减去5分钟,并打印结果:
public static void main(String[] args) {
Date now = new Date();
System.out.println("Current Time: " + now);
Date fiveMinutesAgo = subtractMinutesFromDate(now, 5);
System.out.println("Five Minutes Ago: " + fiveMinutesAgo);
}
通过这种方式,你可以轻松地编写一个减去指定分钟数的方法,并将其应用于日期处理逻辑中。确保使用 Calendar 类的方法进行时间操作,可以方便地对日期进行加减操作。
/*
package com.kucoin.gemstakingjob.biz.daemon;
import com.dangdang.ddframe.job.api.ShardingContext;
import com.dangdang.ddframe.job.api.simple.SimpleJob;
import com.kucoin.gemstakingjob.common.dal.dataobject.*;
import com.kucoin.gemstakingjob.common.dal.mapper.UserRewardSummaryMapper;
import com.kucoin.gemstakingjob.common.dal.mapper.UserStakingEarnMapper;
import com.kucoin.gemstakingjob.core.async.GemStakingThreadPoolConfig;
import com.kucoin.gemstakingjob.core.service.GemPoolCampaignPoolService;
import com.kucoin.gemstakingjob.core.service.GemPoolCampaignService;
import com.kucoin.gemstakingjob.core.service.SummaryRewardJobService;
import com.kucoin.gemstakingjob.core.service.SummaryRewardService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.List;
import java.util.stream.Collectors;
/**
算收益定时任务
@author kylin.lv
*/
@Component
@Slf4j
public class SummaryRewardTask implements SimpleJob {
private static final int BATCH_SIZE = 1000; // 每批处理的记录数
@Autowired
private SummaryRewardJobService summaryRewardJobService;
@Autowired
private UserRewardSummaryMapper userRewardSummaryMapper;
@Resource(name = GemStakingThreadPoolConfig.GEM_STAKING_SUMMARY_REWARD_JOB_EXECUTOR)
private ThreadPoolTaskExecutor summaryRewardJobExecutor;
@Autowired
private GemPoolCampaignPoolService campaignPoolService;
@Autowired
private GemPoolCampaignService gemPoolCampaignService;
@Autowired
private SummaryRewardService summaryRewardService;
/**
private List<UserRewardSummaryDO> fetchUserRewardSummaries(String poolId,long lastId,int summaryStage, int batchSize, int shardingItem, int shardingTotalCount) {
return userRewardSummaryMapper.getUserRewardSummary(poolId, summaryStage, shardingTotalCount, shardingItem, batchSize, lastId);
}
} 这里有个问题,岂不是每次都是从0开始,但是一旦这个记录处理后,后面就查不出来了
你指出的正确,当前代码中的逻辑确实存在一个问题,即每次循环都从 lastId 开始,而不是从上次查询结果的最后一个 ID 开始。如果某个分片任务在一次循环中没有处理完所有的数据,下一次循环会重新从头开始,这会导致重复处理或者漏处理数据。
为了解决这个问题,可以在每次处理完一批数据后更新 lastId,确保下次查询时能够继续处理剩余的数据。下面是修正后的代码:
package com.kucoin.gemstakingjob.biz.daemon;
import com.dangdang.ddframe.job.api.ShardingContext;
import com.dangdang.ddframe.job.api.simple.SimpleJob;
import com.kucoin.gemstakingjob.common.dal.dataobject.*;
import com.kucoin.gemstakingjob.common.dal.mapper.UserRewardSummaryMapper;
import com.kucoin.gemstakingjob.common.dal.mapper.UserStakingEarnMapper;
import com.kucoin.gemstakingjob.core.async.GemStakingThreadPoolConfig;
import com.kucoin.gemstakingjob.core.service.GemPoolCampaignPoolService;
import com.kucoin.gemstakingjob.core.service.GemPoolCampaignService;
import com.kucoin.gemstakingjob.core.service.SummaryRewardJobService;
import com.kucoin.gemstakingjob.core.service.SummaryRewardService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.List;
import java.util.stream.Collectors;
@Component
@Slf4j
public class SummaryRewardTask implements SimpleJob {
private static final int BATCH_SIZE = 1000; // 每批处理的记录数
@Autowired
private SummaryRewardJobService summaryRewardJobService;
@Autowired
private UserRewardSummaryMapper userRewardSummaryMapper;
@Resource(name = GemStakingThreadPoolConfig.GEM_STAKING_SUMMARY_REWARD_JOB_EXECUTOR)
private ThreadPoolTaskExecutor summaryRewardJobExecutor;
@Autowired
private GemPoolCampaignPoolService campaignPoolService;
@Autowired
private GemPoolCampaignService gemPoolCampaignService;
@Autowired
private SummaryRewardService summaryRewardService;
@Override
public void execute(ShardingContext context) {
int totalCount = context.getShardingTotalCount();
int shardingItem = context.getShardingItem();
List<SummaryRewardJobDO> rewardJobDOS = summaryRewardJobService.getSummaryRewardJob();
if (CollectionUtils.isNotEmpty(rewardJobDOS)) {
log.info("This period job needs to execute tasks: {}", rewardJobDOS.stream()
.map(summaryJobDO -> Long.toString(summaryJobDO.getId()))
.collect(Collectors.joining(", ")));
for (SummaryRewardJobDO rewardJobDO : rewardJobDOS) {
long lastId = 0;
List<UserRewardSummaryDO> userRewardSummaries;
StakingCampaignPoolDO stakingCampaignPoolDO = campaignPoolService.getPoolInfoByPoolId(rewardJobDO.getPoolId());
GemStakingCampaignDO stakingCampaignDO = gemPoolCampaignService.getCampaignByCampaignId(stakingCampaignPoolDO.getCampaignId());
BigDecimal sumStakingAmount = userRewardSummaryMapper.getStageTotalReward(rewardJobDO.getPoolId(), rewardJobDO.getRewardStage());
UserRewardSummaryDOExample userRewardSummaryDOExample = new UserRewardSummaryDOExample();
userRewardSummaryDOExample.createCriteria()
.andPoolIdEqualTo(rewardJobDO.getPoolId())
.andSummaryStageEqualTo(rewardJobDO.getRewardStage())
.andCalStateEqualTo(0);
long count = userRewardSummaryMapper.countByExample(userRewardSummaryDOExample);
if (count == 0) {
summaryRewardJobService.updateJob2Finish(rewardJobDO.getId());
continue;
}
do {
userRewardSummaries = fetchUserRewardSummaries(rewardJobDO.getPoolId(), lastId, rewardJobDO.getRewardStage(), BATCH_SIZE, shardingItem, totalCount);
if (CollectionUtils.isNotEmpty(userRewardSummaries)) {
List<UserRewardSummaryDO> finalUserRewardSummaries = userRewardSummaries;
summaryRewardJobExecutor.submit(() -> {
summaryRewardService.processRewardsTransaction(finalUserRewardSummaries, stakingCampaignPoolDO, sumStakingAmount, stakingCampaignDO);
});
lastId = userRewardSummaries.get(userRewardSummaries.size() - 1).getId();
}
} while (CollectionUtils.isNotEmpty(userRewardSummaries));
}
}
}
private List<UserRewardSummaryDO> fetchUserRewardSummaries(String poolId, long lastId, int summaryStage, int batchSize, int shardingItem, int shardingTotalCount) {
return userRewardSummaryMapper.getUserRewardSummary(poolId, summaryStage, shardingTotalCount, shardingItem, batchSize, lastId);
}
}
lastId 的更新:
lastId 为当前批次最后一条记录的 ID。CollectionUtils.isNotEmpty 的使用:
do-while 循环中使用 CollectionUtils.isNotEmpty 检查列表是否为空,确保仅在有数据时才进行处理。通过在每次批量处理后更新 lastId,你可以确保数据处理的连续性和完整性,避免重复处理或漏处理数据。确保在每次查询后更新 lastId,使下次查询能够继续处理剩余的数据。这样可以确保任务能够正确处理所有分片的数据,并且在大数据量的情况下高效运行。
<select id="getUserRewardSummary" resultMap="BaseResultMap">
select
<include refid="Base_Column_List" />
from user_reward_summary
where
pool_id = #{poolId,jdbcType=CHAR}
and summary_stage= #{summaryStage,jdbcType=INTEGER}
and cal_state=0
and id > id = #{id,jdbcType=BIGINT}
and MOD(id,#{shardingTotalCount,jdbcType=INTEGER})=#{shardingItem,jdbcType=INTEGER}
limit #{limit,jdbcType=INTEGER}
</select>你这个还有个问题,定时任务是循环执行。第一次从0开始。但是第二次就不应该从0开始有可能cal_state从2000开始,就会造成空转
你提到的正确,如果定时任务是循环执行的,id 应该从上次处理的最后一个 ID 开始,而不是每次都从 0 开始。为了实现这一点,可以使用上次处理的最后一个 id 来继续查询。
确保 SQL 查询中正确使用 id 参数来实现分页,并避免空转。你提到的查询条件有一个错误,应该修正为 id > #{id,jdbcType=BIGINT}。
<select id="getUserRewardSummary" resultMap="BaseResultMap">
select
<include refid="Base_Column_List" />
from user_reward_summary
where
pool_id = #{poolId,jdbcType=CHAR}
and summary_stage = #{summaryStage,jdbcType=INTEGER}
and cal_state = 0
and id > #{id,jdbcType=BIGINT}
and MOD(id, #{shardingTotalCount,jdbcType=INTEGER}) = #{shardingItem,jdbcType=INTEGER}
limit #{limit,jdbcType=INTEGER}
</select>
确保在每次批量处理后更新 lastId,从而实现分页效果。
package com.kucoin.gemstakingjob.biz.daemon;
import com.dangdang.ddframe.job.api.ShardingContext;
import com.dangdang.ddframe.job.api.simple.SimpleJob;
import com.kucoin.gemstakingjob.common.dal.dataobject.*;
import com.kucoin.gemstakingjob.common.dal.mapper.UserRewardSummaryMapper;
import com.kucoin.gemstakingjob.core.async.GemStakingThreadPoolConfig;
import com.kucoin.gemstakingjob.core.service.GemPoolCampaignPoolService;
import com.kucoin.gemstakingjob.core.service.GemPoolCampaignService;
import com.kucoin.gemstakingjob.core.service.SummaryRewardJobService;
import com.kucoin.gemstakingjob.core.service.SummaryRewardService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.List;
import java.util.stream.Collectors;
@Component
@Slf4j
public class SummaryRewardTask implements SimpleJob {
private static final int BATCH_SIZE = 1000; // 每批处理的记录数
@Autowired
private SummaryRewardJobService summaryRewardJobService;
@Autowired
private UserRewardSummaryMapper userRewardSummaryMapper;
@Resource(name = GemStakingThreadPoolConfig.GEM_STAKING_SUMMARY_REWARD_JOB_EXECUTOR)
private ThreadPoolTaskExecutor summaryRewardJobExecutor;
@Autowired
private GemPoolCampaignPoolService campaignPoolService;
@Autowired
private GemPoolCampaignService gemPoolCampaignService;
@Autowired
private SummaryRewardService summaryRewardService;
@Override
public void execute(ShardingContext context) {
int totalCount = context.getShardingTotalCount();
int shardingItem = context.getShardingItem();
List<SummaryRewardJobDO> rewardJobDOS = summaryRewardJobService.getSummaryRewardJob();
if (CollectionUtils.isNotEmpty(rewardJobDOS)) {
log.info("This period job needs to execute tasks: {}", rewardJobDOS.stream()
.map(summaryJobDO -> Long.toString(summaryJobDO.getId()))
.collect(Collectors.joining(", ")));
for (SummaryRewardJobDO rewardJobDO : rewardJobDOS) {
long lastId = 0;
List<UserRewardSummaryDO> userRewardSummaries;
StakingCampaignPoolDO stakingCampaignPoolDO = campaignPoolService.getPoolInfoByPoolId(rewardJobDO.getPoolId());
GemStakingCampaignDO stakingCampaignDO = gemPoolCampaignService.getCampaignByCampaignId(stakingCampaignPoolDO.getCampaignId());
BigDecimal sumStakingAmount = userRewardSummaryMapper.getStageTotalReward(rewardJobDO.getPoolId(), rewardJobDO.getRewardStage());
UserRewardSummaryDOExample userRewardSummaryDOExample = new UserRewardSummaryDOExample();
userRewardSummaryDOExample.createCriteria()
.andPoolIdEqualTo(rewardJobDO.getPoolId())
.andSummaryStageEqualTo(rewardJobDO.getRewardStage())
.andCalStateEqualTo(0);
long count = userRewardSummaryMapper.countByExample(userRewardSummaryDOExample);
if (count == 0) {
summaryRewardJobService.updateJob2Finish(rewardJobDO.getId());
continue;
}
do {
userRewardSummaries = fetchUserRewardSummaries(rewardJobDO.getPoolId(), lastId, rewardJobDO.getRewardStage(), BATCH_SIZE, shardingItem, totalCount);
if (CollectionUtils.isNotEmpty(userRewardSummaries)) {
List<UserRewardSummaryDO> finalUserRewardSummaries = userRewardSummaries;
summaryRewardJobExecutor.submit(() -> {
summaryRewardService.processRewardsTransaction(finalUserRewardSummaries, stakingCampaignPoolDO, sumStakingAmount, stakingCampaignDO);
});
lastId = userRewardSummaries.get(userRewardSummaries.size() - 1).getId();
}
} while (CollectionUtils.isNotEmpty(userRewardSummaries));
}
}
}
private List<UserRewardSummaryDO> fetchUserRewardSummaries(String poolId, long lastId, int summaryStage, int batchSize, int shardingItem, int shardingTotalCount) {
return userRewardSummaryMapper.getUserRewardSummary(poolId, summaryStage, shardingTotalCount, shardingItem, batchSize, lastId);
}
}
id 参数来实现分页:and id > #{id,jdbcType=BIGINT}。lastId,确保下次查询能够继续处理剩余的数据。lastId 来实现分页,确保定时任务在循环执行时不会从头开始,从而避免空转。通过这种方式,可以确保定时任务在循环执行时能够正确处理所有数据,并避免空转。确保在每次查询后更新 lastId,使下次查询能够继续处理剩余的数据。这样可以确保任务能够正确处理所有分片的数据,并且在大数据量的情况下高效运行。
还是有问题,有可能id1~10000都已经是计算完成的。从0开始的话,1~10000不是都白跑了么
你提到的正确,考虑到 ID 可能已经被处理过(cal_state 已经被更新为已处理),我们需要确保查询时跳过这些已经处理过的记录。为了解决这个问题,可以引入一个新的策略:
cal_state 作为筛选条件:只查询 cal_state 为未处理(0)的记录。lastId 和 cal_state 进行分页:确保在每次查询时跳过已经处理的记录,并从上次处理的最后一个 ID 开始。确保 SQL 查询只查询 cal_state 为 0 的记录,并使用 id 进行分页:
<select id="getUserRewardSummary" resultMap="BaseResultMap">
select
<include refid="Base_Column_List" />
from user_reward_summary
where
pool_id = #{poolId,jdbcType=CHAR}
and summary_stage = #{summaryStage,jdbcType=INTEGER}
and cal_state = 0
and id > #{id,jdbcType=BIGINT}
and MOD(id, #{shardingTotalCount,jdbcType=INTEGER}) = #{shardingItem,jdbcType=INTEGER}
limit #{limit,jdbcType=INTEGER}
</select>
确保在每次批量处理后更新 lastId,从而实现分页效果,并在每次查询时跳过已处理的记录。
package com.kucoin.gemstakingjob.biz.daemon;
import com.dangdang.ddframe.job.api.ShardingContext;
import com.dangdang.ddframe.job.api.simple.SimpleJob;
import com.kucoin.gemstakingjob.common.dal.dataobject.*;
import com.kucoin.gemstakingjob.common.dal.mapper.UserRewardSummaryMapper;
import com.kucoin.gemstakingjob.core.async.GemStakingThreadPoolConfig;
import com.kucoin.gemstakingjob.core.service.GemPoolCampaignPoolService;
import com.kucoin.gemstakingjob.core.service.GemPoolCampaignService;
import com.kucoin.gemstakingjob.core.service.SummaryRewardJobService;
import com.kucoin.gemstakingjob.core.service.SummaryRewardService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.List;
import java.util.stream.Collectors;
@Component
@Slf4j
public class SummaryRewardTask implements SimpleJob {
private static final int BATCH_SIZE = 1000; // 每批处理的记录数
@Autowired
private SummaryRewardJobService summaryRewardJobService;
@Autowired
private UserRewardSummaryMapper userRewardSummaryMapper;
@Resource(name = GemStakingThreadPoolConfig.GEM_STAKING_SUMMARY_REWARD_JOB_EXECUTOR)
private ThreadPoolTaskExecutor summaryRewardJobExecutor;
@Autowired
private GemPoolCampaignPoolService campaignPoolService;
@Autowired
private GemPoolCampaignService gemPoolCampaignService;
@Autowired
private SummaryRewardService summaryRewardService;
@Override
public void execute(ShardingContext context) {
int totalCount = context.getShardingTotalCount();
int shardingItem = context.getShardingItem();
List<SummaryRewardJobDO> rewardJobDOS = summaryRewardJobService.getSummaryRewardJob();
if (CollectionUtils.isNotEmpty(rewardJobDOS)) {
log.info("This period job needs to execute tasks: {}", rewardJobDOS.stream()
.map(summaryJobDO -> Long.toString(summaryJobDO.getId()))
.collect(Collectors.joining(", ")));
for (SummaryRewardJobDO rewardJobDO : rewardJobDOS) {
long lastId = 0;
List<UserRewardSummaryDO> userRewardSummaries;
StakingCampaignPoolDO stakingCampaignPoolDO = campaignPoolService.getPoolInfoByPoolId(rewardJobDO.getPoolId());
GemStakingCampaignDO stakingCampaignDO = gemPoolCampaignService.getCampaignByCampaignId(stakingCampaignPoolDO.getCampaignId());
BigDecimal sumStakingAmount = userRewardSummaryMapper.getStageTotalReward(rewardJobDO.getPoolId(), rewardJobDO.getRewardStage());
UserRewardSummaryDOExample userRewardSummaryDOExample = new UserRewardSummaryDOExample();
userRewardSummaryDOExample.createCriteria()
.andPoolIdEqualTo(rewardJobDO.getPoolId())
.andSummaryStageEqualTo(rewardJobDO.getRewardStage())
.andCalStateEqualTo(0);
long count = userRewardSummaryMapper.countByExample(userRewardSummaryDOExample);
if (count == 0) {
summaryRewardJobService.updateJob2Finish(rewardJobDO.getId());
continue;
}
do {
userRewardSummaries = fetchUserRewardSummaries(rewardJobDO.getPoolId(), lastId, rewardJobDO.getRewardStage(), BATCH_SIZE, shardingItem, totalCount);
if (CollectionUtils.isNotEmpty(userRewardSummaries)) {
List<UserRewardSummaryDO> finalUserRewardSummaries = userRewardSummaries;
summaryRewardJobExecutor.submit(() -> {
summaryRewardService.processRewardsTransaction(finalUserRewardSummaries, stakingCampaignPoolDO, sumStakingAmount, stakingCampaignDO);
});
lastId = userRewardSummaries.get(userRewardSummaries.size() - 1).getId();
}
} while (CollectionUtils.isNotEmpty(userRewardSummaries));
}
}
}
private List<UserRewardSummaryDO> fetchUserRewardSummaries(String poolId, long lastId, int summaryStage, int batchSize, int shardingItem, int shardingTotalCount) {
return userRewardSummaryMapper.getUserRewardSummary(poolId, summaryStage, shardingTotalCount, shardingItem, batchSize, lastId);
}
}
id 参数来实现分页:and id > #{id,jdbcType=BIGINT}。cal_state 为 0 的记录:and cal_state = 0。lastId,确保下次查询能够继续处理剩余的数据。lastId 来实现分页,确保定时任务在循环执行时不会从头开始,从而避免空转。通过这种方式,可以确保定时任务在循环执行时能够正确处理所有数据,并避免空转。确保在每次查询后更新 lastId,使下次查询能够继续处理剩余的数据。这样可以确保任务能够正确处理所有分片的数据,并且在大数据量的情况下高效运行。
我是说定时任务假设每5分钟运行一次。第二个五分钟跑的时候,第一个已经处理了1000个记录并且设置cal_state = 0了。而id是mysql自增长的。第二个五分钟跑的时候lastId从0开始,不是空跑么
你提到的正确,如果定时任务每5分钟运行一次,且在前一次运行中已经处理了部分记录并将其 cal_state 更新为 1,那么在下一次运行时,不应再从 lastId 为 0 开始,而是应该继续处理未处理的记录。
为了解决这个问题,可以在每次查询时记录上一次处理的最后一个 ID,并在下一次运行时从这个 ID 开始。
以下是一个示例代码,展示了如何实现这一逻辑:
确保 SQL 查询中正确使用 id 参数来实现分页,并跳过已处理的记录:
<select id="getUserRewardSummary" resultMap="BaseResultMap">
select
<include refid="Base_Column_List" />
from user_reward_summary
where
pool_id = #{poolId,jdbcType=CHAR}
and summary_stage = #{summaryStage,jdbcType=INTEGER}
and cal_state = 0
and id > #{lastId,jdbcType=BIGINT}
and MOD(id, #{shardingTotalCount,jdbcType=INTEGER}) = #{shardingItem,jdbcType=INTEGER}
limit #{limit,jdbcType=INTEGER}
</select>
在任务执行过程中记录最后处理的 ID,并在下一次运行时从该 ID 开始查询:
package com.kucoin.gemstakingjob.biz.daemon;
import com.dangdang.ddframe.job.api.ShardingContext;
import com.dangdang.ddframe.job.api.simple.SimpleJob;
import com.kucoin.gemstakingjob.common.dal.dataobject.*;
import com.kucoin.gemstakingjob.common.dal.mapper.UserRewardSummaryMapper;
import com.kucoin.gemstakingjob.core.async.GemStakingThreadPoolConfig;
import com.kucoin.gemstakingjob.core.service.GemPoolCampaignPoolService;
import com.kucoin.gemstakingjob.core.service.GemPoolCampaignService;
import com.kucoin.gemstakingjob.core.service.SummaryRewardJobService;
import com.kucoin.gemstakingjob.core.service.SummaryRewardService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.stream.Collectors;
@Component
@Slf4j
public class SummaryRewardTask implements SimpleJob {
private static final int BATCH_SIZE = 1000; // 每批处理的记录数
private static ConcurrentMap<String, Long> lastProcessedIdMap = new ConcurrentHashMap<>();
@Autowired
private SummaryRewardJobService summaryRewardJobService;
@Autowired
private UserRewardSummaryMapper userRewardSummaryMapper;
@Resource(name = GemStakingThreadPoolConfig.GEM_STAKING_SUMMARY_REWARD_JOB_EXECUTOR)
private ThreadPoolTaskExecutor summaryRewardJobExecutor;
@Autowired
private GemPoolCampaignPoolService campaignPoolService;
@Autowired
private GemPoolCampaignService gemPoolCampaignService;
@Autowired
private SummaryRewardService summaryRewardService;
@Override
public void execute(ShardingContext context) {
int totalCount = context.getShardingTotalCount();
int shardingItem = context.getShardingItem();
List<SummaryRewardJobDO> rewardJobDOS = summaryRewardJobService.getSummaryRewardJob();
if (CollectionUtils.isNotEmpty(rewardJobDOS)) {
log.info("This period job needs to execute tasks: {}", rewardJobDOS.stream()
.map(summaryJobDO -> Long.toString(summaryJobDO.getId()))
.collect(Collectors.joining(", ")));
for (SummaryRewardJobDO rewardJobDO : rewardJobDOS) {
String jobKey = rewardJobDO.getPoolId() + "_" + rewardJobDO.getRewardStage() + "_" + shardingItem;
long lastId = lastProcessedIdMap.getOrDefault(jobKey, 0L);
List<UserRewardSummaryDO> userRewardSummaries;
StakingCampaignPoolDO stakingCampaignPoolDO = campaignPoolService.getPoolInfoByPoolId(rewardJobDO.getPoolId());
GemStakingCampaignDO stakingCampaignDO = gemPoolCampaignService.getCampaignByCampaignId(stakingCampaignPoolDO.getCampaignId());
BigDecimal sumStakingAmount = userRewardSummaryMapper.getStageTotalReward(rewardJobDO.getPoolId(), rewardJobDO.getRewardStage());
UserRewardSummaryDOExample userRewardSummaryDOExample = new UserRewardSummaryDOExample();
userRewardSummaryDOExample.createCriteria()
.andPoolIdEqualTo(rewardJobDO.getPoolId())
.andSummaryStageEqualTo(rewardJobDO.getRewardStage())
.andCalStateEqualTo(0);
long count = userRewardSummaryMapper.countByExample(userRewardSummaryDOExample);
if (count == 0) {
summaryRewardJobService.updateJob2Finish(rewardJobDO.getId());
continue;
}
do {
userRewardSummaries = fetchUserRewardSummaries(rewardJobDO.getPoolId(), lastId, rewardJobDO.getRewardStage(), BATCH_SIZE, shardingItem, totalCount);
if (CollectionUtils.isNotEmpty(userRewardSummaries)) {
List<UserRewardSummaryDO> finalUserRewardSummaries = userRewardSummaries;
summaryRewardJobExecutor.submit(() -> {
summaryRewardService.processRewardsTransaction(finalUserRewardSummaries, stakingCampaignPoolDO, sumStakingAmount, stakingCampaignDO);
});
lastId = userRewardSummaries.get(userRewardSummaries.size() - 1).getId();
lastProcessedIdMap.put(jobKey, lastId); // 更新最后处理的 ID
}
} while (CollectionUtils.isNotEmpty(userRewardSummaries));
}
}
}
private List<UserRewardSummaryDO> fetchUserRewardSummaries(String poolId, long lastId, int summaryStage, int batchSize, int shardingItem, int shardingTotalCount) {
return userRewardSummaryMapper.getUserRewardSummary(poolId, summaryStage, shardingTotalCount, shardingItem, batchSize, lastId);
}
}
使用 ConcurrentMap 记录最后处理的 ID:使用 ConcurrentMap 来记录每个任务的最后处理的 ID,确保在多线程环境下数据的一致性。
private static ConcurrentMap<String, Long> lastProcessedIdMap = new ConcurrentHashMap<>();:声明一个静态的 ConcurrentMap 来记录每个任务的最后处理的 ID。String jobKey = rewardJobDO.getPoolId() + "_" + rewardJobDO.getRewardStage() + "_" + shardingItem;:构造一个唯一的任务键。long lastId = lastProcessedIdMap.getOrDefault(jobKey, 0L);:获取上次处理的最后一个 ID,如果没有则默认从 0 开始。lastProcessedIdMap.put(jobKey, lastId);:更新最后处理的 ID。SQL 查询:确保 SQL 查询中正确使用 id 参数来实现分页,并跳过已处理的记录。
任务逻辑:在每次批量处理后更新 lastId 和 lastProcessedIdMap,确保下次查询能够继续处理剩余的数据。
通过这种方式,可以确保定时任务在循环执行时能够正确处理所有数据,并避免空转。确保在每次查询后更新 lastId,使下次查询能够继续处理剩余的数据。这样可以确保任务能够正确处理所有分片的数据,并且在大数据量的情况下高效运行。
但是要是服务器重启了,数据也丢了
为了确保在服务器重启后数据不丢失,我们需要将 lastId 持久化存储。一个常见的解决方案是将 lastId 保存到数据库中。这样,即使服务器重启,我们也可以从数据库中读取上次处理的 lastId,继续处理剩余的数据。
lastId:创建一个新的表来记录每个任务的 lastId。lastId:在任务开始时从数据库读取 lastId,在任务结束时更新 lastId。创建一个新的表 task_last_id 来记录每个任务的 lastId。
CREATE TABLE task_last_id (
id BIGINT AUTO_INCREMENT PRIMARY KEY,
job_key VARCHAR(255) NOT NULL,
last_id BIGINT NOT NULL,
UNIQUE KEY (job_key)
);
在任务执行过程中读取和更新 lastId。
package com.kucoin.gemstakingjob.biz.daemon;
import com.dangdang.ddframe.job.api.ShardingContext;
import com.dangdang.ddframe.job.api.simple.SimpleJob;
import com.kucoin.gemstakingjob.common.dal.dataobject.*;
import com.kucoin.gemstakingjob.common.dal.mapper.TaskLastIdMapper;
import com.kucoin.gemstakingjob.common.dal.mapper.UserRewardSummaryMapper;
import com.kucoin.gemstakingjob.core.async.GemStakingThreadPoolConfig;
import com.kucoin.gemstakingjob.core.service.GemPoolCampaignPoolService;
import com.kucoin.gemstakingjob.core.service.GemPoolCampaignService;
import com.kucoin.gemstakingjob.core.service.SummaryRewardJobService;
import com.kucoin.gemstakingjob.core.service.SummaryRewardService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.List;
import java.util.stream.Collectors;
@Component
@Slf4j
public class SummaryRewardTask implements SimpleJob {
private static final int BATCH_SIZE = 1000; // 每批处理的记录数
@Autowired
private SummaryRewardJobService summaryRewardJobService;
@Autowired
private UserRewardSummaryMapper userRewardSummaryMapper;
@Autowired
private TaskLastIdMapper taskLastIdMapper;
@Resource(name = GemStakingThreadPoolConfig.GEM_STAKING_SUMMARY_REWARD_JOB_EXECUTOR)
private ThreadPoolTaskExecutor summaryRewardJobExecutor;
@Autowired
private GemPoolCampaignPoolService campaignPoolService;
@Autowired
private GemPoolCampaignService gemPoolCampaignService;
@Autowired
private SummaryRewardService summaryRewardService;
@Override
public void execute(ShardingContext context) {
int totalCount = context.getShardingTotalCount();
int shardingItem = context.getShardingItem();
List<SummaryRewardJobDO> rewardJobDOS = summaryRewardJobService.getSummaryRewardJob();
if (CollectionUtils.isNotEmpty(rewardJobDOS)) {
log.info("This period job needs to execute tasks: {}", rewardJobDOS.stream()
.map(summaryJobDO -> Long.toString(summaryJobDO.getId()))
.collect(Collectors.joining(", ")));
for (SummaryRewardJobDO rewardJobDO : rewardJobDOS) {
String jobKey = rewardJobDO.getPoolId() + "_" + rewardJobDO.getRewardStage() + "_" + shardingItem;
long lastId = taskLastIdMapper.getLastId(jobKey).orElse(0L); // 从数据库获取 lastId
List<UserRewardSummaryDO> userRewardSummaries;
StakingCampaignPoolDO stakingCampaignPoolDO = campaignPoolService.getPoolInfoByPoolId(rewardJobDO.getPoolId());
GemStakingCampaignDO stakingCampaignDO = gemPoolCampaignService.getCampaignByCampaignId(stakingCampaignPoolDO.getCampaignId());
BigDecimal sumStakingAmount = userRewardSummaryMapper.getStageTotalReward(rewardJobDO.getPoolId(), rewardJobDO.getRewardStage());
UserRewardSummaryDOExample userRewardSummaryDOExample = new UserRewardSummaryDOExample();
userRewardSummaryDOExample.createCriteria()
.andPoolIdEqualTo(rewardJobDO.getPoolId())
.andSummaryStageEqualTo(rewardJobDO.getRewardStage())
.andCalStateEqualTo(0);
long count = userRewardSummaryMapper.countByExample(userRewardSummaryDOExample);
if (count == 0) {
summaryRewardJobService.updateJob2Finish(rewardJobDO.getId());
continue;
}
do {
userRewardSummaries = fetchUserRewardSummaries(rewardJobDO.getPoolId(), lastId, rewardJobDO.getRewardStage(), BATCH_SIZE, shardingItem, totalCount);
if (CollectionUtils.isNotEmpty(userRewardSummaries)) {
List<UserRewardSummaryDO> finalUserRewardSummaries = userRewardSummaries;
summaryRewardJobExecutor.submit(() -> {
summaryRewardService.processRewardsTransaction(finalUserRewardSummaries, stakingCampaignPoolDO, sumStakingAmount, stakingCampaignDO);
});
lastId = userRewardSummaries.get(userRewardSummaries.size() - 1).getId();
taskLastIdMapper.updateLastId(jobKey, lastId); // 更新 lastId 到数据库
}
} while (CollectionUtils.isNotEmpty(userRewardSummaries));
}
}
}
private List<UserRewardSummaryDO> fetchUserRewardSummaries(String poolId, long lastId, int summaryStage, int batchSize, int shardingItem, int shardingTotalCount) {
return userRewardSummaryMapper.getUserRewardSummary(poolId, summaryStage, shardingTotalCount, shardingItem, batchSize, lastId);
}
}
package com.kucoin.gemstakingjob.common.dal.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.Optional;
@Mapper
public interface TaskLastIdMapper {
Optional<Long> getLastId(@Param("jobKey") String jobKey);
void updateLastId(@Param("jobKey") String jobKey, @Param("lastId") long lastId);
void insertLastId(@Param("jobKey") String jobKey, @Param("lastId") long lastId);
}
<mapper namespace="com.kucoin.gemstakingjob.common.dal.mapper.TaskLastIdMapper">
<select id="getLastId" resultType="java.lang.Long">
SELECT last_id
FROM task_last_id
WHERE job_key = #{jobKey}
</select>
<update id="updateLastId">
UPDATE task_last_id
SET last_id = #{lastId}
WHERE job_key = #{jobKey}
</update>
<insert id="insertLastId">
INSERT INTO task_last_id (job_key, last_id)
VALUES (#{jobKey}, #{lastId})
</insert>
</mapper>
task_last_id 来记录每个任务的 lastId,确保在服务器重启后数据不丢失。TaskLastIdMapper 接口和相应的 XML 文件,用于从数据库读取和更新 lastId。lastId。lastId 更新到数据库。通过这种方式,可以确保在服务器重启后数据不丢失,并且定时任务能够正确处理所有数据。在每次查询后更新 lastId,使下次查询能够继续处理剩余的数据。这样可以确保任务能够正确处理所有分片的数据,并且在大数据量的情况下高效运行。
<select id="getUserStakingEarnUnClaim" resultMap="BaseResultMap">
select
<include refid="Base_Column_List" />
from user_staking_earn
where
pool_id = #{poolId,jdbcType=CHAR}
and earn_state=0
and id > #{lastId,jdbcType=BIGINT}
and MOD(id,#{shardingTotalCount,jdbcType=INTEGER})=#{shardingItem,jdbcType=INTEGER}
limit #{limit,jdbcType=INTEGER}
</select>我想要让同一个campaign同一个userId的到一个分片,请帮我改写 and MOD(id,#{shardingTotalCount,jdbcType=INTEGER})=#{shardingItem,jdbcType=INTEGER}
要确保同一个 campaign 和 userId 的数据分配到同一个分片,你可以使用 MOD 函数基于 userId 和 campaignId 的组合进行分片。这种方式确保对于相同的 userId 和 campaignId,MOD 计算的结果是相同的,从而确保数据分配到同一个分片。
确保 SQL 查询中使用 MOD 函数基于 campaignId 和 userId 的组合进行分片:
<select id="getUserStakingEarnUnClaim" resultMap="BaseResultMap">
select
<include refid="Base_Column_List" />
from user_staking_earn
where
pool_id = #{poolId,jdbcType=CHAR}
and earn_state = 0
and id > #{lastId,jdbcType=BIGINT}
and MOD(CONCAT(campaign_id, user_id), #{shardingTotalCount,jdbcType=INTEGER}) = #{shardingItem,jdbcType=INTEGER}
limit #{limit,jdbcType=INTEGER}
</select>
CONCAT 函数:确保数据库支持 CONCAT 函数,以将 campaign_id 和 user_id 连接起来。MOD 函数:使用 MOD 函数基于组合后的字符串进行分片计算。确保任务逻辑正确处理分片数据:
package com.kucoin.gemstakingjob.biz.daemon;
import com.dangdang.ddframe.job.api.ShardingContext;
import com.dangdang.ddframe.job.api.simple.SimpleJob;
import com.kucoin.gemstakingjob.common.dal.dataobject.*;
import com.kucoin.gemstakingjob.common.dal.mapper.TaskLastIdMapper;
import com.kucoin.gemstakingjob.common.dal.mapper.UserRewardSummaryMapper;
import com.kucoin.gemstakingjob.core.async.GemStakingThreadPoolConfig;
import com.kucoin.gemstakingjob.core.service.GemPoolCampaignPoolService;
import com.kucoin.gemstakingjob.core.service.GemPoolCampaignService;
import com.kucoin.gemstakingjob.core.service.SummaryRewardJobService;
import com.kucoin.gemstakingjob.core.service.SummaryRewardService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.stream.Collectors;
@Component
@Slf4j
public class SummaryRewardTask implements SimpleJob {
private static final int BATCH_SIZE = 1000; // 每批处理的记录数
private static ConcurrentMap<String, Long> lastProcessedIdMap = new ConcurrentHashMap<>();
@Autowired
private SummaryRewardJobService summaryRewardJobService;
@Autowired
private UserRewardSummaryMapper userRewardSummaryMapper;
@Autowired
private TaskLastIdMapper taskLastIdMapper;
@Resource(name = GemStakingThreadPoolConfig.GEM_STAKING_SUMMARY_REWARD_JOB_EXECUTOR)
private ThreadPoolTaskExecutor summaryRewardJobExecutor;
@Autowired
private GemPoolCampaignPoolService campaignPoolService;
@Autowired
private GemPoolCampaignService gemPoolCampaignService;
@Autowired
private SummaryRewardService summaryRewardService;
@Override
public void execute(ShardingContext context) {
int totalCount = context.getShardingTotalCount();
int shardingItem = context.getShardingItem();
List<SummaryRewardJobDO> rewardJobDOS = summaryRewardJobService.getSummaryRewardJob();
if (CollectionUtils.isNotEmpty(rewardJobDOS)) {
log.info("This period job needs to execute tasks: {}", rewardJobDOS.stream()
.map(summaryJobDO -> Long.toString(summaryJobDO.getId()))
.collect(Collectors.joining(", ")));
for (SummaryRewardJobDO rewardJobDO : rewardJobDOS) {
String jobKey = rewardJobDO.getPoolId() + "_" + rewardJobDO.getRewardStage() + "_" + shardingItem;
long lastId = taskLastIdMapper.getLastId(jobKey).orElse(0L); // 从数据库获取 lastId
List<UserRewardSummaryDO> userRewardSummaries;
StakingCampaignPoolDO stakingCampaignPoolDO = campaignPoolService.getPoolInfoByPoolId(rewardJobDO.getPoolId());
GemStakingCampaignDO stakingCampaignDO = gemPoolCampaignService.getCampaignByCampaignId(stakingCampaignPoolDO.getCampaignId());
BigDecimal sumStakingAmount = userRewardSummaryMapper.getStageTotalReward(rewardJobDO.getPoolId(), rewardJobDO.getRewardStage());
UserRewardSummaryDOExample userRewardSummaryDOExample = new UserRewardSummaryDOExample();
userRewardSummaryDOExample.createCriteria()
.andPoolIdEqualTo(rewardJobDO.getPoolId())
.andSummaryStageEqualTo(rewardJobDO.getRewardStage())
.andCalStateEqualTo(0);
long count = userRewardSummaryMapper.countByExample(userRewardSummaryDOExample);
if (count == 0) {
summaryRewardJobService.updateJob2Finish(rewardJobDO.getId());
continue;
}
do {
userRewardSummaries = fetchUserRewardSummaries(rewardJobDO.getPoolId(), lastId, rewardJobDO.getRewardStage(), BATCH_SIZE, shardingItem, totalCount);
if (CollectionUtils.isNotEmpty(userRewardSummaries)) {
List<UserRewardSummaryDO> finalUserRewardSummaries = userRewardSummaries;
summaryRewardJobExecutor.submit(() -> {
summaryRewardService.processRewardsTransaction(finalUserRewardSummaries, stakingCampaignPoolDO, sumStakingAmount, stakingCampaignDO);
});
lastId = userRewardSummaries.get(userRewardSummaries.size() - 1).getId();
taskLastIdMapper.updateLastId(jobKey, lastId); // 更新 lastId 到数据库
}
} while (CollectionUtils.isNotEmpty(userRewardSummaries));
}
}
}
private List<UserRewardSummaryDO> fetchUserRewardSummaries(String poolId, long lastId, int summaryStage, int batchSize, int shardingItem, int shardingTotalCount) {
return userRewardSummaryMapper.getUserRewardSummary(poolId, summaryStage, shardingTotalCount, shardingItem, batchSize, lastId);
}
}
SQL 查询:
MOD(CONCAT(campaign_id, user_id), #{shardingTotalCount,jdbcType=INTEGER}) 确保同一个 campaign 和 userId 的数据分配到同一个分片。任务逻辑:
lastId,确保下次查询能够继续处理剩余的数据。lastProcessedIdMap 和 taskLastIdMapper 确保在服务器重启后数据不丢失,并从数据库中读取上次处理的 lastId。通过这种方式,可以确保同一个 campaign 和 userId 的数据分配到同一个分片,并在服务器重启后数据不丢失。在每次查询后更新 lastId,使下次查询能够继续处理剩余的数据。这样可以确保任务能够正确处理所有分片的数据,并且在大数据量的情况下高效运行。
那这样id>lastId有可能会不连续吧
你提到的正确,根据 id > lastId 进行分页查询可能会导致不连续的问题,特别是当 id 不是连续的。为了解决这个问题,我们可以使用其他方法来确保分页的连续性,例如基于复合键(campaign_id 和 user_id)进行分片,并使用这些键来确保数据的唯一性和连续性。
campaign_id 和 user_id 的数据分配到同一个分片。campaign_id 和 user_id:通过分页查询时使用 campaign_id 和 user_id 来确保数据的连续性。确保 SQL 查询中正确使用复合键来进行分片,并使用分页查询来确保数据的连续性:
<select id="getUserStakingEarnUnClaim" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List" />
FROM user_staking_earn
WHERE
pool_id = #{poolId,jdbcType=CHAR}
AND earn_state = 0
AND (campaign_id, user_id) > (#{lastCampaignId,jdbcType=VARCHAR}, #{lastUserId,jdbcType=VARCHAR})
AND MOD(CONCAT(campaign_id, user_id), #{shardingTotalCount,jdbcType=INTEGER}) = #{shardingItem,jdbcType=INTEGER}
LIMIT #{limit,jdbcType=INTEGER}
</select>
确保任务逻辑正确处理分页数据,并在每次批量处理后更新 lastCampaignId 和 lastUserId:
package com.kucoin.gemstakingjob.biz.daemon;
import com.dangdang.ddframe.job.api.ShardingContext;
import com.dangdang.ddframe.job.api.simple.SimpleJob;
import com.kucoin.gemstakingjob.common.dal.dataobject.*;
import com.kucoin.gemstakingjob.common.dal.mapper.TaskLastIdMapper;
import com.kucoin.gemstakingjob.common.dal.mapper.UserRewardSummaryMapper;
import com.kucoin.gemstakingjob.core.async.GemStakingThreadPoolConfig;
import com.kucoin.gemstakingjob.core.service.GemPoolCampaignPoolService;
import com.kucoin.gemstakingjob.core.service.GemPoolCampaignService;
import com.kucoin.gemstakingjob.core.service.SummaryRewardJobService;
import com.kucoin.gemstakingjob.core.service.SummaryRewardService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.stream.Collectors;
@Component
@Slf4j
public class SummaryRewardTask implements SimpleJob {
private static final int BATCH_SIZE = 1000; // 每批处理的记录数
private static ConcurrentMap<String, String> lastProcessedCampaignIdMap = new ConcurrentHashMap<>();
private static ConcurrentMap<String, String> lastProcessedUserIdMap = new ConcurrentHashMap<>();
@Autowired
private SummaryRewardJobService summaryRewardJobService;
@Autowired
private UserRewardSummaryMapper userRewardSummaryMapper;
@Autowired
private TaskLastIdMapper taskLastIdMapper;
@Resource(name = GemStakingThreadPoolConfig.GEM_STAKING_SUMMARY_REWARD_JOB_EXECUTOR
但是我只有主键ID是自增长的bigint,campaignId和userId都是24未唯一字符串
明白了,如果 campaignId 和 userId 是唯一的字符串,并且你只有一个自增长的主键 id,你可以继续使用 id 作为分页的依据,但需要确保查询条件和逻辑的正确性,以避免数据不连续的问题。以下是修改后的方案:
确保 SQL 查询中正确使用 id 进行分页,并使用复合键进行分片:
<select id="getUserStakingEarnUnClaim" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List" />
FROM user_staking_earn
WHERE
pool_id = #{poolId,jdbcType=CHAR}
AND earn_state = 0
AND id > #{lastId,jdbcType=BIGINT}
AND MOD(CONCAT(campaign_id, user_id), #{shardingTotalCount,jdbcType=INTEGER}) = #{shardingItem,jdbcType=INTEGER}
LIMIT #{limit,jdbcType=INTEGER}
</select>
确保任务逻辑正确处理分页数据,并在每次批量处理后更新 lastId:
package com.kucoin.gemstakingjob.biz.daemon;
import com.dangdang.ddframe.job.api.ShardingContext;
import com.dangdang.ddframe.job.api.simple.SimpleJob;
import com.kucoin.gemstakingjob.common.dal.dataobject.*;
import com.kucoin.gemstakingjob.common.dal.mapper.TaskLastIdMapper;
import com.kucoin.gemstakingjob.common.dal.mapper.UserRewardSummaryMapper;
import com.kucoin.gemstakingjob.core.async.GemStakingThreadPoolConfig;
import com.kucoin.gemstakingjob.core.service.GemPoolCampaignPoolService;
import com.kucoin.gemstakingjob.core.service.GemPoolCampaignService;
import com.kucoin.gemstakingjob.core.service.SummaryRewardJobService;
import com.kucoin.gemstakingjob.core.service.SummaryRewardService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.stream.Collectors;
@Component
@Slf4j
public class SummaryRewardTask implements SimpleJob {
private static final int BATCH_SIZE = 1000; // 每批处理的记录数
private static ConcurrentMap<String, Long> lastProcessedIdMap = new ConcurrentHashMap<>();
@Autowired
private SummaryRewardJobService summaryRewardJobService;
@Autowired
private UserRewardSummaryMapper userRewardSummaryMapper;
@Autowired
private TaskLastIdMapper taskLastIdMapper;
@Resource(name = GemStakingThreadPoolConfig.GEM_STAKING_SUMMARY_REWARD_JOB_EXECUTOR)
private ThreadPoolTaskExecutor summaryRewardJobExecutor;
@Autowired
private GemPoolCampaignPoolService campaignPoolService;
@Autowired
private GemPoolCampaignService gemPoolCampaignService;
@Autowired
private SummaryRewardService summaryRewardService;
@Override
public void execute(ShardingContext context) {
int totalCount = context.getShardingTotalCount();
int shardingItem = context.getShardingItem();
List<SummaryRewardJobDO> rewardJobDOS = summaryRewardJobService.getSummaryRewardJob();
if (CollectionUtils.isNotEmpty(rewardJobDOS)) {
log.info("This period job needs to execute tasks: {}", rewardJobDOS.stream()
.map(summaryJobDO -> Long.toString(summaryJobDO.getId()))
.collect(Collectors.joining(", ")));
for (SummaryRewardJobDO rewardJobDO : rewardJobDOS) {
String jobKey = rewardJobDO.getPoolId() + "_" + rewardJobDO.getRewardStage() + "_" + shardingItem;
long lastId = taskLastIdMapper.getLastId(jobKey).orElse(0L); // 从数据库获取 lastId
List<UserRewardSummaryDO> userRewardSummaries;
StakingCampaignPoolDO stakingCampaignPoolDO = campaignPoolService.getPoolInfoByPoolId(rewardJobDO.getPoolId());
GemStakingCampaignDO stakingCampaignDO = gemPoolCampaignService.getCampaignByCampaignId(stakingCampaignPoolDO.getCampaignId());
BigDecimal sumStakingAmount = userRewardSummaryMapper.getStageTotalReward(rewardJobDO.getPoolId(), rewardJobDO.getRewardStage());
UserRewardSummaryDOExample userRewardSummaryDOExample = new UserRewardSummaryDOExample();
userRewardSummaryDOExample.createCriteria()
.andPoolIdEqualTo(rewardJobDO.getPoolId())
.andSummaryStageEqualTo(rewardJobDO.getRewardStage())
.andCalStateEqualTo(0);
long count = userRewardSummaryMapper.countByExample(userRewardSummaryDOExample);
if (count == 0) {
summaryRewardJobService.updateJob2Finish(rewardJobDO.getId());
continue;
}
do {
userRewardSummaries = fetchUserRewardSummaries(rewardJobDO.getPoolId(), lastId, rewardJobDO.getRewardStage(), BATCH_SIZE, shardingItem, totalCount);
if (CollectionUtils.isNotEmpty(userRewardSummaries)) {
List<UserRewardSummaryDO> finalUserRewardSummaries = userRewardSummaries;
summaryRewardJobExecutor.submit(() -> {
summaryRewardService.processRewardsTransaction(finalUserRewardSummaries, stakingCampaignPoolDO, sumStakingAmount, stakingCampaignDO);
});
lastId = userRewardSummaries.get(userRewardSummaries.size() - 1).getId();
taskLastIdMapper.updateLastId(jobKey, lastId); // 更新 lastId 到数据库
}
} while (CollectionUtils.isNotEmpty(userRewardSummaries));
}
}
}
private List<UserRewardSummaryDO> fetchUserRewardSummaries(String poolId, long lastId, int summaryStage, int batchSize, int shardingItem, int shardingTotalCount) {
return userRewardSummaryMapper.getUserRewardSummary(poolId, summaryStage, shardingTotalCount, shardingItem, batchSize, lastId);
}
}
SQL 查询:
MOD(CONCAT(campaign_id, user_id), #{shardingTotalCount,jdbcType=INTEGER}) 确保同一个 campaignId 和 userId 的数据分配到同一个分片。id > #{lastId,jdbcType=BIGINT} 确保分页查询。任务逻辑:
lastId,确保下次查询能够继续处理剩余的数据。lastProcessedIdMap 和 taskLastIdMapper 确保在服务器重启后数据不丢失,并从数据库中读取上次处理的 lastId。通过这种方式,可以确保同一个 campaignId 和 userId 的数据分配到同一个分片,并在服务器重启后数据不丢失。在每次查询后更新 lastId,使下次查询能够继续处理剩余的数据。这样可以确保任务能够正确处理所有分片的数据,并且在大数据量的情况下高效运行。
package com.kucoin.gemstaking.core.config;
import com.kucoin.gemstaking.core.enums.MessageTopicEnum;
import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
@author: sean.zhao
@date: Created by sean.zhao on 2023/03/08 17:44
@Description:
*/
@Slf4j
@Configuration
public class KafkaConfig {
@Value("#{'${kucoin.kafka.consumer.stakingHold.bootstrap-servers}'.split(',')}")
private List<String> gemStakingHoldKafkaServers;
@Value("${kucoin.kafka.consumer.stakingHold.max-poll-records:1000}")
private String orderMaxPollRecords;
@Value("${kucoin.kafka.consumer.stakingHold.fetch-max-wait-ms:500}")
private String orderFetchMaxWaitMs;
@Value("${kucoin.kafka.consumer.stakingHold.group-id:gem-pool}")
private String orderGroupId;
/**
*
*
@return
*/
@Bean
public Consumer<String, String> symbolSyncKafkaConsumer() {
Map<String, Object> config = new HashMap<>(8);
config.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
config.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
config.put(ConsumerConfig.GROUP_ID_CONFIG, orderGroupId);
config.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
config.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, orderMaxPollRecords);
config.put(ConsumerConfig.FETCH_MAX_WAIT_MS_CONFIG, orderFetchMaxWaitMs);
config.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, gemStakingHoldKafkaServers);
config.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
KafkaConsumer<String, String> consumer = new KafkaConsumer(config);
//设置订阅的消息队列和分区
String topic = MessageTopicEnum.SPOT_GEM_POOL_STAKING_HOLD.getCode();
log.info("symbolSyncKafkaConsumer bootstrap.servers: {}", gemStakingHoldKafkaServers);
return consumer;
}
}
想得到Kafka的这个consumer去消费topic,补全symbolSyncKafkaConsumer方法
要补全 symbolSyncKafkaConsumer 方法,使其能够正确订阅 Kafka 主题并消费消息,你需要完成以下步骤:
subscribe 方法订阅一个或多个主题。assign 方法。以下是补全后的 symbolSyncKafkaConsumer 方法:
package com.kucoin.gemstaking.core.config;
import com.kucoin.gemstaking.core.enums.MessageTopicEnum;
import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.time.Duration;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Kafka Configuration
* @author: sean.zhao
* @date: Created by sean.zhao on 2023/03/08 17:44
*/
@Slf4j
@Configuration
public class KafkaConfig {
@Value("#{'${kucoin.kafka.consumer.stakingHold.bootstrap-servers}'.split(',')}")
private List<String> gemStakingHoldKafkaServers;
@Value("${kucoin.kafka.consumer.stakingHold.max-poll-records:1000}")
private String orderMaxPollRecords;
@Value("${kucoin.kafka.consumer.stakingHold.fetch-max-wait-ms:500}")
private String orderFetchMaxWaitMs;
@Value("${kucoin.kafka.consumer.stakingHold.group-id:gem-pool}")
private String orderGroupId;
/**
* Kafka Consumer for symbol synchronization
* @return Kafka Consumer
*/
@Bean
public Consumer<String, String> symbolSyncKafkaConsumer() {
Map<String, Object> config = new HashMap<>(8);
config.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
config.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
config.put(ConsumerConfig.GROUP_ID_CONFIG, orderGroupId);
config.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
config.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, orderMaxPollRecords);
config.put(ConsumerConfig.FETCH_MAX_WAIT_MS_CONFIG, orderFetchMaxWaitMs);
config.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, gemStakingHoldKafkaServers);
config.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
KafkaConsumer<String, String> consumer = new KafkaConsumer<>(config);
// 设置订阅的消息队列
String topic = MessageTopicEnum.SPOT_GEM_POOL_STAKING_HOLD.getCode();
consumer.subscribe(Collections.singletonList(topic));
log.info("symbolSyncKafkaConsumer bootstrap.servers: {}", gemStakingHoldKafkaServers);
return consumer;
}
}
配置 Kafka Consumer:
ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG 和 ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG:使用 StringDeserializer 反序列化消息的键和值。ConsumerConfig.GROUP_ID_CONFIG:设置消费者组 ID。ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG:禁用自动提交偏移量。ConsumerConfig.MAX_POLL_RECORDS_CONFIG:设置每次拉取的最大记录数。ConsumerConfig.FETCH_MAX_WAIT_MS_CONFIG:设置 fetch 请求的最大等待时间。ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG:设置 Kafka 服务器地址。ConsumerConfig.AUTO_OFFSET_RESET_CONFIG:设置消费者在没有初始偏移量或偏移量超出范围时的行为。订阅主题:
consumer.subscribe(Collections.singletonList(topic)) 方法订阅主题 SPOT_GEM_POOL_STAKING_HOLD。日志记录:
你可以在服务类中使用这个 Consumer 来处理消息。例如:
import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.time.Duration;
@Service
public class KafkaConsumerService {
@Autowired
private Consumer<String, String> symbolSyncKafkaConsumer;
public void consumeMessages() {
while (true) {
ConsumerRecords<String, String> records = symbolSyncKafkaConsumer.poll(Duration.ofMillis(1000));
for (ConsumerRecord<String, String> record : records) {
log.info("Consumed message: key = {}, value = {}, offset = {}, partition = {}",
record.key(), record.value(), record.offset(), record.partition());
// 处理消息
processMessage(record);
// 手动提交偏移量
symbolSyncKafkaConsumer.commitSync();
}
}
}
private void processMessage(ConsumerRecord<String, String> record) {
// 实现消息处理逻辑
}
}
在应用程序启动时调用 consumeMessages 方法:
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
@Component
public class KafkaConsumerRunner implements CommandLineRunner {
@Autowired
private KafkaConsumerService kafkaConsumerService;
@Override
public void run(String... args) {
kafkaConsumerService.consumeMessages();
}
}
通过上述配置和代码,你可以创建一个 Kafka Consumer 来订阅和消费消息。确保在配置和使用过程中正确处理消息,并手动提交偏移量,以确保消息的高效和可靠消费。