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方法内到三个表的更新或者插入操作是一个事务的吗

2024-06-17by@lvxing_ood-hcvmu&@GPT-4.Model: GPT-4
lvxing_ood-hcvmu

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方法内到三个表的更新或者插入操作是一个事务的吗

Avatar
Avatar

是的,processAfterTransferSuccess 和 processAfterTransferFail 方法内的操作都是在同一个事务中进行的。以下是一些关键点:

  1. @Transactional 注解:这两个方法都被 @Transactional 注解修饰。这意味着方法内的所有操作(如数据库的插入、更新等)要么全部成功,要么全部回滚,不会出现部分成功部分失败的情况。Spring 的事务管理器会确保这一点。

  2. 多个数据库操作:在 processAfterTransferSuccess 和 processAfterTransferFail 方法内,你可以看到对多个表的更新和插入操作。这些操作包括对 UserTransferLogDO、StakingPoolOrderDO 和 UserStakingHoldDO 表的更新或插入。这些操作都是在同一个事务上下文中进行的。

  3. 事务的一致性和原子性:由于 @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 方法内的所有数据库更新或插入操作都在同一个事务中进行。

lvxing_ood-hcvmu

事务是生效的吗

Avatar
Avatar

要确保 @Transactional 注解的事务管理真正生效,需要确认以下几个要点:

  1. 事务管理器配置正确:确保 Spring 配置了正确的事务管理器。通常在 Spring Boot 中,这些配置是自动完成的,但在某些情况下(例如自定义配置、使用特定的数据库等),你可能需要手动配置事务管理器。

  2. Spring AOP 的代理机制:Spring 的事务管理是基于 AOP(面向方面编程)的,需要确保代理机制正常工作。如果你的 Spring Bean 是通过 @Autowired 注入的,并且事务方法是在同一个类内调用的,Spring 的代理机制可能无法捕获事务注解。为确保事务生效,建议将事务方法放在单独的服务层类中,并通过 Spring 容器管理这些 Bean 的注入。

  3. 事务传播属性:默认情况下,@Transactional 注解使用传播属性 REQUIRED,这意味着如果当前已经存在一个事务,则该方法将在现有事务中运行;如果没有事务,则会启动一个新的事务。在大多数情况下,这种传播行为是可以满足需求的。

  4. 异常处理:确保方法内部抛出的异常没有被捕获并吞掉。Spring 的事务机制默认只在遇到未捕获的运行时异常时才会回滚事务。你可以通过配置 @Transactional 注解的 rollbackFor 属性来指定需要回滚的异常类型。

以下是一些常见的检查点,确保事务管理生效:

1. 检查 Spring 配置

确保 Spring Boot 或 Spring 配置文件中有启用事务管理的配置:

@SpringBootApplication
@EnableTransactionManagement
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

2. 确保 @Transactional 注解放置正确

确保你的事务方法位于 Spring 管理的 Bean 中,并且是通过容器注入的方式调用:

@Service
public class StakingTransactionProcessServiceImpl implements StakingTransactionProcessService {
    // Service methods here
}

3. 确保事务方法不是在同一个类内调用

事务方法如果在同一个类内调用,事务管理可能不会生效,因为 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
    }
}

4. 捕获异常并回滚

确保遇到异常时事务会回滚:

@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
    }
}

5. 日志和调试

查看日志和调试信息,确保事务管理器正确工作。你可以在日志中查找有关事务开始、提交和回滚的消息:

logging:
  level:
    org.springframework.transaction: DEBUG

通过以上检查,你可以确保 @Transactional 注解的事务管理生效。如果所有这些配置都正确,你的方法中的数据库操作将会在一个事务中执行,并且在遇到错误时会自动回滚。

lvxing_ood-hcvmu

我上面贴的那个类的事务是否是生效的

Avatar
Avatar

要确定你提供的类中的事务是否生效,需要检查以下几个关键点:

  1. @Transactional 注解的位置:确保 @Transactional 注解放置在需要事务管理的方法上。
  2. Spring AOP 代理机制:确保调用事务方法时,Spring AOP 代理机制能够正确拦截。
  3. 异常处理:确保事务方法中的异常没有被捕获并吞掉,以便 Spring 能够正确回滚事务。
  4. Spring 配置:确保 Spring 配置启用了事务管理。

从你提供的代码来看,@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) {
        // 方法实现
    }
}

为了验证事务是否生效,可以通过以下几步检查:

1. 确保 Spring 配置启用了事务管理

@SpringBootApplication
@EnableTransactionManagement
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

2. 确保 StakingTransactionProcessServiceImpl 是通过 Spring 容器管理的

确保你的服务类是通过 Spring 容器管理的,并且是通过依赖注入的方式调用,而不是直接实例化。

3. 检查方法调用路径

确保事务方法是在类外部被调用的,而不是在同一个类中调用。Spring 的事务管理是基于 AOP 的,如果方法在同一个类中调用,事务将不会生效。

例如:

@Service
public class SomeOtherService {

    @Autowired
    private StakingTransactionProcessService stakingTransactionProcessService;

    public void someMethod() {
        // 调用事务方法
        stakingTransactionProcessService.processAfterTransferSuccess(...);
    }
}

4. 检查日志

启用 Spring 的事务日志,可以帮助你确定事务是否生效。在 application.properties 或 application.yml 中添加以下配置:

logging:
  level:
    org.springframework.transaction: DEBUG

然后检查日志,确保你看到事务开始、提交或回滚的日志消息。

5. 异常处理

确保在事务方法中,异常没有被捕获并吞掉:

@Override
@Transactional
public void processAfterTransferSuccess(UserTransferLogDO transferLogDO, StakingPoolOrderDO orderOpsDO) {
    try {
        // 你的事务代码
    } catch (Exception e) {
        log.error("Error occurred during transaction", e);
        throw e; // 确保异常被抛出,以便事务回滚
    }
}

6. 测试事务

你可以编写一个测试用例,模拟事务方法中的异常,看看事务是否会回滚。例如:

@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 注解应该能够正常工作。

lvxing_ood-hcvmu

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);
} 这段代码能起到分布式锁的作用吗?需要怎么改进

Avatar
Avatar

这段代码在某种程度上可以实现分布式锁的作用,但是它并不是一个真正的分布式锁实现。主要问题在于它不能保证原子性操作,即检查和设置值不是原子操作,这可能会导致竞争条件问题。要实现一个真正的分布式锁,需要使用 Redis 提供的原子操作。

改进建议

  1. 使用 Redis 的原子操作:Redis 提供了 SET NX(仅在键不存在时设置键)和 EX(设置键的过期时间)选项,可以确保设置键和值是一个原子操作。
  2. 设置过期时间:确保锁设置了过期时间,以防止在某些情况下(如进程崩溃)锁永远不会释放。

以下是使用 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);
        }
    }
}

解释

  1. setIfAbsent 方法:这个方法等价于 Redis 的 SET NX 命令,它会在键不存在时设置键,并返回一个布尔值表示设置是否成功。
  2. 过期时间:通过 setIfAbsent 的第三和第四个参数设置过期时间,确保锁不会永久存在。
  3. 释放锁:在业务逻辑完成后,通过 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,可以实现更可靠的分布式锁。

lvxing_ood-hcvmu

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();
}
}
} 该方法有没有问题

Avatar
Avatar

你的 createRedeemOrder 方法总体上是正确的,但仍有一些潜在问题和改进空间。下面是一些详细的建议:

1. 锁定尝试时间

在调用 lock.tryLock() 时,你没有指定等待时间。如果 Redis 出现问题或锁被其他线程持有,tryLock 将立即返回 false。为了提高鲁棒性,可以增加一个等待时间。

AssertUtil.assertTrue(lock.tryLock(10, TimeUnit.SECONDS), "error.createRedeemOrder.existsRedeeming", CommonErrorCode.RATE_LIMITED);

2. 锁释放

确保锁在最终块中释放,并且在任何情况下都能正确释放。你已经在 finally 块中处理了锁的释放,这很好。确保 lock.isHeldByCurrentThread() 只是一个安全检查。

3. 异常处理

你捕获了 BizException 和 Exception,并根据不同的情况抛出 BaseException。确保所有异常都能正确处理,尤其是那些可能导致事务失败的异常。

4. 事务控制

确保 transactionProcessService.processAfterTransferSuccess 和 transactionProcessService.processAfterTransferFail 方法中的事务控制是正确的。你已经在这些方法上使用了 @Transactional 注解,所以事务控制应该是有效的。

5. 代码结构

为了更清晰和易于维护,建议将某些逻辑分解成单独的方法。例如,创建订单和转账记录的逻辑可以提取到单独的方法中。

6. 日志记录

确保在关键路径上添加日志记录,方便以后调试和监控。

修改后的代码示例

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);
}

总结

  1. 增加锁定尝试时间:在 tryLock 方法中增加等待时间,提高鲁棒性。
  2. 确保锁释放:在 finally 块中释放锁,以确保无论发生什么情况都能正确释放锁。
  3. 处理所有异常:确保所有异常都能正确处理,并且不会导致事务失败。
  4. 重构代码:将逻辑分解成更小的方法,提高代码可读性和可维护性。
  5. 日志记录:增加日志记录,以便更好地监控和调试。

通过这些改进,你的 createRedeemOrder 方法将会更加健壮和可维护。

lvxing_ood-hcvmu

<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接口

Avatar
Avatar

根据你提供的 MyBatis 映射文件中的 updateParticipantsAndAmount 更新语句,我们可以编写相应的 Mapper 接口。以下是一个示例:

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 映射文件

确保你的 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");
        }
    }
}

总结

  1. Mapper 接口:定义一个包含 updateParticipantsAndAmount 方法的 Mapper 接口。
  2. MyBatis 映射文件:确保映射文件中的 SQL 语句与方法正确映射。
  3. 服务层调用:在服务层注入 Mapper 并调用 updateParticipantsAndAmount 方法来执行更新操作。

通过这些步骤,你就可以在 Java 代码中调用 MyBatis 映射文件中的 updateParticipantsAndAmount 方法来更新数据库中的记录。

lvxing_ood-hcvmu

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")
什么意思

Avatar
Avatar

@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 的数据,方法将被执行,并将返回值缓存起来。
  • 缓存条目将过期时间设置为60秒,并且每5秒刷新一次。

注意事项

  1. 缓存管理器:确保你已经配置了合适的缓存管理器(如 Redis、EhCache 等)来处理这些缓存条目。
  2. 缓存配置:根据你们的实际需求和缓存策略,配置缓存的过期时间和刷新时间。

通过合理使用缓存注解,可以显著提升应用的性能,减少数据库的压力。

lvxing_ood-hcvmu

如果5秒刷新一次,这样的话,这个ek y

Avatar
Avatar

如果缓存每5秒刷新一次,这意味着缓存将会在每5秒钟重新加载一次数据,而不会等到缓存过期(60秒)才重新加载。这种配置适用于一些数据变化频率较高的场景,确保数据在缓存中的时效性较高。

不过在标准的 Spring Cache 注解中,@Cacheable 注解并没有提供直接设置刷新时间的功能。你提到的 #60#5 是一种自定义的缓存策略配置,可能是你们团队或框架的特定实现。通常情况下,我们需要借助一些高级的缓存管理库(例如 Caffeine 或 Redis)来实现这种行为。

实现刷新时间的常见方法

使用 Caffeine Cache

Caffeine 是一个高性能的 Java 缓存库,支持缓存刷新机制。以下是一个使用 Caffeine 实现缓存刷新时间的示例:

  1. 引入依赖

    在 pom.xml 中添加 Caffeine 依赖:

    <dependency>
        <groupId>com.github.ben-manes.caffeine</groupId>
        <artifactId>caffeine</artifactId>
        <version>2.9.2</version>
    </dependency>
    
  2. 配置 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;
        }
    }
    
  3. 使用缓存

    在服务类中使用缓存注解:

    @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 Cache

如果你使用的是 Redis 作为缓存,并且希望实现类似的刷新机制,你可能需要在缓存失效前主动更新缓存。这通常需要一些额外的逻辑来实现。

总结

在标准的 Spring Cache 注解中,@Cacheable 注解不支持直接设置刷新时间。你提到的 #60#5 配置可能是你们团队或框架的特定实现,如果你使用的是标准 Spring Cache,你需要借助像 Caffeine 这样的高级缓存库来实现缓存刷新机制。

通过合理配置缓存策略,可以在保证数据时效性的同时,提高系统性能,减少数据库的压力。

lvxing_ood-hcvmu

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;
}

Avatar
Avatar

你提供的 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;
    }
}

解释

  1. 累加奖金:在累加奖金时,使用 userBonus = userBonus.add(userStakingTaskBonusDO.getBonusCoefficient()) 来确保累加操作正确。
  2. 处理 VIP 奖励:添加了一个 handleVipBonus 方法,用于处理 VIP 奖励的特殊逻辑。你可以根据具体业务需求实现这个方法。
  3. 改进代码结构:将累加奖金和处理 VIP 奖励的逻辑分开,使代码更加清晰和易于维护。

详细说明

  • CollectionUtils.isNotEmpty:使用 CollectionUtils.isNotEmpty 来检查集合是否为空,可以避免空指针异常。
  • 累加操作:BigDecimal 是不可变对象,add 方法会返回一个新的 BigDecimal 对象,因此需要将结果赋值回 userBonus。
  • VIP 处理:添加了一个私有方法 handleVipBonus,用于处理 VIP 奖励的特殊逻辑。你可以根据实际需求实现这个方法。

通过这些改进,你的 getUserBonusByUserAndCampaign 方法将更加健壮和易于维护。

lvxing_ood-hcvmu

String bonusCoefficient = stakingBonusTaskVipconfigDO.getBonusCoefficient(); bonusCoefficient的格式是{"1":"1.2","2":"1.333","12":"0.2"},请用fastjson或者gson帮忙解析这个字符串并按照"1"取出value

Avatar
Avatar

你可以使用 FastJSON 或 Gson 来解析 JSON 字符串,并提取指定键的值。以下是两种方法的示例:

使用 FastJSON

首先,确保你已经在项目中引入了 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

首先,确保你已经在项目中引入了 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);
    }
}

总结

  • FastJSON:使用 JSON.parseObject 方法将 JSON 字符串解析为 JSONObject,然后使用 jsonObject.getString("1") 获取指定键的值。
  • Gson:使用 gson.fromJson 方法将 JSON 字符串解析为 JsonObject,然后使用 jsonObject.get("1").getAsString() 获取指定键的值。

你可以根据自己的项目依赖和开发习惯选择使用 FastJSON 或 Gson。两者都能方便地解析 JSON 字符串并提取指定键的值。

lvxing_ood-hcvmu

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;
}

Avatar
Avatar

你的 handleVIPBonus 方法大致上是正确的,但有一些需要改进的地方:

  1. 解析用户的 VIP 等级对应的加成系数:目前你只解析了 VIP 等级为 1 的加成系数。你需要根据用户的实际 VIP 等级来获取相应的加成系数。
  2. 异常处理:解析 JSON 时可能会出现异常,需要适当处理。
  3. 代码结构:优化代码结构,提高可读性。

改进后的代码

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;
    }
}

解释

  1. 解析用户的 VIP 等级对应的加成系数:使用 getVipBonusCoefficient 方法来解析 JSON 字符串,并根据用户的实际 VIP 等级获取相应的加成系数。
  2. 异常处理:在 getVipBonusCoefficient 方法中添加了异常处理,以防在解析 JSON 时发生错误。
  3. 代码结构优化:将解析 JSON 的逻辑提取到单独的方法 getVipBonusCoefficient 中,提高了代码的可读性和可维护性。

详细说明

  • CollectionUtils.isNotEmpty:检查集合是否为空,避免空指针异常。
  • getVipBonusCoefficient 方法:用于解析 JSON 字符串,并根据 VIP 等级获取相应的加成系数。如果解析失败或没有找到对应的 VIP 等级,返回 BigDecimal.ZERO。
  • 异常处理:在解析 JSON 时添加了异常处理,以防止解析错误导致程序崩溃。

通过这些改进,你的 handleVIPBonus 方法将更加健壮和易于维护。

lvxing_ood-hcvmu

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;
}

}

Avatar
Avatar

你的代码基本上是正确的,但是有一些可以改进的地方,特别是在代码结构和异常处理方面。以下是一些改进建议:

  1. 异常处理和日志记录:在处理异常时,记录详细的日志信息,以便更容易排查问题。
  2. 代码结构优化:将一些重复的逻辑提取到单独的方法中,提高代码的可读性和可维护性。
  3. 常量使用:对于常量值(如任务类型 1),使用常量字段代替直接使用数字,以提高代码的可读性和可维护性。

改进后的代码

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;
    }
}

主要改进点

  1. 常量使用:

    • 定义了 VIP_TASK_TYPE 常量,避免直接使用数字,提高代码可读性。
  2. 提取方法:

    • 将获取用户质押任务奖金的逻辑提取到 getUserStakingTaskBonuses 方法中。
    • 这样可以使 getUserBonusByUserAndCampaign 方法更简洁。
  3. 异常处理:

    • 在解析 JSON 时,添加详细的日志记录以便更容易排查问题。
    • 使用 log.error 记录详细的错误信息,包括 bonusCoefficient 和异常堆栈信息。
  4. 代码结构优化:

    • 优化了 handleVIPBonus 方法的逻辑,提高了代码的可读性和可维护性。

通过这些改进,你的代码将更加健壮、易读和易于维护。

lvxing_ood-hcvmu

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分组,统计待领取的收益总额。

Avatar
Avatar

要根据 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,因此不计入待领取收益)。

通过这种方式,你可以轻松统计每个池子的待领取收益总额。

lvxing_ood-hcvmu

请生成sql根据campaign_id分组,返回每个campaign已领取的数量、未领取的数量、earn_token、earn_token_logo,每个campaign只有一个earn_token,有多个pool

Avatar
Avatar

要根据 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。

lvxing_ood-hcvmu

还需要返回pool_id

Avatar
Avatar

要在结果中包含 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。

lvxing_ood-hcvmu

claimed_count这不是想要的,而是想要待领取的earn_amount

Avatar
Avatar

明白了,你希望返回每个 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。

lvxing_ood-hcvmu

<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> 请帮忙纠正一下

Avatar
Avatar

你的 SQL 语句中有一些小问题需要纠正:

  1. 多余的逗号:在 AS pool_unclaimed_rewards 后面有一个多余的逗号。
  2. 缺少 pool_id 的选择:虽然你在 GROUP BY 中使用了 pool_id,但是在 SELECT 子句中没有选择 pool_id。
  3. SQL 语法:确保所有的关键词和标识符按照正确的 SQL 语法编写。

以下是修正后的 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>

解释

  1. 选择的字段:

    • campaign_id、pool_id 和 staking_token:这些字段用于分组并且在查询结果中返回。
    • SUM(CASE WHEN earn_state = 0 THEN earn_amount ELSE 0 END) AS pool_unclaimed_rewards:计算每个 pool_id 的待领取收益总额。
  2. 过滤条件:

    • user_id = #{userId,jdbcType=CHAR}:过滤指定用户ID。
    • campaign_id = #{campaignId,jdbcType=CHAR}:过滤指定活动ID。
  3. 分组:

    • 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 的待领取收益总额。

lvxing_ood-hcvmu

parameterType="java.lang.String"这样正确吗,where条件有两个

Avatar
Avatar

你是对的,parameterType="java.lang.String" 只适用于单一参数的情况。如果你的 WHERE 子句中有多个参数(例如 userId 和 campaignId),你需要使用一个包含这些参数的对象或一个 Map。

解决方案

1. 使用 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);

2. 使用自定义参数对象

你也可以创建一个自定义的参数对象来传递多个参数。以下是 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 分组的待领取收益总额。

lvxing_ood-hcvmu

List<PoolUnclaimedVO> poolUnclaimedVOS = new ArrayList<>();
List<PoolUnclaimedDO> poolUnclaimedDOS = userStakingEarnMapper.selectPoolSummary(userId,unclaimedCampaignsVO.getCampaignId());把poolUnclaimedDOS转换为poolUnclaimedVOS,PoolUnclaimedVO和PoolUnclaimedDO属性一样

Avatar
Avatar

你可以通过遍历 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 Streams 进行转换

如果你使用的是 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 列表的转换。选择最适合你项目风格和需求的方法即可。

lvxing_ood-hcvmu

@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;
}可以优化一下吗

Avatar
Avatar

当然可以,对你的代码进行以下几个方面的优化:

  1. 减少重复代码:使用构造函数或工厂方法来减少重复的 setter 调用。
  2. 使用 Java 8 Streams:简化列表转换逻辑,使代码更加简洁和易读。
  3. 修复逻辑错误:在 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;
}

解释

  1. 使用 Java 8 Streams:

    • 使用 stream 和 map 方法来简化列表转换逻辑。
    • 使用 collect(Collectors.toList()) 将流转换回列表。
  2. 减少重复代码:

    • 在 map 操作中直接创建并设置 UnclaimedCampaignsVO 和 PoolUnclaimedVO 对象,减少了重复的 setter 调用。
  3. 修复逻辑错误:

    • 从 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
}

通过这些优化,你的代码将更加简洁、易读和易于维护。

lvxing_ood-hcvmu

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

Avatar
Avatar

要实现这个需求,你需要编写一个 SQL 查询来根据 campaign_id 分组,统计待领取和已领取的奖励总额,同时还需要返回 pool_id、earn_token_logo 和 earn_token。你可以使用子查询或联合查询来实现这一点。

SQL 查询

以下是一个示例查询,可以满足你的需求:

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;

解释

  1. 选择的字段:

    • 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:已领取的奖励总和。
  2. 分组:

    • GROUP BY campaign_id, pool_id, earn_token, earn_token_logo:按活动、矿池、奖励币种及其 logo 分组。
  3. 过滤条件:

    • 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。

lvxing_ood-hcvmu

会不会把没有待领取的活动查出来

Avatar
Avatar

为了确保只返回有待领取奖励的活动,你需要在查询中使用 HAVING 子句来过滤掉那些待领取奖励总和为零的记录。

修正后的 SQL 查询

以下是修正后的查询,确保只返回有待领取奖励的活动:

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。

lvxing_ood-hcvmu

假设campaign2没有earn_state是0的会查出来campaign2吗

Avatar
Avatar

如果 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 的记录,它将不会出现在查询结果中。

lvxing_ood-hcvmu

List<GemStakingCampaignDO> checkedCampaignsDO = gemStakingCampaignMapper.selectByExample(gemStakingCampaignDOExample);
if (null != checkedCampaignsDO) {
//GemStakingCampaignDO里有个earnToken,帮我把checkedCampaignsDO转换为List<String> earnTokens
}

Avatar
Avatar

你可以通过遍历 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);
        }
    }
}

解释

  1. 检查是否为空:

    • 首先,检查 checkedCampaignsDO 是否为 null,以避免空指针异常。
  2. 方法1:使用传统的 for 循环:

    • 创建一个新的 ArrayList<String>,名为 earnTokens。
    • 使用 for 循环遍历 checkedCampaignsDO 列表,将每个 GemStakingCampaignDO 对象中的 earnToken 字段提取并添加到 earnTokens 列表中。
  3. 方法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,根据你的需求和代码风格来选择。

lvxing_ood-hcvmu

如何优雅的构造一个空的list

Avatar
Avatar

在 Java 中构造一个空的 List 有多种方式。以下是几种常见且优雅的方法:

1. 使用 Collections.emptyList()

Collections.emptyList() 是最推荐的方式之一,它返回一个不可变的空列表。

import java.util.Collections;
import java.util.List;

List<String> emptyList = Collections.emptyList();

2. 使用 Arrays.asList() 创建空列表

Arrays.asList() 可以用来创建一个固定大小的列表。当你传递空数组时,它会返回一个空列表。

import java.util.Arrays;
import java.util.List;

List<String> emptyList = Arrays.asList();

3. 使用 new ArrayList<>()

直接创建一个新的 ArrayList。这是最常见的方式之一,特别是当你需要一个可变的空列表时。

import java.util.ArrayList;
import java.util.List;

List<String> emptyList = new ArrayList<>();

4. 使用 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 引入的方法,返回一个不可变的空列表,适用于不需要修改列表的场景。

根据你的具体需求选择适合的方法,可以确保代码的简洁性和可维护性。

lvxing_ood-hcvmu

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();
}

}

Avatar
Avatar

你可以通过使用 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);
    }
}

详细解释

  1. 使用 Streams API:

    • 使用 stream() 方法将 userStakingEarnDOS 列表转换为流。
    • 使用 map 方法将每个 UserStakingEarnDO 对象转换为 RewardsHistoryVO 对象。
    • 使用 collect(Collectors.toList()) 将流转换回 List<RewardsHistoryVO>。
  2. 映射属性:

    • 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>,提取并设置每个对象的相关属性。

lvxing_ood-hcvmu

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

Avatar
Avatar

你需要编写一个 SQL 查询,首先过滤出 earn_state 为领取成功的记录,然后根据 earn_token 和 pool_id 分组,统计每个 earn_token 下每个 pool 的收益,以及每个 earn_token 的收益总额。最终结果应该包括每个 earn_token 下每个 pool 的收益和总收益。

SQL 查询

以下是一个示例查询,可以满足你的需求:

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;

解释

  1. 选择的字段:

    • 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) 实现。
  2. 过滤条件:

    • earn_state = 1:只选择领取成功的记录。
  3. 分组:

    • GROUP BY earn_token, pool_id:按 earn_token 和 pool_id 分组。
  4. 排序:

    • 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 的收益总和。

lvxing_ood-hcvmu

<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>

Avatar
Avatar

你提供的 SQL 语句有一些小问题需要修正:

  1. SQL 语法问题:where 子句中的条件之间应该使用 AND,而不是逗号。
  2. 条件顺序问题:确保 AND 连接符在条件之间适当地使用。
  3. GROUP BY 子句:你正在使用 COUNT(*) 函数,并且希望按 earn_token 分组,因此需要确保 GROUP BY 子句没有语法错误。
  4. 返回类型:resultType 应该是 java.lang.Long,因为你正在计算计数。

以下是修正后的 SQL 语句:

修正后的 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>

解释

  1. 选择的字段:

    • count(*):计算记录的数量。
  2. 过滤条件:

    • 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:只选择领取成功的记录。
  3. 分组:

    • GROUP BY earn_token:按 earn_token 分组。

Java 类示例

确保你的 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 对象包含了必要的参数。

lvxing_ood-hcvmu
  and updated_at <= #{endTime,jdbcType=CHAR}

idea编辑器提示<= Tag name expected

Avatar
Avatar

IDE 提示 "Tag name expected" 通常是因为 XML 语法错误。你的 SQL 语句中的 <if> 标签需要正确关闭,并且需要确保条件之间的连接符正确使用。

以下是修正后的 SQL 语句,确保所有 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>

解释

  1. 选择的字段:

    • COUNT(*):计算记录的数量。
  2. 过滤条件:

    • 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 不为空):指定结束时间。
  3. 分组:

    • GROUP BY earn_token:按 earn_token 分组。

Java 类示例

确保你的 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 对象包含了必要的参数。

lvxing_ood-hcvmu

<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>

Avatar
Avatar

你的 SQL 语句有一个关键问题:在使用 <if> 标签添加条件时,应该确保这些条件在逻辑上正确连接。特别是最后一个条件 and earn_state = 1,如果前面的条件不添加,则会导致语法错误。为了避免这个问题,建议将 earn_state = 1 条件放在最前面,或者在每个条件前面都添加一个占位符条件。

此外,需要注意的是,在 XML 中,必须使用 &gt; 和 &lt; 分别表示 >= 和 <=。

以下是修正后的 SQL 语句:

修正后的 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 &gt;= #{startTime,jdbcType=CHAR}
    </if>
    <if test="endTime != null">
        AND updated_at &lt;= #{endTime,jdbcType=CHAR}
    </if>
    GROUP BY 
        earn_token
</select>

解释

  1. 选择的字段:

    • COUNT(*):计算记录的数量。
  2. 过滤条件:

    • user_id = #{userId,jdbcType=CHAR}:指定用户 ID。
    • earn_state = 1:只选择领取成功的记录。
    • earn_token = #{earnToken,jdbcType=CHAR}(如果 earnToken 不为空):指定奖励币种。
    • updated_at &gt;= #{startTime,jdbcType=CHAR}(如果 startTime 不为空):指定开始时间。
    • updated_at &lt;= #{endTime,jdbcType=CHAR}(如果 endTime 不为空):指定结束时间。
  3. 分组:

    • GROUP BY earn_token:按 earn_token 分组。

关键点

  • 逻辑连接:确保所有条件在逻辑上正确连接,特别是使用 <if> 标签时,条件需要在逻辑上前后一致。
  • XML 转义字符:在 XML 中,>= 和 <= 分别用 &gt; 和 &lt; 表示。

Java 类示例

确保你的 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 对象包含了必要的参数。

lvxing_ood-hcvmu

mapper接口该怎么写

Avatar
Avatar

为了让 MyBatis 映射文件中的 countByEarnTokenGroup 查询在 Java 中可用,你需要在 Mapper 接口中定义相应的方法。以下是如何编写 Mapper 接口的方法:

1. 定义 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);
}

2. 完整的 Mapper 接口

以下是完整的 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);
}

3. MyBatis 映射文件

确保你的 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 &gt;= #{example.startTime,jdbcType=CHAR}
        </if>
        <if test="example.endTime != null">
            AND updated_at &lt;= #{example.endTime,jdbcType=CHAR}
        </if>
        GROUP BY 
            earn_token
    </select>
</mapper>

4. 使用 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);
    }
}

总结

  1. 定义 Mapper 接口:在 UserStakingEarnMapper 接口中声明 countByEarnTokenGroup 方法。
  2. MyBatis 映射文件:在 UserStakingEarnMapper.xml 映射文件中定义 countByEarnTokenGroup 查询。
  3. 使用 Mapper 接口:在服务类中注入 UserStakingEarnMapper 并调用 countByEarnTokenGroup 方法。

通过这些步骤,你可以在 Java 代码中使用 MyBatis 查询来统计每个 earn_token 组的记录数量。确保在调用这个查询时,传入的 StakingProductsDOExample 对象包含了必要的参数。

lvxing_ood-hcvmu

不传对象StakingProductsDOExample,改成map

Avatar
Avatar

如果你希望不传对象,而是传 Map 参数,可以按照以下步骤进行修改:

1. 修改 MyBatis 映射文件

首先,修改 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 &gt;= #{startTime,jdbcType=CHAR}
        </if>
        <if test="endTime != null">
            AND updated_at &lt;= #{endTime,jdbcType=CHAR}
        </if>
        GROUP BY 
            earn_token
    </select>
</mapper>

2. 修改 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);
}

3. 使用 Mapper 接口

在你的服务类中,构建 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);
    }
}

解释

  1. 修改 MyBatis 映射文件:

    • 使用 parameterType="map"。
    • 修改参数引用为 #{paramName},例如 #{userId}, #{earnToken}, #{startTime}, #{endTime}。
  2. 修改 Mapper 接口:

    • 使用 Map<String, Object> 作为参数类型。
    • 使用 @Param("params") 注解来传递 Map 参数。
  3. 使用 Mapper 接口:

    • 在服务类中构建 Map<String, Object> 参数。
    • 调用 countByEarnTokenGroup 方法,并传递构建的参数。

通过这些步骤,你可以使用 Map 作为参数来调用 MyBatis 查询,统计每个 earn_token 组的记录数量。确保在调用这个查询时,传入的 Map 对象包含了必要的参数。

lvxing_ood-hcvmu

不指定parameterType,可以直接在UserStakingEarnMapper里的方法里加参数吗

Avatar
Avatar

是的,你可以直接在 UserStakingEarnMapper 接口的方法中添加多个参数,而不需要指定 parameterType。在这种情况下,可以使用 @Param 注解来标识每个参数,以便在 MyBatis 映射文件中引用它们。

以下是如何实现这一点的示例:

1. 修改 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 &gt;= #{startTime,jdbcType=CHAR}
        </if>
        <if test="endTime != null">
            AND updated_at &lt;= #{endTime,jdbcType=CHAR}
        </if>
        GROUP BY 
            earn_token
    </select>
</mapper>

2. 修改 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
    );
}

3. 使用 Mapper 接口

在你的服务类中,直接传递多个参数调用 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);
    }
}

解释

  1. MyBatis 映射文件:

    • 你不需要指定 parameterType,因为参数名称通过 @Param 注解直接在映射文件中引用。
    • 确保在 SQL 查询中正确引用参数名称,例如 #{userId}, #{earnToken}, #{startTime}, #{endTime}。
  2. Mapper 接口:

    • 使用 @Param 注解为每个方法参数命名。
    • 这样可以在 MyBatis 映射文件中直接引用这些参数。
  3. 服务类:

    • 在服务类中直接调用 Mapper 接口方法,并传递多个参数。

通过这些步骤,你可以使用多个参数调用 MyBatis 查询,而不需要指定 parameterType。确保在映射文件中正确引用参数名称,以便 MyBatis 能够正确地将参数传递给 SQL 查询。

lvxing_ood-hcvmu

select Count(*) countByEarnTokenGroup这个返回值应该是long吧?

Avatar
Avatar

是的,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 &gt;= #{startTime,jdbcType=CHAR}
        </if>
        <if test="endTime != null">
            AND updated_at &lt;= #{endTime,jdbcType=CHAR}
        </if>
        GROUP BY 
            earn_token
    </select>
</mapper>

使用 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);
    }
}

解释

  1. 单个计数值的返回:如果只需要一个计数值,直接返回 Long 类型。
  2. 多个计数值的返回:如果需要返回多个计数值,定义一个 CountResult 类来包含分组字段和计数值,并在 Mapper 接口中返回 List<CountResult>。
  3. MyBatis 映射文件:确保在 SQL 查询中正确地返回 CountResult 对象的字段。

通过这些步骤,你可以正确地使用 MyBatis 查询来获取每个 earn_token 组的记录数量。确保在映射文件中正确引用参数名称和返回类型。

lvxing_ood-hcvmu

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>

Avatar
Avatar

你的方法定义和 MyBatis 映射文件看起来基本上是正确的,但有一些细节需要注意:

  1. 返回类型:由于你使用 GROUP BY 子句,count(*) 将返回多个分组的计数值。因此,返回类型应该是 List<Long> 而不是单个 Long。
  2. XML 文件中的 GROUP BY:如果你希望返回多个分组的计数值,并且每个分组的计数值是单独的记录,需要调整返回类型和查询逻辑。

修改后的方案

假设你希望返回每个 earn_token 的计数值,应该返回一个包含每个 earn_token 以及相应计数值的对象列表。

1. 定义返回对象

定义一个包含 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;
    }
}

2. 修改 Mapper 接口

修改 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
    );
}

3. 修改 MyBatis 映射文件

修改 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 &gt;= #{startTime,jdbcType=TIMESTAMP}
        </if>
        <if test="endTime != null">
            AND updated_at &lt;= #{endTime,jdbcType=TIMESTAMP}
        </if>
        GROUP BY 
            earn_token
    </select>
</mapper>

4. 使用 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);
    }
}

解释

  1. 返回对象:定义一个新的 EarnTokenCount 类,包含 earnToken 和计数值。
  2. Mapper 接口:修改接口方法的返回类型为 List<EarnTokenCount>,并使用 @Param 注解传递参数。
  3. MyBatis 映射文件:修改 SQL 查询以返回 EarnTokenCount 对象列表,并确保使用正确的 JDBC 类型。
  4. 服务类:调用 Mapper 接口方法,并处理返回的 EarnTokenCount 对象列表。

通过这些步骤,你可以正确地使用 MyBatis 查询来获取每个 earn_token 组的记录数量,并返回结果列表。确保在映射文件中正确引用参数名称和返回类型。

lvxing_ood-hcvmu

你搞错了。我的sql是select count()
from gem_staking.user_staking_earn,SELECT
earn_token AS earnToken,
COUNT(
) AS count你这是什么东西

Avatar
Avatar

抱歉,我理解错了你的需求。你希望使用 COUNT(*) 并且返回单个计数值,但是因为你使用了 GROUP BY 子句,因此你会得到多个计数值。每个分组的计数值都是一个单独的记录。

如果你希望返回每个 earn_token 组的计数值,并且每个分组的计数值是单独的记录,你可以返回一个列表。你可以返回一个包含 earn_token 和计数值的对象列表,或者返回一个 List<Long>,然后你需要明确处理每个分组的计数值。

使用 List<Long> 返回多个计数值

如果你只需要返回计数值而不关心具体的 earn_token,你可以直接返回 List<Long>。以下是示例:

1. 修改 MyBatis 映射文件

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 &gt;= #{startTime,jdbcType=TIMESTAMP}
        </if>
        <if test="endTime != null">
            AND updated_at &lt;= #{endTime,jdbcType=TIMESTAMP}
        </if>
        GROUP BY 
            earn_token
    </select>
</mapper>

2. 修改 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 和计数值的对象列表。

1. 定义返回对象

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;
    }
}

2. 修改 MyBatis 映射文件

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 &gt;= #{startTime,jdbcType=TIMESTAMP}
        </if>
        <if test="endTime != null">
            AND updated_at &lt;= #{endTime,jdbcType=TIMESTAMP}
        </if>
        GROUP BY 
            earn_token
    </select>
</mapper>

3. 修改 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
    );
}

使用 Mapper 接口

在你的服务类中,调用 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);
    }
}

解释

  1. 返回对象:定义一个新的 EarnTokenCount 类,包含 earnToken 和计数值。
  2. Mapper 接口:修改接口方法的返回类型为 List<EarnTokenCount>,并使用 @Param 注解传递参数。
  3. MyBatis 映射文件:修改 SQL 查询以返回 EarnTokenCount 对象列表,并确保使用正确
lvxing_ood-hcvmu

你完全错了。我是先分组统计数量,然后分页分组统计结果。先解决分组统计数量

Avatar
Avatar

明白了,我理解错了你的需求。你是希望先统计每个 earn_token 的数量,然后进行分页查询。下面是如何实现这个需求的步骤:

1. 统计每个 earn_token 的数量

我们首先需要编写一个 SQL 查询,统计每个 earn_token 的数量。

修改 MyBatis 映射文件

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 &gt;= #{startTime,jdbcType=TIMESTAMP}
        </if>
        <if test="endTime != null">
            AND updated_at &lt;= #{endTime,jdbcType=TIMESTAMP}
        </if>
        GROUP BY 
            earn_token
    </select>
</mapper>

修改 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
    );
}

2. 使用 Mapper 接口

在你的服务类中,调用 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);
    }
}

3. 分页查询每个 earn_token 的统计结果

为了实现分页查询,我们需要修改 SQL 查询,以返回分页后的结果。

修改 MyBatis 映射文件

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 &gt;= #{startTime,jdbcType=TIMESTAMP}
        </if>
        <if test="endTime != null">
            AND updated_at &lt;= #{endTime,jdbcType=TIMESTAMP}
        </if>
        GROUP BY 
            earn_token
        ORDER BY
            earn_token
        LIMIT #{offset}, #{pageSize}
    </select>
</mapper>

修改 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
    );
}

4. 使用分页查询方法

在你的服务类中,调用 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,
lvxing_ood-hcvmu

我的需求是想获得分组后有多少条记录

Avatar
Avatar

明白了,你的需求是想获得分组后的记录数,而不是每个分组内的记录数。也就是说,你希望知道有多少个不同的 earn_token 分组。

解决方案

你可以编写一个 SQL 查询,使用 GROUP BY 和 COUNT(DISTINCT earn_token) 来获得分组后的记录数。

SQL 查询

以下是一个示例查询,可以满足你的需求:

修改 MyBatis 映射文件

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 &gt;= #{startTime,jdbcType=TIMESTAMP}
        </if>
        <if test="endTime != null">
            AND updated_at &lt;= #{endTime,jdbcType=TIMESTAMP}
        </if>
    </select>
</mapper>

修改 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
    );
}

使用 Mapper 接口

在你的服务类中,调用 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);
    }
}

解释

  1. 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 不为空):按结束时间过滤。
  2. Mapper 接口:

    • 定义 countDistinctEarnTokenGroups 方法,返回 Long 类型。
    • 使用 @Param 注解传递参数。
  3. 服务类:

    • 在服务类中调用 countDistinctEarnTokenGroups 方法,并处理返回的结果。

通过这些步骤,你可以获得分组后有多少条记录,即不同 earn_token 的数量。确保在调用这个查询时,传入的参数包含了必要的过滤条件。

lvxing_ood-hcvmu
    List<StakingCampaignBonusTaskDO> bonusTaskDOS = bonusTaskMapper.selectByExample(bonusTaskDOExample);

遍历一下bonusTaskDOS,StakingCampaignBonusTaskDO有个taskType,0表示做题,要取做题的StakingCampaignBonusTaskDO

Avatar
Avatar

你可以通过遍历 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

以下是使用 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,则将对象添加到新的列表中。
  • 使用 Java 8 Streams API:使用 stream() 方法将 bonusTaskDOS 列表转换为流,使用 filter 方法过滤 taskType 为 0 的对象,并使用 collect(Collectors.toList()) 将流转换回列表。

你可以根据项目的具体需求和代码风格选择适合的方法。

lvxing_ood-hcvmu

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

Avatar
Avatar

在 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();
    }
}

解释

  1. 使用 AtomicInteger:

    • 创建一个 AtomicInteger 变量 questionNO,初始值为 1。
    • 在 lambda 表达式中使用 questionNO.getAndIncrement() 方法来获取当前值并递增。
  2. Streams API:

    • 使用 stream() 方法将 bonusTaskDOS 列表转换为流。
    • 使用 map 方法将每个 StakingCampaignBonusTaskDO 对象转换为 BonusTaskExamVO 对象。
    • 使用 collect(Collectors.toList()) 将流转换回列表。
  3. 解析 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 列表。

lvxing_ood-hcvmu

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;
}

Avatar
Avatar

你可以通过遍历用户的答案列表 answerVOS 和题库 bonusTaskDOS 来校验每一题是否正确。然后,将校验结果放到 List<AnswerCheckVO> 中。以下是具体的实现步骤和示例代码:

实现步骤

  1. 遍历用户的答案列表 answerVOS。
  2. 对于每个用户答案,从题库 bonusTaskDOS 中找到对应的题目。
  3. 比较用户答案和正确答案,判断是否正确。
  4. 将结果放入 AnswerCheckVO 和 AnswerVO 对象中。
  5. 计算总的校验结果和加成系数。

示例代码

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;
}

解释

  1. 创建 Map:将 bonusTaskDOS 转换为 Map,以便快速查找题目。
  2. 校验答案:遍历 answerVOS,对于每个答案,从 questionMap 中找到对应的题目,并进行答案校验。
  3. 生成结果:将校验结果放入 AnswerCheckVO 和 AnswerVO 对象中,计算总的校验结果和加成系数。
  4. 打印结果:将结果打印或进行其他处理。

通过这些代码,你可以实现每一题的校验,并将结果放到 List<AnswerCheckVO> 中。

lvxing_ood-hcvmu
    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;}请帮我判断用户是否完成所有的任务。通过任务类型比较。
Avatar
Avatar

要判断用户是否完成所有的任务,可以通过以下步骤实现:

  1. 遍历配置的任务列表 bonusTaskDOS。
  2. 对于每个配置的任务,检查用户完成任务记录 userStakingTaskBonusDOS 中是否存在对应的记录,并且任务状态为已完成。
  3. 如果所有配置的任务都能找到对应的完成记录,则表示用户已完成所有任务。

示例代码

以下是实现这一逻辑的示例代码:

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("用户未完成所有任务");
        }
    }
}

解释

  1. 将用户完成任务记录转换为 Map:

    • 使用 Collectors.toMap 将 userStakingTaskBonusDOS 列表转换为 Map<String, UserStakingTaskBonusDO>,键为 taskId,值为 UserStakingTaskBonusDO 对象,以便快速查找。
  2. 遍历配置的任务列表:

    • 遍历 bonusTaskDOS 列表,对于每个 StakingCampaignBonusTaskDO 对象,从 userTaskMap 中查找对应的 UserStakingTaskBonusDO 对象。
    • 检查任务状态是否为已完成 (taskState == 1)。
    • 如果有任何一个任务未完成,则设置 allTasksCompleted 为 false 并跳出循环。
  3. 输出结果:

    • 根据 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;
}

通过这些代码,你可以判断用户是否完成了所有配置的任务。确保在实现过程中正确处理每个任务的状态和类型。

lvxing_ood-hcvmu

mysql表存储年月日时分的字段用什么类型

Avatar
Avatar

在 MySQL 中,存储日期和时间的字段有多个选项,具体选择取决于你需要存储的精度和范围。以下是存储年月日时分的常见类型:

1. DATETIME

  • 范围:'1000-01-01 00:00:00' 到 '9999-12-31 23:59:59'
  • 精度:秒

DATETIME 类型可以存储日期和时间,并且能够存储年月日时分秒。它通常用于存储不依赖时区的日期和时间。

示例:

CREATE TABLE example_table (
    id INT AUTO_INCREMENT PRIMARY KEY,
    event_time DATETIME NOT NULL
);

2. TIMESTAMP

  • 范围:'1970-01-01 00:00:01' UTC 到 '2038-01-19 03:14:07' UTC
  • 精度:秒

TIMESTAMP 类型也可以存储日期和时间,并且能够存储年月日时分秒。它会根据当前会话的时区转换存储的时间,并且通常用于存储依赖时区的日期和时间。

示例:

CREATE TABLE example_table (
    id INT AUTO_INCREMENT PRIMARY KEY,
    event_time TIMESTAMP NOT NULL
);

3. 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 类型,并设置默认值为当前时间戳,并在记录更新时自动更新。

通过选择合适的数据类型,你可以确保日期和时间数据的精度和范围满足应用程序的需求。

lvxing_ood-hcvmu

TIMESTAMP和时区无关吗

Avatar
Avatar

TIMESTAMP 类型与时区有关,这是它与 DATETIME 类型的一个关键区别。

TIMESTAMP 类型

  • 时区相关:TIMESTAMP 类型会根据当前会话的时区存储和检索数据。
  • 存储格式:内部以 UTC 时间存储,但在检索时会转换为当前会话的时区。
  • 自动初始化和更新:TIMESTAMP 字段可以自动初始化为当前时间戳,并在记录更新时自动更新。

DATETIME 类型

  • 时区无关:DATETIME 类型存储的是一个固定的日期和时间值,不会根据时区进行转换。
  • 存储格式:以字符串格式存储日期和时间,不进行任何时区转换。

例子说明

假设你在 UTC 时区插入了一条记录,并且后来在不同时区检索它:

使用 TIMESTAMP

CREATE 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 类型会根据时区进行转换。

使用 DATETIME

CREATE 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 -- 记录的最后更新时间(与时区相关)
);

通过选择合适的类型,你可以确保日期和时间数据的存储和检索方式满足应用需求。

lvxing_ood-hcvmu

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条数据,需要从这个表里一个用户一个用户的计算收益,将收益结果插入收益表里。如何高性能的实现。

Avatar
Avatar

为了高性能地从大量数据中计算收益并插入到收益表中,你可以考虑以下几种优化策略:

  1. 分批处理:将数据分成小批次进行处理,可以避免内存溢出,同时也可以在每一批次处理之间进行一些优化。
  2. 索引优化:确保查询语句能够利用到索引,提高查询效率。
  3. 多线程并发处理:可以使用多线程或并发框架来提高处理速度。
  4. 批量插入:将计算好的收益结果批量插入到收益表中,减少单次插入的开销。

示例代码

以下是一个示例代码,展示了如何高效地处理大量数据:

1. 定义收益表

首先,确保你已经定义了收益表:

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='用户收益表';

2. 分批处理和多线程并发

使用 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();
        }
    }
}

解释

  1. 分批处理:使用 LIMIT 和 OFFSET 分批获取数据,每次处理一批数据。
  2. 多线程并发:使用 ExecutorService 创建一个固定大小的线程池,并发执行收益计算和插入操作。
  3. 批量插入:使用 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
    // ...
}

通过这些代码,你可以高效地从大量数据中计算收益,并将收益结果插入到收益表中。确保在实现过程中正确处理数据库连接和资源关闭。

lvxing_ood-hcvmu

还能更高效吗

Avatar
Avatar

当然,可以通过更多优化措施进一步提高效率,包括以下几个方面:

  1. 数据库层面的优化:

    • 使用更高效的批量处理和分页策略,例如游标(cursor)。
    • 利用数据库存储过程进行批量处理。
    • 使用数据库索引优化查询性能。
  2. 并发处理优化:

    • 使用更高效的线程池管理策略。
    • 使用异步处理框架,如 Spring Batch 或 Apache Spark。
  3. 减少数据库交互次数:

    • 尽可能减少从数据库读取和写入的次数。

以下是一些更深入的优化策略和示例:

使用游标进行批量处理

游标可以帮助你在数据库层面进行分批处理,从而减少内存占用。以下是一个使用游标的示例:

创建存储过程

你可以创建一个存储过程,使用游标批量处理数据:

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 进行批量处理

Spring Batch 是一个用于处理大量数据的框架,支持分批处理、并发处理、重试等功能。

配置 Spring Batch

  1. 添加依赖:

在 pom.xml 中添加 Spring Batch 依赖:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-batch</artifactId>
</dependency>
  1. 配置 Batch Job:

创建一个配置类来定义批处理作业:

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();
    }
}

启动 Batch Job

创建一个启动类来运行批处理作业:

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 提供了更多的优化和扩展功能,可以根据需求进一步优化和定制。

lvxing_ood-hcvmu

我这边的需求还有其他信息补充,计算插入这个动作是周期性执行,比如1小时执行一次。我们这边用了elasticjob来调度任务

Avatar
Avatar

了解了,如果你需要周期性地执行计算和插入操作,并且使用 ElasticJob 来调度任务,这可以很好地实现高效的批量处理。ElasticJob 是一个分布式调度框架,可以帮助你定时和分布式执行任务。

使用 ElasticJob 实现周期性任务调度

以下是如何使用 ElasticJob 实现周期性任务调度的步骤:

  1. 添加 ElasticJob 依赖:
  2. 配置 ElasticJob:
  3. 实现任务逻辑:
  4. 启动任务:

1. 添加 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>

2. 配置 ElasticJob

配置 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);
    }
}

3. 实现任务逻辑

实现你的计算和插入逻辑作为一个 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();
        }
    }
}

4. 启动任务

启动 Spring Boot 应用程序,ElasticJob 将按照配置的调度策略每小时执行一次任务。

相关类示例

确保你的相关类具有适当的属性和方法,例如:

public class UserRewardSummary {
    // 属性和 Getters/Setters
}

public class UserReward {
    // 属性和 Getters/Setters
}

通过这些配置和代码,你可以利用 ElasticJob 实现周期性任务调度,并且高效地处理和插入收益数据。ElasticJob 提供了分布式调度的能力,可以进一步提升任务的可靠性和可扩展性。

lvxing_ood-hcvmu

部署了三个节点,有没有可能调度作业的时候重复执行同一个用户

Avatar
Avatar

在分布式环境中,部署多个节点时,确保任务不会被重复执行是一个关键问题。ElasticJob 提供了分布式调度的能力,并且有一些机制可以帮助确保任务不会被重复执行。

ElasticJob 的分布式调度机制

ElasticJob 通过分片和协调机制来确保任务在多个节点间均匀分布和协调执行。每个作业会被分成多个分片,每个分片由一个节点执行,避免了重复执行的问题。

确保任务不会重复执行的策略

  1. 分片机制:ElasticJob 通过分片机制将任务分配给不同的节点。通过配置分片总数和分片项,确保每个节点只处理自己分配到的分片。
  2. 幂等操作:在处理任务时确保操作是幂等的,即同一操作执行多次的结果与执行一次的结果相同。
  3. 任务锁定:在任务开始处理时,对任务进行锁定,确保同一时间只有一个节点在处理该任务。
  4. 重试机制:如果一个节点在处理任务时失败,可以配置 ElasticJob 进行重试,确保任务不会丢失。

配置 ElasticJob 的分片机制

以下是如何配置 ElasticJob 的分片机制和幂等操作的示例:

1. 配置 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);
    }
}

2. 实现任务逻辑并确保幂等性

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();
        }
    }
}

解释

  1. 分片机制:ElasticJob 将任务分成多个分片,通过 shardingItemParameters 将分片项参数传递给任务执行逻辑。
  2. 幂等操作:在每次处理任务时,通过更新 cal_state 字段来记录任务状态,确保同一任务不会被重复处理。
  3. 高效查询:通过 MOD(id, 3) 来分片查询数据,确保每个节点只处理自己分配到的分片。

通过这些配置和代码,你可以确保在分布式环境中高效且准确地执行周期性任务,避免重复执行同一用户的任务。ElasticJob 提供了强大的分布式调度能力,可以帮助你实现高效的任务管理和执行。

lvxing_ood-hcvmu

查询条件里加一个函数运算对性能有影响吧?

Avatar
Avatar

是的,在查询条件中使用函数运算可能会对性能产生影响,尤其是在处理大数据量时。函数运算会导致数据库不能利用索引,从而导致全表扫描,性能会显著下降。

在你提供的示例中,使用 MOD(id, 3) = ? 作为分片条件确实会导致性能问题,因为这会使得数据库无法有效地利用索引。

优化策略

为了优化查询性能,可以考虑以下几种策略:

  1. 预计算分片键:在数据插入时预计算分片键,并将其存储在表中。这样可以避免在查询时进行函数运算。
  2. 使用覆盖索引:确保查询所涉及的所有列都包含在索引中,以便数据库可以直接使用索引进行查询,而无需回表。
  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);
    }
}

通过预计算分片键并将其存储在表中,可以避免在查询时使用函数运算,从而提高查询性能。此外,确保查询能够利用索引也非常重要,可以通过创建适当的索引来实现。

总结

  1. 预计算分片键:在数据插入时预计算分片键,并将其存储在表中。
  2. 使用覆盖索引:确保查询所涉及的所有列都包含在索引中。
  3. 分区表:如果数据量非常大,可以考虑使用分区表。

通过这些优化策略,可以显著提高查询性能,确保在分布式环境中高效地执行周期性任务。

lvxing_ood-hcvmu

elasticjob每个周期调度的时候,是轮训节点吗

Avatar
Avatar

ElasticJob 的工作原理并不是简单的轮询节点,而是通过分布式协调和分片机制来确保任务的分布式执行和均衡分配。以下是 ElasticJob 的工作方式和一些关键概念:

ElasticJob 的工作原理

  1. 分布式协调:ElasticJob 使用 Zookeeper 作为注册中心,所有节点共同协调任务的执行。每个节点都会向 Zookeeper 注册自己,并定期在 Zookeeper 上进行心跳检测。
  2. 分片机制:ElasticJob 将任务分成多个分片,每个分片由一个节点处理。分片数和分片项由任务配置决定。
  3. 任务分配:任务启动时,ElasticJob 会根据分片总数和当前活跃节点数,将分片均匀分配给各个节点。每个节点只处理自己分配到的分片。
  4. 故障转移:如果某个节点失效,ElasticJob 会自动将该节点负责的分片重新分配给其他活跃节点,确保任务的高可用性。

分片机制的示例

假设你有一个任务,分成 3 个分片,部署了 3 个节点。每个节点各自处理一个分片:

  • 节点 A 处理分片 0
  • 节点 B 处理分片 1
  • 节点 C 处理分片 2

如果节点 B 失效,ElasticJob 会重新分配分片:

  • 节点 A 处理分片 0 和分片 1
  • 节点 C 处理分片 2

配置 ElasticJob 分片机制

以下是如何配置 ElasticJob 的分片机制并确保任务均衡分配的示例:

1. 配置 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);
    }
}

2. 实现任务逻辑

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();
        }
    }
}

解释

  1. 分片机制:ElasticJob 将任务分成多个分片,通过 shardingItemParameters 将分片项参数传递给任务执行逻辑。
  2. 幂等操作:在每次处理任务时,通过更新 cal_state 字段来记录任务状态,确保同一任务不会被重复处理。
  3. 高效查询:通过预先计算的 shard_key 来分片查询数据,确保每个节点只处理自己分配到的分片。

通过这些配置和代码,你可以确保在分布式环境中高效且准确地执行周期性任务,避免重复执行同一用户的任务。ElasticJob 提供了强大的分布式调度能力,可以帮助你实现高效的任务管理和执行。

lvxing_ood-hcvmu

如果节点发生了增加或者减少,那么shard_key不就失效了吗

Avatar
Avatar

你提出的一个非常重要的问题:如果节点数量发生变化,预先计算的 shard_key 将无法适应新的分片方案,从而导致任务分配不均或重复计算。

为了解决这个问题,我们需要一种动态分片的方法,使得分片可以根据当前的节点数量进行调整。ElasticJob 提供了这种能力,可以动态地根据分片总数和当前活跃节点数进行分片。

动态分片

在动态分片中,我们不再使用预先计算的 shard_key。相反,我们根据当前的分片总数和活跃节点数动态计算每个分片所处理的数据。

修改任务逻辑以支持动态分片

我们可以通过使用 ElasticJob 的 ShardingContext 来获取当前的分片项,并在查询时使用这个分片项来动态划分数据。

1. 配置 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 * * * ?") // 每小时执行一次
                .build();
        return new ScheduleJobBootstrap(elasticJobLiteAutoConfiguration().getRegistryCenter(), job, jobConfig);
    }
}

2. 实现任务逻辑

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();
        }
    }
}

解释

  1. 动态分片:ElasticJob 将任务分成多个分片,通过 ShardingContext 获取当前分片项和分片总数。在查询时使用 MOD(id, ?) 来动态计算分片。
  2. 节点变动处理:当节点数量发生变化时,ElasticJob 会动态调整分片分配,确保任务的均衡分配和高效执行。
  3. 高效查询:通过动态分片查询数据,确保每个节点只处理自己分配到的分片,避免重复处理和性能瓶颈。

通过这些配置和代码,你可以确保在分布式环境中高效且准确地执行周期性任务,即使节点数量发生变化,任务也能动态调整,以避免重复执行同一用户的任务。ElasticJob 提供了强大的分布式调度能力,可以帮助你实现高效的任务管理和执行。

lvxing_ood-hcvmu

同一时间,是不是只有一个节点被调度

Avatar
Avatar

在 ElasticJob 的分布式调度机制中,并不是同一时间只有一个节点被调度。相反,ElasticJob 通过分片机制将任务分配到多个节点上,并行执行,以提高任务的执行效率和处理能力。

关键点

  1. 分片机制:ElasticJob 将一个任务分成多个分片,每个分片由一个节点处理。每个节点只处理自己分配到的分片。
  2. 并行执行:当一个任务被调度时,多个节点会同时执行各自分配到的分片,从而并行处理任务。
  3. 协调和故障转移:ElasticJob 使用 Zookeeper 进行协调。如果某个节点失效,ElasticJob 会将该节点负责的分片重新分配给其他节点。

工作流程示例

假设你有一个任务分成 3 个分片,并且有 3 个节点(A、B、C)。任务被调度时,ElasticJob 会将分片分别分配给节点:

  • 节点 A 处理分片 0
  • 节点 B 处理分片 1
  • 节点 C 处理分片 2

这三个节点会并行执行各自的分片任务。

任务配置和实现

以下是如何配置和实现分布式任务调度的示例:

1. 配置 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);
    }
}

2. 实现任务逻辑

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();
        }
    }
}

解释

  1. 分片机制:ElasticJob 将任务分成多个分片,通过 ShardingContext 获取当前分片项和分片总数。在查询时使用 MOD(id, ?) 来动态计算分片。
  2. 并行执行:当任务被调度时,多个节点会同时执行各自分配到的分片,从而并行处理任务。
  3. 高效查询:通过动态分片查询数据,确保每个节点只处理自己分配到的分片,避免重复处理和性能瓶颈。

通过这些配置和代码,你可以确保在分布式环境中高效且准确地执行周期性任务,多个节点会并行处理任务,提高任务处理效率。ElasticJob 提供了强大的分布式调度能力,可以帮助你实现高效的任务管理和执行。

lvxing_ood-hcvmu

以上这种如果有50万数据要处理需要多久

Avatar
Avatar

处理50万条数据所需的时间取决于多个因素,包括数据库查询和写入的性能、网络延迟、计算资源(CPU、内存等)以及任务的复杂性。为了提供一个更精确的估计,我们可以考虑以下几个方面:

  1. 数据库查询和写入性能:

    • 数据库的查询速度和写入速度是关键因素。如果数据库可以高效地处理批量查询和写入,处理时间将会大大减少。
    • 使用索引可以显著提高查询性能。
  2. 批量处理大小:

    • 批量处理的大小(BATCH_SIZE)会影响处理速度。较大的批量可以减少数据库的往返次数,但也会增加内存占用。
  3. 并行处理:

    • 使用多线程或并发机制可以提高处理速度。合理配置线程池大小(THREAD_POOL_SIZE)可以提高并行处理能力。
  4. 网络延迟:

    • 如果应用程序和数据库在不同的物理位置,网络延迟也会影响处理时间。

估算示例

假设以下条件:

  • 每次批量处理1000条记录(BATCH_SIZE = 1000)。
  • 使用10个线程并行处理(THREAD_POOL_SIZE = 10)。
  • 每次查询和处理一批数据(包括从数据库读取、计算和插入)平均耗时0.5秒。

我们可以大致估算处理时间:

总记录数 = 500,000
每批处理记录数 = 1,000
批次数 = 总记录数 / 每批处理记录数 = 500,000 / 1,000 = 500

每次批量处理时间 = 0.5秒
总处理时间(不并行) = 批次数 * 每次批量处理时间 = 500 * 0.5 = 250秒

并行处理:使用10个线程并行处理
总处理时间(并行) = 总处理时间(不并行) / 线程数 = 250 / 10 = 25秒

优化建议

为了进一步优化处理时间,可以考虑以下建议:

  1. 优化数据库查询:

    • 确保数据库表有适当的索引,以加速查询。
    • 使用覆盖索引,减少回表操作。
  2. 批量插入:

    • 使用批量插入(executeBatch)减少数据库写入的往返次数。
  3. 合理配置批量大小和线程池:

    • 根据系统资源和数据库性能,调整批量大小和线程池大小,找到最佳配置。
  4. 数据库连接池:

    • 使用数据库连接池(例如 HikariCP),提高数据库连接的复用率,减少连接建立和关闭的开销。

完整代码示例

以下是一个改进后的代码示例,包含上述优化建议:

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万条数据应该可以在合理的时间范围内完成。

lvxing_ood-hcvmu

如果不设置shardingItem, shardingTotalCount,部署三个节点,会怎样

Avatar
Avatar

如果你不设置 shardingItem 和 shardingTotalCount,ElasticJob 在默认情况下仍然会使用分片机制将任务分配到多个节点上。每个节点会根据总的分片数和当前的节点数来分配和处理任务。但是,这样做会失去精细控制分片的能力,可能会导致负载不均衡。

分片机制的默认行为

  • 分片总数:ElasticJob 会根据配置的总分片数将任务分成多个分片。
  • 节点分配:ElasticJob 会将这些分片均匀分配到当前活跃的节点上,每个节点处理一个或多个分片。
  • 动态调整:如果节点数量发生变化(增加或减少),ElasticJob 会动态重新分配分片,确保任务的高可用性和均衡分配。

不设置 shardingItem 和 shardingTotalCount

如果你不显式传递 shardingItem 和 shardingTotalCount,ElasticJob 会自动处理这些参数,并将其传递给每个节点的任务执行逻辑。每个节点会根据分片项处理自己分配到的任务。

示例:不显式传递 shardingItem 和 shardingTotalCount

以下是一个示例,展示如何在不显式传递 shardingItem 和 shardingTotalCount 的情况下使用 ElasticJob:

1. 配置 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);
    }
}

2. 实现任务逻辑

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();
        }
    }
}

解释

  1. 自动分片:ElasticJob 自动将任务分成多个分片,并将分片分配到各个节点。每个节点在执行任务时,通过 ShardingContext 获取当前分片项和分片总数。
  2. 动态分配:ElasticJob 会根据当前活跃节点数动态分配分片,确保任务均衡分配和高效执行。
  3. 并行执行:多个节点会并行处理各自分配到的分片,提高任务处理效率。

总结

通过 ElasticJob 的分布式调度机制,你可以高效地在多个节点上并行处理任务,即使没有显式地传递 shardingItem 和 shardingTotalCount。ElasticJob 会自动处理这些参数,并确保任务的均衡分配和高效执行。这样可以充分利用集群资源,提高任务处理的整体性能和可靠性。

lvxing_ood-hcvmu

我的执行代码不关心ShardingContext 获取当前分片项和分片总数会怎样呢,我们系统里很多定时任务都没有关心这个分片

Avatar
Avatar

如果你的定时任务没有关心 ShardingContext 来获取当前分片项和分片总数,ElasticJob 仍然会将任务分片并分配给各个节点,但你的任务逻辑将不会根据分片来处理数据。这意味着每个节点可能会处理相同的数据,导致数据重复处理和资源浪费。

什么会发生

  1. 重复处理:每个节点都会执行相同的任务逻辑,而不考虑分片。这可能导致多个节点处理相同的数据,造成重复计算和数据冲突。
  2. 资源浪费:由于每个节点都在处理相同的数据,计算资源和数据库资源会被浪费,整体性能会下降。
  3. 任务不均衡:任务没有按照分片均衡地分配到各个节点上,可能导致某些节点负载过高,而其他节点空闲。

如何处理分片

为了避免上述问题,你需要在任务逻辑中处理分片,确保每个节点只处理自己分配到的分片数据。以下是一个示例,展示了如何在任务逻辑中处理分片:

1. 配置 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);
    }
}

2. 实现任务逻辑并处理分片

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();
        }
    }
}

解释

  1. 配置分片:ElasticJob 会将任务分片,并根据节点数量动态调整分片分配。
  2. 处理分片:在任务逻辑中,通过 ShardingContext 获取当前分片项(shardingItem)和分片总数(shardingTotalCount),并根据分片项处理数据。
  3. 避免重复处理:通过分片机制,确保每个节点只处理自己分配到的分片数据,避免重复处理和资源浪费。

总结

通过处理分片,可以确保任务在多个节点上均衡分配和高效执行。ElasticJob 提供了强大的分布式调度能力,通过分片机制可以避免数据重复处理和资源浪费。确保在任务逻辑中处理分片,可以充分利用 ElasticJob 的分布式调度能力,实现高效的任务管理和执行。

lvxing_ood-hcvmu

<job:simple id="userTradableSymbolApproveCheckTask"
job-ref="userTradableSymbolApproveCheckTask"
registry-center-ref="regCenter"
cron="${kucoin.job.userTradableSymbolApproveCheckCron}"
sharding-total-count="1"
overwrite="true"
description="用户可交易币对白名单审批状态检查任务"/>

Avatar
Avatar

你的配置显示了一个简单的 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="用户可交易币对白名单审批状态检查任务"/>
  • id: 任务的唯一标识符。
  • job-ref: 引用一个 Spring Bean,表示你实现的任务类。
  • registry-center-ref: 引用注册中心的配置。
  • cron: 定时任务的执行时间表达式。
  • sharding-total-count: 分片总数,设置为 1 表示没有分片。
  • overwrite: 允许覆盖配置。
  • description: 任务的描述信息。

什么会发生

  1. 单节点执行:由于 sharding-total-count 被设置为 1,任务不会被分片。整个任务会被分配给一个节点来执行。
  2. 无并行处理:多个节点不会并行处理这个任务,因为任务没有分片。即使有多个节点,任务也只会在一个节点上执行。
  3. 单一责任:任务的所有逻辑都会在一个节点上处理,适用于不需要分片的简单任务。

如果需要并行处理

如果你希望任务能够在多个节点上并行处理,可以增加 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);
        
        // 示例:根据分片项处理不同的数据
        // 你的具体处理逻辑,例如数据库查询和处理
    }
}

解释

  1. 配置分片:将 sharding-total-count 设置为大于 1 的值,表示任务将被分成多个分片。
  2. 处理分片:在任务实现类中,通过 ShardingContext 获取当前分片项和分片总数,并根据分片项处理数据。

总结

  • 当前配置:你的当前配置将任务分片总数设置为 1,意味着任务不会被分片,只会在一个节点上执行。
  • 并行处理:如果希望任务在多个节点上并行处理,可以增加 sharding-total-count 的值,并在任务实现中处理分片逻辑。
  • 分片机制:ElasticJob 通过分片机制将任务分配到多个节点上,并行执行,提高任务处理效率。

通过合理配置和实现分片逻辑,可以充分利用 ElasticJob 的分布式调度能力,实现高效的任务管理和执行。

lvxing_ood-hcvmu

sharding-total-count这个如果不指定会怎样

Avatar
Avatar

如果你在 ElasticJob 配置中没有指定 sharding-total-count,ElasticJob 将无法进行分片,因为 sharding-total-count 是定义任务分片总数的必要参数。没有这个参数,ElasticJob 将无法确定任务应该如何分片和分配给不同的节点。

影响

  1. 任务无法分片:没有指定 sharding-total-count,ElasticJob 无法将任务分成多个分片,这意味着无法利用分布式调度的优势。
  2. 任务无法启动: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);
        
        // 示例:根据分片项处理不同的数据
        // 你的具体处理逻辑,例如数据库查询和处理
    }
}

解释

  1. 配置分片:通过 sharding-total-count="3" 将任务分成3个分片。
  2. 处理分片:在任务实现类中,通过 ShardingContext 获取当前分片项和分片总数,并根据分片项处理数据。

总结

  • 必须指定 sharding-total-count:在 ElasticJob 配置中,sharding-total-count 是一个必需参数,用于定义任务的分片总数。如果没有指定,ElasticJob 将无法进行分片,任务可能无法启动。
  • 分片机制:通过合理配置 sharding-total-count,ElasticJob 可以将任务分片,并将分片均匀分配给多个节点,提高任务处理效率。

确保在 ElasticJob 配置中指定 sharding-total-count 参数,并在任务实现中处理分片逻辑,以充分利用 ElasticJob 的分布式调度能力,实现高效的任务管理和执行。

lvxing_ood-hcvmu

overwrite="true"是什么作用

Avatar
Avatar

在 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="用户可交易币对白名单审批状态检查任务"/>

解释

  • id: 任务的唯一标识符。
  • job-ref: 引用一个 Spring Bean,表示你实现的任务类。
  • registry-center-ref: 引用注册中心的配置。
  • cron: 定时任务的执行时间表达式。
  • 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);
        
        // 示例:根据分片项处理不同的数据
        // 你的具体处理逻辑,例如数据库查询和处理
    }
}

解释

  1. 配置分片:通过 sharding-total-count="3" 将任务分成3个分片。
  2. 处理分片:在任务实现类中,通过 ShardingContext 获取当前分片项和分片总数,并根据分片项处理数据。

总结

  • overwrite="true" 的作用:允许覆盖现有的任务配置,确保新的配置能够生效。
  • 使用场景:适用于开发、测试环境频繁调整任务配置,或者生产环境需要动态更新任务配置的场景。
  • 分片机制:通过合理配置 sharding-total-count,ElasticJob 可以将任务分片,并将分片均匀分配给多个节点,提高任务处理效率。

确保在 ElasticJob 配置中合理使用 overwrite="true" 参数,以便能够动态调整任务配置,实现灵活、高效的任务管理和执行。

lvxing_ood-hcvmu

也就是说如果 sharding-total-count配置在Apollo这样的分布式配置中心里,是可以热更新的吗

Avatar
Avatar

是的,通过使用 overwrite="true" 配置,ElasticJob 可以支持热更新任务配置。这意味着如果你将 sharding-total-count 等配置参数存储在 Apollo 这样的分布式配置中心里,并且在运行时更新这些参数,ElasticJob 可以动态地应用新的配置,而无需重启整个应用程序。

关键点

  1. 分布式配置中心:将 ElasticJob 的配置参数(如 sharding-total-count)存储在 Apollo 等分布式配置中心中。
  2. 自动刷新:通过 Spring Cloud Apollo 等框架,自动刷新配置参数。
  3. 覆盖现有配置:使用 overwrite="true",确保新的配置能够动态覆盖旧的配置,任务会根据新的配置进行调度和分片。

示例配置

以下是如何配置 ElasticJob 和 Apollo 的示例:

1. 配置 Apollo

首先,确保你的项目已经集成了 Apollo,并且可以从 Apollo 获取配置参数。

在 application.yml 中配置 Apollo:

apollo:
  bootstrap:
    enabled: true
  meta: http://config-service-url:8080

2. 配置 ElasticJob

将 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

3. 配置 ElasticJob 的 Spring Bean

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();
    }
}

4. 实现任务逻辑并处理分片

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);
        
        // 示例:根据分片项处理不同的数据
        // 你的具体处理逻辑,例如数据库查询和处理
    }
}

解释

  1. 分布式配置中心:将 ElasticJob 的配置参数存储在 Apollo 中,允许动态更新这些配置参数。
  2. 自动刷新:通过 Spring Cloud Apollo 等框架,自动刷新配置参数。
  3. 覆盖配置:使用 overwrite=true 确保新配置能够覆盖旧配置,任务会根据新的配置进行调度和分片。

总结

通过将 ElasticJob 的配置参数存储在 Apollo 等分布式配置中心,并使用 overwrite="true",你可以实现任务配置的热更新。这样,任务在运行时可以动态应用新的配置参数,无需重启应用程序,从而实现灵活、高效的任务管理和执行。确保在任务实现中处理分片逻辑,以充分利用 ElasticJob 的分布式调度能力。

lvxing_ood-hcvmu

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有没有问题

Avatar
Avatar

你的 SQL 语句基本上是正确的,但是有一些需要注意的地方:

  1. 你需要明确插入的列,以确保插入的数据顺序和目标表的列顺序一致。
  2. 你忘记了插入的 created_at 和 updated_at 列。这些列在目标表 user_reward_summary 中是必须的,并且有默认值。
  3. 你需要在 SELECT 子句中添加 NULL 来填充 id 列,因为 id 是 AUTO_INCREMENT 列,你不需要在 INSERT 中显式提供它。
  4. 你需要确保 group by 子句中的列和 select 子句中的列一致。

修正后的 SQL 语句

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;

解释

  1. 显式指定插入的列:在 INSERT INTO 子句中显式指定插入的列名,以确保数据顺序和目标表的列顺序一致。
  2. 填充 id 列:你不需要在 INSERT 中显式提供 id 列,因为它是 AUTO_INCREMENT 列。
  3. 添加 created_at 和 updated_at 列:在 SELECT 子句中添加 CURRENT_TIMESTAMP 来填充这些列。
  4. 确保 GROUP BY 子句中的列和 SELECT 子句中的列一致:在 GROUP BY 子句中包含所有需要分组的列。

注意事项

  • 数据类型:确保 pool_id 的数据类型一致。如果 pool_id 是字符串类型,确保在 WHERE 子句和 GROUP BY 子句中使用相同的引号。
  • 索引优化:确保你的表有适当的索引,以提高查询性能。

通过这些修正,你的 SQL 语句应该能够正确执行,并将计算结果插入到 user_reward_summary 表中。

lvxing_ood-hcvmu

如果有20万数据插入有问题吗

Avatar
Avatar

插入大量数据(例如20万条记录)时,可能会遇到一些性能问题以及潜在的锁竞争问题。为了确保插入操作高效且不会对系统产生负面影响,以下是一些优化建议和注意事项:

1. 使用批量插入

批量插入可以显著提高插入性能,减少数据库连接和事务的开销。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;

2. 使用分批处理

如果一次性插入20万条记录仍然存在性能问题,可以考虑分批处理。分批处理可以减少每次插入的记录数,降低单次事务大小,从而减少锁竞争。以下是一个分批处理的示例:

示例代码(Java)

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();
                    }
                }
            );
        }
    }
}

3. 索引优化

确保你的表有适当的索引,以提高查询性能。对于查询条件中的列(如 pool_id, summary_stage, cal_state),可以创建复合索引:

CREATE INDEX idx_pool_stage_cal ON gem_staking.user_reward_summary (pool_id, summary_stage, cal_state);

4. 禁用和启用索引

在插入大量数据时,可以暂时禁用索引,然后在插入完成后重新启用索引。这可以显著提高插入性能,但要确保在插入完成后重新启用索引:

-- 禁用索引
ALTER TABLE gem_staking.user_reward_summary DISABLE KEYS;

-- 执行插入操作

-- 启用索引
ALTER TABLE gem_staking.user_reward_summary ENABLE KEYS;

5. 使用事务

在批量插入时,使用事务可以确保数据的完整性和一致性。可以将多个批次的插入操作放在一个事务中:

import org.springframework.transaction.annotation.Transactional;

@Transactional
public void batchInsertWithTransaction(List<UserRewardSummary> rewardSummaries) {
    batchInsert(rewardSummaries);
}

总结

通过使用批量插入、分批处理、索引优化以及事务管理,可以显著提高大量数据插入的效率,减少对系统的影响。确保在插入操作前进行充分的测试,以找到最佳的批量大小和处理策略。

lvxing_ood-hcvmu

<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>这样可以吗

Avatar
Avatar

你的 MyBatis insert 语句看起来基本是正确的,能够将数据从 gem_staking.user_staking_hold_snapshot 表插入到 gem_staking.user_reward_summary 表中,并且在 SELECT 子句中使用了聚合函数和 GROUP BY 子句。

语法检查

  1. 显式指定插入的列:已经正确指定了插入的列。
  2. 使用参数:使用了 MyBatis 的参数占位符 #{},这会使得 SQL 更加灵活和可重用。
  3. GROUP BY:使用了 GROUP BY 子句来确保数据聚合正确。

最终 SQL

以下是你的 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>

解释

  1. INSERT INTO:指定了目标表 gem_staking.user_reward_summary 以及要插入的列。
  2. SELECT:从 gem_staking.user_staking_hold_snapshot 表中选择数据,并进行必要的计算和聚合。
  3. WHERE 子句:使用 MyBatis 参数占位符 #{summaryStage} 和 #{poolId} 来过滤数据。
  4. GROUP BY 子句:确保数据按指定的列进行聚合。

注意事项

  1. 索引优化:确保在 gem_staking.user_staking_hold_snapshot 表上有适当的索引,以提高查询性能。
  2. 数据量控制:如果数据量非常大,可以考虑分批处理,以避免长时间锁表或内存溢出。

示例用法

下面是一个示例,展示如何在 Java 代码中使用这个 MyBatis insert 方法:

Mapper 接口

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);
    }
}

解释

  1. Mapper 接口:定义了 snapshotToSummary 方法,使用 @Param 注解传递参数。
  2. Service 类:在 Service 类中调用 snapshotToSummary 方法,并使用 @Transactional 注解确保事务管理。

通过这些配置和代码,你可以将数据从 gem_staking.user_staking_hold_snapshot 表插入到 gem_staking.user_reward_summary 表中,并且可以灵活地指定 summaryStage 和 poolId 参数。确保在实际使用中根据数据量和性能需求进行充分测试和优化。

lvxing_ood-hcvmu

@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方法失败了。会抛异常吗?会全部会滚吗,这样是否保证即使一个任务失败了也不影响其他任务

Avatar
Avatar

在你提供的代码中,RewardSummaryServiceImpl 类的 snapshotToSummary 方法被 @Transactional 注解修饰,这意味着该方法是事务性的。如果 snapshotToSummary 方法中的任何操作失败并抛出异常,事务将回滚,保证数据的一致性。

事务管理

  1. @Transactional 注解:@Transactional 注解确保在 snapshotToSummary 方法内的所有数据库操作要么全部成功,要么全部回滚。
  2. 异常处理:如果 snapshotToSummary 方法中的任何操作失败并抛出异常,Spring 的事务管理器会捕获异常并回滚事务。

代码解释

1. 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 方法内的操作具有事务性。

2. 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 方法中,异常被捕获并记录日志,确保即使一个任务失败也不会影响其他任务的执行。

通过这种方式,你可以确保任务的可靠执行,即使某个任务失败,其他任务也能继续执行。

lvxing_ood-hcvmu
    log.info("this period job need execute task:{}",summaryJobDOS.stream().map(summaryJobDO->Long.toString(summaryJobDO::getId())));
Avatar
Avatar

你在日志记录中尝试将 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(", ")));

解释

  1. map 方法:使用 map 方法将每个 SnapshotSummaryJobDO 对象的 id 转换为字符串。
  2. Collectors.joining 方法:使用 Collectors.joining(", ") 方法将所有字符串连接成一个字符串,字符串之间用逗号和空格分隔。
  3. 日志记录:将结果记录到日志中。

示例

以下是完整的代码示例:

@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 列表,执行每个任务,并在发生异常时记录错误日志。

通过这种方式,你可以清晰地记录需要执行的任务列表,并确保在任务执行过程中发生异常时能够记录详细的错误信息。

lvxing_ood-hcvmu

上面这个方案mysql里用limit offset有没有性能问题

Avatar
Avatar

使用 LIMIT OFFSET 进行分页查询时,随着偏移量 (OFFSET) 的增大,性能可能会下降。这是因为 MySQL 需要扫描并跳过 OFFSET 之前的所有行,即使这些行不需要返回。这会导致扫描大量行,从而影响查询性能。

性能问题的原因

  • 跳过行:OFFSET 会导致 MySQL 扫描并跳过 OFFSET 之前的所有行。对于大表,这可能会导致大量的磁盘 I/O 操作和 CPU 开销。
  • 索引使用:虽然索引可以帮助找到起始行,但 MySQL 仍然需要扫描和跳过不需要的行。

优化方案

为了解决 LIMIT OFFSET 带来的性能问题,可以考虑以下优化方案:

  1. 使用覆盖索引:确保查询使用覆盖索引,以减少回表操作。
  2. 基于主键或唯一索引分页:使用主键或唯一索引进行分页查询,避免使用 OFFSET。
  3. 分段查询:将大查询拆分成多个小查询,逐段处理数据。

示例:使用主键或唯一索引分页

假设你有一个自增主键 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;

在应用程序中,通过逐步增加主键的值来实现分页:

Java 示例代码

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) {
        // 处理数据的逻辑
    }
}

优化解释

  1. 基于主键分页:每次查询时使用主键 id 进行分页,而不是使用 OFFSET。这样可以避免扫描和跳过大量不需要的行。
  2. 逐步增加主键值:在每次查询后,记录最后处理的主键值,并在下一次查询时使用它作为起始点。
  3. 覆盖索引:确保查询使用覆盖索引,以减少回表操作。

通过这种方式,可以显著提高大数据量分页查询的性能,避免 LIMIT OFFSET 带来的性能问题。在处理大量数据时,基于主键或唯一索引的分页查询是一种常见且有效的优化方案。

lvxing_ood-hcvmu

@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);这三个能否放到一个事务里

Avatar
Avatar

要将多个操作放在一个事务中,确保它们要么全部成功,要么全部失败回滚,可以使用 Spring 的事务管理功能。你可以使用 @Transactional 注解来实现这一点。

事务管理

以下是将计算奖励、插入收益表和更新汇总记录状态这三个操作放在一个事务中的方法。

修改 Service 类

  1. 创建一个新的 Service 方法:将这三个操作放在一个新的 Service 方法中,并使用 @Transactional 注解。

  2. 在原来的任务执行逻辑中调用这个新的 Service 方法。

示例代码

1. 新的 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) {
        // 更新汇总记录的计算状态为完成的逻辑
    }
}

2. 修改任务执行逻辑

在原来的任务执行逻辑中调用新的 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状态
            }
        }
    }
}

解释

  1. 新的 Service 方法:在 RewardService 中创建一个新的 processRewardsTransaction 方法,并使用 @Transactional 注解,确保该方法内的操作具有事务性。
  2. 任务执行逻辑:在任务执行逻辑中调用 RewardService 的 processRewardsTransaction 方法,将计算奖励、插入收益表和更新汇总记录状态这三个操作放在一个事务中。

总结

通过将计算奖励、插入收益表和更新汇总记录状态这三个操作放在一个带有 @Transactional 注解的方法中,可以确保这些操作要么全部成功,要么全部回滚,从而保证数据的一致性。同时,这种方式也能够在任务执行过程中处理事务的管理和异常处理,确保在一个任务失败时不影响其他任务的执行。

lvxing_ood-hcvmu

// 入收益表后说明已经完成计算,更新汇总记录的计算状态为完成
updateSummary2CalFinish(userRewardSummaries, rewards);这里mapper.xml的批量update怎么写

Avatar
Avatar

在 MyBatis 中进行批量更新可以通过 foreach 元素来实现。foreach 元素允许你在 SQL 语句中动态地生成多个更新语句,从而实现批量更新。

示例

假设你有一个包含用户奖励信息的列表 userRewardSummaries,你希望根据这些信息更新汇总记录的计算状态。以下是如何在 MyBatis 的 mapper.xml 中实现批量更新的示例。

1. Mapper 接口

首先,在你的 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);
}

2. Mapper XML 文件

然后,在 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>

3. 调用批量更新方法

在你的 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) {
        // 插入收益表逻辑
    }
}

解释

  1. foreach 元素:在 mapper.xml 文件中使用 foreach 元素生成多个 UPDATE 语句,实现批量更新。foreach 元素遍历 userRewardSummaries 列表,每个元素生成一个 UPDATE 语句。
  2. 批量更新方法:在 Mapper 接口中定义 updateSummary2CalFinish 方法,并使用 @Param 注解传递参数列表。
  3. 调用批量更新:在 Service 类中调用 updateSummary2CalFinish 方法,传递需要更新的 userRewardSummaries 列表。

注意事项

  • 性能优化:批量更新虽然可以减少数据库的往返次数,但仍需要注意性能问题。如果数据量非常大,可以考虑分批次更新。
  • 事务管理:在批量更新时使用事务管理,确保所有更新操作要么全部成功,要么全部回滚,保证数据的一致性。

通过这种方式,你可以实现批量更新汇总记录的计算状态,确保在入收益表后更新汇总记录的状态为完成。

lvxing_ood-hcvmu

数据库是mysql,stakingStartTim数据类型是datetime,数据库数据类型是stakingEndTime,表里存储的值是2024-06-12 17:00:00,但是java程序打印出来是stakingStartTime=Thu Jan 01 17:00:00 CST 1970

Avatar
Avatar

你的问题可能是由于时区或数据类型转换的问题导致的。以下是一些检查和解决方案:

1. 检查数据库字段类型

确保 stakingStartTime 和 stakingEndTime 字段在数据库中的类型是 DATETIME,并且存储格式正确。

2. 检查数据库连接配置

确保数据库连接配置中,时区设置正确。可以在数据库连接 URL 中指定时区。

示例数据库连接 URL(带时区配置)

spring.datasource.url=jdbc:mysql://localhost:3306/your_database?serverTimezone=Asia/Shanghai

3. 检查 Java 数据类型

确保 Java 类中对应的字段类型是 java.util.Date 或 java.time.LocalDateTime,推荐使用 java.time.LocalDateTime,因为它更现代化且更容易处理时间和日期。

示例 Java 类

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;
    }
}

4. 检查 MyBatis 映射配置

如果你使用的是 MyBatis,确保在 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>

5. 检查数据获取和输出逻辑

确保在获取和输出数据的逻辑中没有误操作。例如,确保没有错误地将日期时间类型转换为其他类型。

示例数据获取和输出代码

@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());
}

6. 检查时区

确保你的应用程序和数据库在相同的时区。可以在 JVM 启动参数中指定默认时区:

JVM 启动参数

-Duser.timezone=Asia/Shanghai

总结

通过检查和配置以上几个方面,你应该能够解决日期时间字段在数据库和 Java 程序之间转换的问题。确保时区设置一致,数据类型正确,并且在获取和输出数据时没有误操作。

lvxing_ood-hcvmu

date和date time是什么区别

Avatar
Avatar

在 MySQL 中,DATE 和 DATETIME 是两种不同的数据类型,用于存储日期和时间信息。它们之间有一些关键区别:

1. DATE

  • 存储内容:DATE 类型仅存储日期部分(年、月、日)。
  • 格式:YYYY-MM-DD。
  • 范围:1000-01-01 到 9999-12-31。
  • 示例:2024-06-12。

2. DATETIME

  • 存储内容:DATETIME 类型存储日期和时间部分(年、月、日、时、分、秒)。
  • 格式: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 映射

在 Java 中,处理 DATE 和 DATETIME 类型的数据时,一般使用以下数据类型:

  • DATE:java.sql.Date 或 java.time.LocalDate。
  • DATETIME:java.sql.Timestamp 或 java.time.LocalDateTime。

示例 Java 类

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;
    }
}

MyBatis 映射配置

<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。
  • 使用场景:根据需要存储的信息类型选择合适的数据类型。
  • Java 映射:使用适当的 Java 数据类型和 MyBatis 配置来处理 DATE 和 DATETIME 数据。

通过了解和正确使用 DATE 和 DATETIME 类型,可以更好地管理和处理数据库中的日期和时间信息。

lvxing_ood-hcvmu

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.AbstractWebMvcEndpointHandlerMappingServletWebOperationAdapter.handle(AbstractWebMvcEndpointHandlerMapping.java:305)atorg.springframework.boot.actuate.endpoint.web.servlet.AbstractWebMvcEndpointHandlerMappingServletWebOperationAdapter.handle(AbstractWebMvcEndpointHandlerMapping.java:305) 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.AbstractProtocolConnectionHandler.process(AbstractProtocol.java:928)atorg.apache.tomcat.util.net.NioEndpointConnectionHandler.process(AbstractProtocol.java:928) at org.apache.tomcat.util.net.NioEndpointSocketProcessor.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.ThreadPoolExecutorWorker.run(ThreadPoolExecutor.java:659)atorg.apache.tomcat.util.threads.TaskThreadWorker.run(ThreadPoolExecutor.java:659) at org.apache.tomcat.util.threads.TaskThreadWrappingRunnable.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

Avatar
Avatar

从你的日志输出来看,问题是你的 Spring Boot 应用程序无法连接到 Elasticsearch。这种情况通常是由于以下原因之一:

  1. Elasticsearch 服务未启动:Elasticsearch 服务没有启动或没有正确运行。
  2. 连接配置错误:Spring Boot 配置文件中的 Elasticsearch 连接参数不正确。
  3. 网络问题:你的应用程序无法通过网络访问 Elasticsearch 服务(例如,防火墙或网络策略阻止访问)。
  4. Elasticsearch 地址错误:配置的 Elasticsearch 地址不正确,导致连接被拒绝。

排查步骤

1. 检查 Elasticsearch 服务状态

确保 Elasticsearch 服务已启动并正在运行。你可以通过以下命令检查其状态:

sudo service elasticsearch status

或者,如果你使用的是 Docker:

docker ps

2. 检查 Elasticsearch 服务日志

查看 Elasticsearch 服务的日志,看是否有任何错误或警告:

sudo journalctl -u elasticsearch

或者,如果你使用的是 Docker:

docker logs <elasticsearch_container_id>

3. 检查 Spring Boot 配置文件

检查你的 Spring Boot 配置文件(application.properties 或 application.yml),确保配置了正确的 Elasticsearch 连接参数。

application.properties 示例
spring.elasticsearch.rest.uris=http://localhost:9200
application.yml 示例
spring:
  elasticsearch:
    rest:
      uris: http://localhost:9200

4. 检查网络连接

确保你的应用程序所在的服务器可以访问 Elasticsearch 服务。你可以使用 curl 命令进行简单的测试:

curl http://localhost:9200

如果 Elasticsearch 服务运行在远程服务器上,请确保你使用了正确的 IP 地址或主机名,并且中间没有防火墙或网络策略阻止访问。

5. 检查防火墙和网络策略

确保没有防火墙或网络策略阻止应用程序访问 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 应用程序

完成上述检查和配置后,重新启动你的 Spring Boot 应用程序:

mvn spring-boot:run

或者,如果你使用的是 Docker:

docker-compose up --build

通过上述步骤,你应该能够排查并解决 Spring Boot 应用程序无法连接到 Elasticsearch 服务的问题。确保 Elasticsearch 服务运行正常,配置正确,并且网络畅通。

lvxing_ood-hcvmu

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);
    }
}

}

Avatar
Avatar

你的问题是由于 MyBatis 试图通过反射访问 oredCriteria 属性,但它找不到该属性的 getter 方法。根据 MyBatis 的要求,所有需要访问的属性都必须有对应的 getter 和 setter 方法。

解决方法

确保你的 UserStakingEarnDOExample 类中有 getOredCriteria 方法。你已经定义了这个方法,但请确保它没有被注释掉,并且其定义是正确的。

检查点

  1. 检查 getOredCriteria 方法:确保 getOredCriteria 方法存在且没有拼写错误。
public List<Criteria> getOredCriteria() {
    return oredCriteria;
}
  1. 确保 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 的要求。

lvxing_ood-hcvmu

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); 上面构造条件的写法有没有问题

Avatar
Avatar

你的条件构造看起来基本上是正确的,但是在处理日期时间条件时,有一个小错误:

  • 你在两个条件中都使用了 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);

解释

  1. 用户ID和收益状态条件:

    • countCriteria.andUserIdEqualTo(rewardsHistoryRequest.getUserId()).andEarnStateEqualTo(1);:确保 userId 和 earnState 条件正确。
  2. 收益币种条件:

    • if (StringUtils.isNotEmpty(rewardsHistoryRequest.getEarnToken())) { countCriteria.andEarnTokenEqualTo(rewardsHistoryRequest.getEarnToken()); }:如果 earnToken 不为空,则添加该条件。
  3. 时间条件:

    • if (rewardsHistoryRequest.getStartTime() != null) { countCriteria.andUpdatedAtGreaterThanOrEqualTo(rewardsHistoryRequest.getStartTime()); }:如果 startTime 不为空,则添加该条件。
    • if (rewardsHistoryRequest.getEndTime() != null) { countCriteria.andUpdatedAtLessThanOrEqualTo(rewardsHistoryRequest.getEndTime()); }:如果 endTime 不为空,则添加该条件。

确保 MyBatis 映射正确

确保你的 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 映射文件中的字段映射正确,以避免任何可能的错误。通过这些调整,你应该能够正确查询并统计符合条件的记录数量。

lvxing_ood-hcvmu

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'

Avatar
Avatar

这个错误提示 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 属性。

检查点和解决方案

  1. 检查 MyBatis 映射文件:确保在 MyBatis 映射文件中没有错误地引用 distinct 属性。
  2. 检查 MyBatis 生成的代码:如果你使用 MyBatis Generator 来生成代码,确保生成的代码没有错误。
  3. 确保 getter 方法存在:确保 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 映射文件正确

确保你的 MyBatis 映射文件中没有错误地引用 distinct 属性。

示例 MyBatis 映射文件

<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 映射文件中没有错误地引用属性。

lvxing_ood-hcvmu

<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]

Avatar
Avatar

从你的描述中可以看出,你正在使用 MyBatis 查询来获取用户的奖励信息,并且你遇到了一个问题,即日志信息中显示的结果是 [null],这意味着查询结果中的元素是 null。可能原因有以下几种:

  1. 查询返回的列名和映射对象的字段名不匹配。
  2. SQL 查询中的条件逻辑有问题,导致没有匹配的记录。
  3. MyBatis 映射配置存在问题。

解决方案

1. 确保列名和字段名匹配

确保 SQL 查询返回的列名与 EarnTokenDO 类中的字段名匹配。你可以在 SQL 查询中使用别名来确保列名与字段名一致。

2. 检查 MyBatis 映射配置

确保 MyBatis 映射配置是正确的。你可以使用 resultMap 来明确指定列名和字段名的映射关系。

修改后的代码

1. SQL 查询

修改 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 &gt;= #{startTime,jdbcType=TIMESTAMP}
    </if>
    <if test="endTime != null">
      AND updated_at &lt;= #{endTime,jdbcType=TIMESTAMP}
    </if>
    GROUP BY
      earn_token
</select>

2. Mapper 接口

确保你的 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);
}

3. 数据对象

确保你的数据对象 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 +
                '}';
    }
}

4. 调用示例

确保在调用方法时传递了正确的参数,并且日志打印的结果正确:

List<EarnTokenDO> earnTokenDOList = userStakingEarnMapper.getEarnTokenByEarnTokenGroup(
        rewardsHistoryRequest.getUserId(),
        rewardsHistoryRequest.getEarnToken(),
        rewardsHistoryRequest.getStartTime(),
        rewardsHistoryRequest.getEndTime()
);

log.info("getRewardsHistorySummary.earnTokenDOList: {}", earnTokenDOList);

5. 检查 SQL 查询结果

确保 SQL 查询在数据库中返回正确的结果。你可以将生成的 SQL 查询直接在数据库中运行,确保它返回预期的结果。

总结

通过确保 SQL 查询返回的列名与 EarnTokenDO 类中的字段名一致,并正确配置 MyBatis 映射,你应该能够解决查询结果为 null 的问题。通过上述修改和检查,你应该能够正确地从数据库中查询数据并打印日志。

lvxing_ood-hcvmu

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

Avatar
Avatar

为了在不传递 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);

注意事项

  1. @RequestParam 的 defaultValue 属性:defaultValue 属性用于在请求参数缺失时提供默认值。
  2. @Min 注解:@Min(1) 注解用于验证 currentPage 是否大于或等于 1,但是它不允许 require 属性。require 应该在 @RequestParam 注解中使用。
  3. @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<>();
    }
}

解释

  1. @RequestParam 的 defaultValue 属性:通过设置 defaultValue = "1",确保在 currentPage 参数未传递时,默认值为 1。
  2. @Min 注解:确保 currentPage 至少为 1。
  3. @Range 注解:确保 pageSize 在 1 到 30 的范围内。
  4. 默认值逻辑:如果 pageSize 参数未传递,手动设置一个默认值,例如 10。

通过这种方式,你可以确保在未传递 currentPage 参数时,使用默认值 1,并且在未传递 pageSize 参数时,使用默认值 10。这样可以保证分页参数的正确性和健壮性。

lvxing_ood-hcvmu

pageSize也在不传的时候给个默认值

Avatar
Avatar

为了确保在不传递 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<>();
    }
}

解释

  1. @RequestParam 的 defaultValue 属性:通过设置 defaultValue = "1" 和 defaultValue = "10",确保在 currentPage 和 pageSize 参数未传递时,使用默认值 1 和 10。
  2. @Min 和 @Max 注解:确保 currentPage 至少为 1,pageSize 在 1 到 30 的范围内。
  3. @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。这样可以保证分页参数的正确性和健壮性。

lvxing_ood-hcvmu

@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);

Avatar
Avatar

你的代码片段展示了使用 Spring Boot 和 Swagger 注解来定义一个 RESTful API 接口。这个接口用于获取活动详情,并且支持通过请求参数传递语言和收益币种。

代码解释

  • @ApiOperation:用于描述接口的用途和请求方法。
  • @GetMapping:指定请求路径和方法类型(GET)。
  • @RequestParam:用于获取请求参数,其中 lang 参数有默认值 en_US,earnToken 参数是必须的。

完整示例

以下是一个完整的 Spring Boot 控制器示例,展示了如何使用 Swagger 注解和 Spring 的注解来定义和处理请求。

1. 导入必要的依赖

确保你的项目中已经包含了 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>

2. 配置 Swagger

创建一个配置类来启用和配置 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();
    }
}

3. 创建控制器

创建一个控制器类,定义 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);
    }
}

4. 定义返回数据对象

定义返回的数据对象 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;
    }
}

5. 运行和测试

启动 Spring Boot 应用程序,访问 Swagger UI 进行测试,默认情况下,Swagger UI 可以在 http://localhost:8080/swagger-ui/ 访问。你可以看到刚才定义的 API 接口,并可以在界面上进行测试。

解释

  1. @ApiOperation:描述 API 的用途和 HTTP 方法。
  2. @GetMapping:定义 GET 请求路径。
  3. @RequestParam:获取请求参数,其中 lang 参数有默认值 en_US,earnToken 参数是必须的。
  4. 业务逻辑:在 getCampaignDetails 方法中模拟业务逻辑,返回活动详情。
  5. 返回结果:使用 GenericResult 包装返回的活动详情对象 GemPoolCampaignVO。

通过这种方式,你可以定义一个带有默认参数值的 API 接口,并使用 Swagger 进行文档化和测试。

lvxing_ood-hcvmu

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;;
}}请帮我简化一下

Avatar
Avatar

你的代码逻辑是对 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;
    }
}

解释

  1. 提取公共逻辑:

    • 提取 campaign.getInnerTest() == 1 为 isInnerTest。
    • 提取 StringUtils.isNotEmpty(userId) 为 isUserLoggedIn。
    • 提取 CollectionUtils.isNotEmpty(whitelist) && whitelist.contains(userId) 为 isUserInWhitelist。
  2. 简化条件判断:

    • 使用一个 if 语句来处理所有情况:
      • 如果活动是内测的 (isInnerTest 为 true),并且用户未登录 (!isUserLoggedIn) 或用户不在白名单中 (!isUserInWhitelist),则跳过该活动。

逻辑总结

  • 内测活动:isInnerTest 为 true。
  • 用户未登录或用户不在白名单中:!isUserLoggedIn || !isUserInWhitelist。
  • 跳过条件:如果是内测活动且用户未登录或用户不在白名单中,则跳过。

通过这种方式,可以使代码更加简洁清晰,同时保持原有逻辑不变。

lvxing_ood-hcvmu

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塞值

Avatar
Avatar

虽然 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(/* 初始化参数 */)
        );
    }
}

解释

  1. map 方法:使用 map 方法将原始数据列表 campaignPools 转换为新的 PoolHisVO 对象列表。
  2. PoolHisVO.PoolHisVOBuilder:使用 PoolHisVO 的 Builder 模式来生成对象,这样可以在构建对象的过程中添加逻辑。
  3. 添加逻辑:在 map 方法内部编写逻辑,根据需要设置 PoolHisVO 对象的字段值。
  4. 收集结果:使用 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 方法中添加逻辑,可以在转换过程中对数据进行处理,并生成包含所需值的新对象。

lvxing_ood-hcvmu

//挖矿结束时间大于现在并且挖矿结束时间在结束的24小时内
StakingCampaignPoolDOExample stakingCampaignPoolDOExample = new StakingCampaignPoolDOExample();
Date now = DateTimeUtils.getNowDateUTC8();
stakingCampaignPoolDOExample.createCriteria()
.andStakingEndTimeLessThanOrEqualTo(now);
List<StakingCampaignPoolDO> stakingCampaignPoolDOS = stakingCampaignPoolMapper.selectByExample(stakingCampaignPoolDOExample); 怎么实现查结束时间小于现在但是,现在没有超过结束后1小时

Avatar
Avatar

要实现查询挖矿结束时间小于当前时间但未超过结束后1小时的记录,你需要两个条件:

  1. 挖矿结束时间小于当前时间。
  2. 挖矿结束时间大于当前时间减去1小时。

实现步骤

  1. 获取当前时间 now。
  2. 计算当前时间减去1小时的时间 oneHourAgo。
  3. 使用两个条件构建查询: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);
    }
}

解释

  1. 获取当前时间:Date now = DateTimeUtils.getNowDateUTC8();
  2. 计算当前时间减去1小时的时间:Date oneHourAgo = new Date(now.getTime() - 3600 * 1000);
  3. 构建查询条件:
    • andStakingEndTimeLessThanOrEqualTo(now):挖矿结束时间小于当前时间。
    • andStakingEndTimeGreaterThan(oneHourAgo):挖矿结束时间大于当前时间减去1小时。
  4. 执行查询:stakingCampaignPoolMapper.selectByExample(stakingCampaignPoolDOExample);

MyBatis Mapper 配置

确保你的 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)。

lvxing_ood-hcvmu

错了。挖矿结束时间小于现在是对的。表示挖矿已经结束。但是还需要查出当前时间不要超过(挖矿结束时间+1小时)

Avatar
Avatar

明白了,你的需求是查询挖矿结束时间小于当前时间,并且当前时间不超过挖矿结束时间再加上1小时。换句话说,你需要找到那些挖矿刚刚结束且在结束后的1小时内的记录。

实现步骤

  1. 获取当前时间 now。
  2. 计算时间范围的边界,即当前时间减去1小时的时间 oneHourAgo。
  3. 使用两个条件构建查询: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);
    }
}

解释

  1. 获取当前时间:Date now = DateTimeUtils.getNowDateUTC8();
  2. 计算当前时间减去1小时的时间:Date oneHourAgo = new Date(now.getTime() - 3600 * 1000);
  3. 构建查询条件:
    • andStakingEndTimeLessThanOrEqualTo(now):挖矿结束时间在当前时间之前。
    • andStakingEndTimeGreaterThan(oneHourAgo):挖矿结束时间在当前时间减去1小时之后。
  4. 执行查询:stakingCampaignPoolMapper.selectByExample(stakingCampaignPoolDOExample);

MyBatis Mapper 配置

确保你的 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)。

lvxing_ood-hcvmu

public static Date addMinutesToDate(Date date, int minutes) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(Calendar.MINUTE, minutes);
return calendar.getTime();
}按照这个方法写一个减5分钟的方法

Avatar
Avatar

你可以使用类似的方法来编写一个减去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);
    }
}

解释

  1. 方法定义:

    • public static Date subtractMinutesFromDate(Date date, int minutes): 定义一个静态方法,接受一个 Date 对象和一个整数 minutes,返回减去指定分钟数后的 Date 对象。
  2. 使用 Calendar 类:

    • Calendar calendar = Calendar.getInstance();:获取一个 Calendar 实例。
    • calendar.setTime(date);:将 Calendar 的时间设置为传入的 Date 对象。
    • calendar.add(Calendar.MINUTE, -minutes);:使用 add 方法减去指定的分钟数。注意这里传递的是负值 -minutes。
  3. 返回结果:

    • 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 类的方法进行时间操作,可以方便地对日期进行加减操作。

lvxing_ood-hcvmu

/*

  • Copyright 2019 Mek Global Limited
    */

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;

    /**

    • 整体逻辑:
    • 从收益计算任务表捞需要计算收益的任务
    • 遍历计算收益任务,从汇总表里每次捞1000条数据处理
    • 我们整个定时任务是注册了3个分片(apollo可配置)
    • 我们会根据分片和当前节点分配的分片号,根据汇总表的主键ID/总的分片数是否等于分片号为条件查汇总表的目标用户数据
    • 批量插入到收益表
    • 然后更新汇总表的计算状态为完成
    • 插入和更新是一个事务
    • @param context
      */
      @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());
      //干之前看看是不是还有未计算的用户
      //如果没有,这个task就可以把状态更改为完成了
      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 (!userRewardSummaries.isEmpty()) {
      List<UserRewardSummaryDO> finalUserRewardSummaries1 = userRewardSummaries;
      summaryRewardJobExecutor.submit(() -> {
      summaryRewardService.processRewardsTransaction(finalUserRewardSummaries1,stakingCampaignPoolDO,sumStakingAmount,stakingCampaignDO);
      });
      lastId = userRewardSummaries.get(userRewardSummaries.size() - 1).getId();
      }
      } while (!userRewardSummaries.isEmpty());
      }
      }
      }

    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开始,但是一旦这个记录处理后,后面就查不出来了

Avatar
Avatar

你指出的正确,当前代码中的逻辑确实存在一个问题,即每次循环都从 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);
    }
}

解释

  1. lastId 的更新:

    • 在每次从数据库中获取一批数据后,更新 lastId 为当前批次最后一条记录的 ID。
    • 确保下一次查询能够从上次查询结果的最后一个 ID 开始,避免重复处理或漏处理数据。
  2. CollectionUtils.isNotEmpty 的使用:

    • 在 do-while 循环中使用 CollectionUtils.isNotEmpty 检查列表是否为空,确保仅在有数据时才进行处理。

总结

通过在每次批量处理后更新 lastId,你可以确保数据处理的连续性和完整性,避免重复处理或漏处理数据。确保在每次查询后更新 lastId,使下次查询能够继续处理剩余的数据。这样可以确保任务能够正确处理所有分片的数据,并且在大数据量的情况下高效运行。

lvxing_ood-hcvmu

<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开始,就会造成空转

Avatar
Avatar

你提到的正确,如果定时任务是循环执行的,id 应该从上次处理的最后一个 ID 开始,而不是每次都从 0 开始。为了实现这一点,可以使用上次处理的最后一个 id 来继续查询。

修改 SQL 查询

确保 SQL 查询中正确使用 id 参数来实现分页,并避免空转。你提到的查询条件有一个错误,应该修正为 id > #{id,jdbcType=BIGINT}。

修改后的 SQL 查询

<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);
    }
}

解释

  1. SQL 查询:
    • 确保 SQL 查询中正确使用 id 参数来实现分页:and id > #{id,jdbcType=BIGINT}。
  2. 任务逻辑:
    • 在每次批量处理后更新 lastId,确保下次查询能够继续处理剩余的数据。
  3. 避免空转:
    • 通过使用 lastId 来实现分页,确保定时任务在循环执行时不会从头开始,从而避免空转。

通过这种方式,可以确保定时任务在循环执行时能够正确处理所有数据,并避免空转。确保在每次查询后更新 lastId,使下次查询能够继续处理剩余的数据。这样可以确保任务能够正确处理所有分片的数据,并且在大数据量的情况下高效运行。

lvxing_ood-hcvmu

还是有问题,有可能id1~10000都已经是计算完成的。从0开始的话,1~10000不是都白跑了么

Avatar
Avatar

你提到的正确,考虑到 ID 可能已经被处理过(cal_state 已经被更新为已处理),我们需要确保查询时跳过这些已经处理过的记录。为了解决这个问题,可以引入一个新的策略:

  1. 使用 cal_state 作为筛选条件:只查询 cal_state 为未处理(0)的记录。
  2. 基于 lastId 和 cal_state 进行分页:确保在每次查询时跳过已经处理的记录,并从上次处理的最后一个 ID 开始。

修改后的 SQL 查询

确保 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);
    }
}

解释

  1. SQL 查询:
    • 确保 SQL 查询中正确使用 id 参数来实现分页:and id > #{id,jdbcType=BIGINT}。
    • 确保只查询 cal_state 为 0 的记录:and cal_state = 0。
  2. 任务逻辑:
    • 在每次批量处理后更新 lastId,确保下次查询能够继续处理剩余的数据。
    • 通过使用 lastId 来实现分页,确保定时任务在循环执行时不会从头开始,从而避免空转。

通过这种方式,可以确保定时任务在循环执行时能够正确处理所有数据,并避免空转。确保在每次查询后更新 lastId,使下次查询能够继续处理剩余的数据。这样可以确保任务能够正确处理所有分片的数据,并且在大数据量的情况下高效运行。

lvxing_ood-hcvmu

我是说定时任务假设每5分钟运行一次。第二个五分钟跑的时候,第一个已经处理了1000个记录并且设置cal_state = 0了。而id是mysql自增长的。第二个五分钟跑的时候lastId从0开始,不是空跑么

Avatar
Avatar

你提到的正确,如果定时任务每5分钟运行一次,且在前一次运行中已经处理了部分记录并将其 cal_state 更新为 1,那么在下一次运行时,不应再从 lastId 为 0 开始,而是应该继续处理未处理的记录。

为了解决这个问题,可以在每次查询时记录上一次处理的最后一个 ID,并在下一次运行时从这个 ID 开始。

解决方案

  1. 记录上次处理的最后一个 ID:在任务执行的上下文中记录上一次处理的最后一个 ID。
  2. 从上次记录的 ID 开始查询:在下一次运行时,从上次记录的 ID 开始查询。

示例代码

以下是一个示例代码,展示了如何实现这一逻辑:

1. 修改 SQL 查询

确保 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>

2. 修改任务逻辑

在任务执行过程中记录最后处理的 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);
    }
}

解释

  1. 使用 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。
  2. SQL 查询:确保 SQL 查询中正确使用 id 参数来实现分页,并跳过已处理的记录。

  3. 任务逻辑:在每次批量处理后更新 lastId 和 lastProcessedIdMap,确保下次查询能够继续处理剩余的数据。

通过这种方式,可以确保定时任务在循环执行时能够正确处理所有数据,并避免空转。确保在每次查询后更新 lastId,使下次查询能够继续处理剩余的数据。这样可以确保任务能够正确处理所有分片的数据,并且在大数据量的情况下高效运行。

lvxing_ood-hcvmu

但是要是服务器重启了,数据也丢了

Avatar
Avatar

为了确保在服务器重启后数据不丢失,我们需要将 lastId 持久化存储。一个常见的解决方案是将 lastId 保存到数据库中。这样,即使服务器重启,我们也可以从数据库中读取上次处理的 lastId,继续处理剩余的数据。

修改方案

  1. 在数据库中记录 lastId:创建一个新的表来记录每个任务的 lastId。
  2. 在任务执行过程中读取和更新 lastId:在任务开始时从数据库读取 lastId,在任务结束时更新 lastId。

示例代码

1. 创建数据库表

创建一个新的表 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)
);

2. 修改任务逻辑

在任务执行过程中读取和更新 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);
    }
}

3. 创建 Mapper 接口和 XML 文件

TaskLastIdMapper.java
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);
}
TaskLastIdMapper.xml
<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>

解释

  1. 数据库表:创建一个新的表 task_last_id 来记录每个任务的 lastId,确保在服务器重启后数据不丢失。
  2. Mapper 接口和 XML 文件:定义 TaskLastIdMapper 接口和相应的 XML 文件,用于从数据库读取和更新 lastId。
  3. 任务逻辑:
    • 在任务开始时,从数据库读取 lastId。
    • 在任务结束时,将最新的 lastId 更新到数据库。

通过这种方式,可以确保在服务器重启后数据不丢失,并且定时任务能够正确处理所有数据。在每次查询后更新 lastId,使下次查询能够继续处理剩余的数据。这样可以确保任务能够正确处理所有分片的数据,并且在大数据量的情况下高效运行。

lvxing_ood-hcvmu

<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}

Avatar
Avatar

要确保同一个 campaign 和 userId 的数据分配到同一个分片,你可以使用 MOD 函数基于 userId 和 campaignId 的组合进行分片。这种方式确保对于相同的 userId 和 campaignId,MOD 计算的结果是相同的,从而确保数据分配到同一个分片。

修改 SQL 查询

确保 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>

注意事项

  1. CONCAT 函数:确保数据库支持 CONCAT 函数,以将 campaign_id 和 user_id 连接起来。
  2. 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);
    }
}

解释

  1. SQL 查询:

    • 使用 MOD(CONCAT(campaign_id, user_id), #{shardingTotalCount,jdbcType=INTEGER}) 确保同一个 campaign 和 userId 的数据分配到同一个分片。
  2. 任务逻辑:

    • 在每次批量处理后更新 lastId,确保下次查询能够继续处理剩余的数据。
    • 使用 lastProcessedIdMap 和 taskLastIdMapper 确保在服务器重启后数据不丢失,并从数据库中读取上次处理的 lastId。

通过这种方式,可以确保同一个 campaign 和 userId 的数据分配到同一个分片,并在服务器重启后数据不丢失。在每次查询后更新 lastId,使下次查询能够继续处理剩余的数据。这样可以确保任务能够正确处理所有分片的数据,并且在大数据量的情况下高效运行。

lvxing_ood-hcvmu

那这样id>lastId有可能会不连续吧

Avatar
Avatar

你提到的正确,根据 id > lastId 进行分页查询可能会导致不连续的问题,特别是当 id 不是连续的。为了解决这个问题,我们可以使用其他方法来确保分页的连续性,例如基于复合键(campaign_id 和 user_id)进行分片,并使用这些键来确保数据的唯一性和连续性。

修改方案

  1. 基于复合键进行分片:确保同一个 campaign_id 和 user_id 的数据分配到同一个分片。
  2. 分页查询时使用 campaign_id 和 user_id:通过分页查询时使用 campaign_id 和 user_id 来确保数据的连续性。

1. 修改 SQL 查询

确保 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>

2. 修改任务逻辑

确保任务逻辑正确处理分页数据,并在每次批量处理后更新 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
lvxing_ood-hcvmu

但是我只有主键ID是自增长的bigint,campaignId和userId都是24未唯一字符串

Avatar
Avatar

明白了,如果 campaignId 和 userId 是唯一的字符串,并且你只有一个自增长的主键 id,你可以继续使用 id 作为分页的依据,但需要确保查询条件和逻辑的正确性,以避免数据不连续的问题。以下是修改后的方案:

1. 修改 SQL 查询

确保 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>

2. 修改任务逻辑

确保任务逻辑正确处理分页数据,并在每次批量处理后更新 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);
    }
}

解释

  1. SQL 查询:

    • 使用 MOD(CONCAT(campaign_id, user_id), #{shardingTotalCount,jdbcType=INTEGER}) 确保同一个 campaignId 和 userId 的数据分配到同一个分片。
    • 使用 id > #{lastId,jdbcType=BIGINT} 确保分页查询。
  2. 任务逻辑:

    • 在每次批量处理后更新 lastId,确保下次查询能够继续处理剩余的数据。
    • 使用 lastProcessedIdMap 和 taskLastIdMapper 确保在服务器重启后数据不丢失,并从数据库中读取上次处理的 lastId。

通过这种方式,可以确保同一个 campaignId 和 userId 的数据分配到同一个分片,并在服务器重启后数据不丢失。在每次查询后更新 lastId,使下次查询能够继续处理剩余的数据。这样可以确保任务能够正确处理所有分片的数据,并且在大数据量的情况下高效运行。

lvxing_ood-hcvmu

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方法

Avatar
Avatar

要补全 symbolSyncKafkaConsumer 方法,使其能够正确订阅 Kafka 主题并消费消息,你需要完成以下步骤:

  1. 订阅主题:使用 subscribe 方法订阅一个或多个主题。
  2. 设置分区(可选):如果需要消费特定的分区,可以使用 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;
    }
}

解释

  1. 配置 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:设置消费者在没有初始偏移量或偏移量超出范围时的行为。
  2. 订阅主题:

    • 使用 consumer.subscribe(Collections.singletonList(topic)) 方法订阅主题 SPOT_GEM_POOL_STAKING_HOLD。
  3. 日志记录:

    • 记录 Kafka 服务器地址,方便调试和监控。

处理消息

你可以在服务类中使用这个 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 来订阅和消费消息。确保在配置和使用过程中正确处理消息,并手动提交偏移量,以确保消息的高效和可靠消费。