SpringBoot的4种抽奖活动实现策略

抽奖系统(5——抽奖模块) 抽奖设计、RabbitMQ 的配置与使用、抽奖请求处理、MQ 异步抽奖逻辑执行、中奖名单设计 阅读详情

抽奖活动是产品运营中常见的用户激励和互动手段,通过随机性和奖励刺激用户参与度,提升用户活跃度和留存率。

在技术实现上,抽奖系统涉及到随机算法、奖品分配、防作弊机制等多方面内容。

本文将介绍基于SpringBoot实现抽奖活动的5种策略。

一、基于内存的简单抽奖策略

1.1 基本原理

最简单的抽奖策略是将所有奖品信息加载到内存中,通过随机数算法从奖品池中选取一个奖品。

这种方式实现简单,适合奖品种类少、规则简单的小型抽奖活动。

1.2 实现方式

首先定义奖品实体:

@Data
public class Prize {
    private Long id;
    private String name;
    private String description;
    private Integer probability; // 中奖概率,1-10000之间的数字,表示万分之几
    private Integer stock;       // 库存
    private Boolean available;   // 是否可用
}

然后实现抽奖服务:

@Service
public class SimpleDrawService {
    
    private final List<Prize> prizePool = new ArrayList<>();
    private final Random random = new Random();
    
    // 初始化奖品池
    @PostConstruct
    public void init() {
        // 奖品1: 一等奖,概率0.01%,库存10
        Prize firstPrize = new Prize();
        firstPrize.setId(1L);
        firstPrize.setName("一等奖");
        firstPrize.setDescription("iPhone 14 Pro");
        firstPrize.setProbability(1); // 万分之1
        firstPrize.setStock(10);
        firstPrize.setAvailable(true);
        
        // 奖品2: 二等奖,概率0.1%,库存50
        Prize secondPrize = new Prize();
        secondPrize.setId(2L);
        secondPrize.setName("二等奖");
        secondPrize.setDescription("AirPods Pro");
        secondPrize.setProbability(10); // 万分之10
        secondPrize.setStock(50);
        secondPrize.setAvailable(true);
        
        // 奖品3: 三等奖,概率1%,库存500
        Prize thirdPrize = new Prize();
        thirdPrize.setId(3L);
        thirdPrize.setName("三等奖");
        thirdPrize.setDescription("100元优惠券");
        thirdPrize.setProbability(100); // 万分之100
        thirdPrize.setStock(500);
        thirdPrize.setAvailable(true);
        
        // 奖品4: 谢谢参与,概率98.89%,无限库存
        Prize noPrize = new Prize();
        noPrize.setId(4L);
        noPrize.setName("谢谢参与");
        noPrize.setDescription("再接再厉");
        noPrize.setProbability(9889); // 万分之9889
        noPrize.setStock(Integer.MAX_VALUE);
        noPrize.setAvailable(true);
        
        prizePool.add(firstPrize);
        prizePool.add(secondPrize);
        prizePool.add(thirdPrize);
        prizePool.add(noPrize);
    }
    
    // 抽奖方法
    public synchronized Prize draw() {
        // 生成一个1-10000之间的随机数
        int randomNum = random.nextInt(10000) + 1;
        
        int probabilitySum = 0;
        for (Prize prize : prizePool) {
            if (!prize.getAvailable() || prize.getStock() <= 0) {
                continue; // 跳过不可用或无库存的奖品
            }
            
            probabilitySum += prize.getProbability();
            if (randomNum <= probabilitySum) {
                // 减少库存
                prize.setStock(prize.getStock() - 1);
                
                // 如果库存为0,设置为不可用
                if (prize.getStock() <= 0) {
                    prize.setAvailable(false);
                }
                
                return prize;
            }
        }
        
        // 如果所有奖品都不可用,返回默认奖品
        return getDefaultPrize();
    }
    
    private Prize getDefaultPrize() {
        for (Prize prize : prizePool) {
            if (prize.getName().equals("谢谢参与")) {
                return prize;
            }
        }
        
        // 创建一个默认奖品
        Prize defaultPrize = new Prize();
        defaultPrize.setId(999L);
        defaultPrize.setName("谢谢参与");
        defaultPrize.setDescription("再接再厉");
        return defaultPrize;
    }
}

控制器实现:

@RestController
@RequestMapping("/api/draw")
public class DrawController {
    
    @Autowired
    private SimpleDrawService drawService;
    
    @GetMapping("/simple")
    public Prize simpleDraw() {
        return drawService.draw();
    }
}

1.3 优缺点分析

优点:

  • 实现简单,开发成本低
  • 无需数据库支持,启动即可使用

缺点:

  • 不适合大规模并发场景
  • 服务重启后数据丢失,无法保证奖品总量控制
  • 难以实现用户抽奖次数限制和作弊防护

1.4 适用场景

  • 小型活动或测试环境
  • 奖品总量不敏感的场景
  • 单机部署的简单应用
  • 对抽奖公平性要求不高的场景

二、基于数据库的抽奖策略

2.1 基本原理

将奖品信息、抽奖记录等数据存储在数据库中,通过数据库事务来保证奖品库存的准确性和抽奖记录的完整性。

这种方式适合需要持久化数据并且对奖品库存有严格管理要求的抽奖活动。

2.2 实现方式

数据库表设计:

-- 奖品表
CREATE TABLE prize (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(100) NOT NULL,
    description VARCHAR(255),
    probability INT NOT NULL COMMENT '中奖概率,1-10000之间的数字,表示万分之几',
    stock INT NOT NULL COMMENT '库存',
    available BOOLEAN DEFAULT TRUE COMMENT '是否可用'
);

-- 抽奖记录表
CREATE TABLE draw_record (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    user_id BIGINT NOT NULL COMMENT '用户ID',
    prize_id BIGINT COMMENT '奖品ID',
    draw_time DATETIME NOT NULL COMMENT '抽奖时间',
    ip VARCHAR(50) COMMENT '用户IP地址',
    INDEX idx_user_id (user_id)
);

-- 抽奖活动表
CREATE TABLE draw_activity (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(100) NOT NULL COMMENT '活动名称',
    start_time DATETIME NOT NULL COMMENT '开始时间',
    end_time DATETIME NOT NULL COMMENT '结束时间',
    daily_limit INT DEFAULT 1 COMMENT '每人每日抽奖次数限制',
    total_limit INT DEFAULT 10 COMMENT '每人总抽奖次数限制',
    active BOOLEAN DEFAULT TRUE COMMENT '是否激活'
);

实体类:

@Data
@Entity
@Table(name = "prize")
public class Prize {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    private String description;
    
    private Integer probability;
    
    private Integer stock;
    
    private Boolean available;
}

@Data
@Entity
@Table(name = "draw_record")
public class DrawRecord {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "user_id")
    private Long userId;
    
    @Column(name = "prize_id")
    private Long prizeId;
    
    @Column(name = "draw_time")
    private LocalDateTime drawTime;
    
    private String ip;
}

@Data
@Entity
@Table(name = "draw_activity")
public class DrawActivity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    @Column(name = "start_time")
    private LocalDateTime startTime;
    
    @Column(name = "end_time")
    private LocalDateTime endTime;
    
    @Column(name = "daily_limit")
    private Integer dailyLimit;
    
    @Column(name = "total_limit")
    private Integer totalLimit;
    
    private Boolean active;
}

Repository 接口:

public interface PrizeRepository extends JpaRepository<Prize, Long> {
    List<Prize> findByAvailableTrueAndStockGreaterThan(int stock);
}

public interface DrawRecordRepository extends JpaRepository<DrawRecord, Long> {
    long countByUserIdAndDrawTimeBetween(Long userId, LocalDateTime start, LocalDateTime end);
    
    long countByUserId(Long userId);
}

public interface DrawActivityRepository extends JpaRepository<DrawActivity, Long> {
    Optional<DrawActivity> findByActiveTrue();
}

服务实现:

@Service
@Transactional
public class DatabaseDrawService {
    
    @Autowired
    private PrizeRepository prizeRepository;
    
    @Autowired
    private DrawRecordRepository drawRecordRepository;
    
    @Autowired
    private DrawActivityRepository drawActivityRepository;
    
    private final Random random = new Random();
    
    public Prize draw(Long userId, String ip) {
        // 检查活动是否有效
        DrawActivity activity = drawActivityRepository.findByActiveTrue()
                .orElseThrow(() -> new RuntimeException("No active draw activity"));
        
        LocalDateTime now = LocalDateTime.now();
        if (now.isBefore(activity.getStartTime()) || now.isAfter(activity.getEndTime())) {
            throw new RuntimeException("Draw activity is not in progress");
        }
        
        // 检查用户抽奖次数限制
        checkDrawLimits(userId, activity);
        
        // 获取所有可用奖品
        List<Prize> availablePrizes = prizeRepository.findByAvailableTrueAndStockGreaterThan(0);
        if (availablePrizes.isEmpty()) {
            throw new RuntimeException("No available prizes");
        }
        
        // 计算总概率
        int totalProbability = availablePrizes.stream()
                .mapToInt(Prize::getProbability)
                .sum();
        
        // 生成随机数
        int randomNum = random.nextInt(totalProbability) + 1;
        
        // 根据概率选择奖品
        int probabilitySum = 0;
        Prize selectedPrize = null;
        
        for (Prize prize : availablePrizes) {
            probabilitySum += prize.getProbability();
            if (randomNum <= probabilitySum) {
                selectedPrize = prize;
                break;
            }
        }
        
        if (selectedPrize == null) {
            throw new RuntimeException("Failed to select a prize");
        }
        
        // 减少库存
        selectedPrize.setStock(selectedPrize.getStock() - 1);
        if (selectedPrize.getStock() <= 0) {
            selectedPrize.setAvailable(false);
        }
        prizeRepository.save(selectedPrize);
        
        // 记录抽奖
        DrawRecord record = new DrawRecord();
        record.setUserId(userId);
        record.setPrizeId(selectedPrize.getId());
        record.setDrawTime(now);
        record.setIp(ip);
        drawRecordRepository.save(record);
        
        return selectedPrize;
    }
    
    private void checkDrawLimits(Long userId, DrawActivity activity) {
        // 检查每日抽奖次数限制
        LocalDateTime startOfDay = LocalDate.now().atStartOfDay();
        LocalDateTime endOfDay = LocalDate.now().plusDays(1).atStartOfDay().minusNanos(1);
        
        long dailyDraws = drawRecordRepository.countByUserIdAndDrawTimeBetween(userId, startOfDay, endOfDay);
        if (dailyDraws >= activity.getDailyLimit()) {
            throw new RuntimeException("Daily draw limit exceeded");
        }
        
        // 检查总抽奖次数限制
        long totalDraws = drawRecordRepository.countByUserId(userId);
        if (totalDraws >= activity.getTotalLimit()) {
            throw new RuntimeException("Total draw limit exceeded");
        }
    }
}

控制器实现:

@RestController
@RequestMapping("/api/draw")
public class DatabaseDrawController {
    
    @Autowired
    private DatabaseDrawService databaseDrawService;
    
    @GetMapping("/database")
    public Prize databaseDraw(@RequestParam Long userId, HttpServletRequest request) {
        String ip = request.getRemoteAddr();
        return databaseDrawService.draw(userId, ip);
    }
}

2.3 优缺点分析

优点:

  • 数据持久化,服务重启不丢失
  • 可靠的库存管理和抽奖记录
  • 支持用户抽奖次数限制和活动时间控制
  • 易于扩展其他业务需求

缺点:

  • 数据库操作带来的性能开销
  • 高并发场景下可能出现数据库瓶颈
  • 实现相对复杂,开发成本较高

2.4 适用场景

  • 中小型抽奖活动
  • 需要精确控制奖品库存的场景
  • 需要完整抽奖记录和数据分析的场景

三、基于Redis的高性能抽奖策略

3.1 基本原理

利用Redis的高性能和原子操作特性来实现抽奖系统,将奖品信息和库存存储在Redis中,通过Lua脚本实现原子抽奖操作。这种方式适合高并发抽奖场景,能够提供极高的性能和可靠的数据一致性。

3.2 实现方式

首先配置Redis:

@Configuration
public class RedisConfig {
    
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        
        template.afterPropertiesSet();
        return template;
    }
}

抽奖服务实现:

@Service
public class RedisDrawService {
    
    private static final String PRIZE_HASH_KEY = "draw:prizes";
    private static final String DAILY_DRAW_COUNT_KEY = "draw:daily:";
    private static final String TOTAL_DRAW_COUNT_KEY = "draw:total:";
    private static final String DRAW_RECORD_KEY = "draw:records:";
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    
    @PostConstruct
    public void init() {
        // 初始化奖品数据
        if (!redisTemplate.hasKey(PRIZE_HASH_KEY)) {
            Map<String, Prize> prizes = new HashMap<>();
            
            Prize firstPrize = new Prize();
            firstPrize.setId(1L);
            firstPrize.setName("一等奖");
            firstPrize.setDescription("iPhone 14 Pro");
            firstPrize.setProbability(1); // 万分之1
            firstPrize.setStock(10);
            firstPrize.setAvailable(true);
            prizes.put("1", firstPrize);
            
            Prize secondPrize = new Prize();
            secondPrize.setId(2L);
            secondPrize.setName("二等奖");
            secondPrize.setDescription("AirPods Pro");
            secondPrize.setProbability(10); // 万分之10
            secondPrize.setStock(50);
            secondPrize.setAvailable(true);
            prizes.put("2", secondPrize);
            
            Prize thirdPrize = new Prize();
            thirdPrize.setId(3L);
            thirdPrize.setName("三等奖");
            thirdPrize.setDescription("100元优惠券");
            thirdPrize.setProbability(100); // 万分之100
            thirdPrize.setStock(500);
            thirdPrize.setAvailable(true);
            prizes.put("3", thirdPrize);
            
            Prize noPrize = new Prize();
            noPrize.setId(4L);
            noPrize.setName("谢谢参与");
            noPrize.setDescription("再接再厉");
            noPrize.setProbability(9889); // 万分之9889
            noPrize.setStock(Integer.MAX_VALUE);
            noPrize.setAvailable(true);
            prizes.put("4", noPrize);
            
            // 将奖品信息存储到Redis
            redisTemplate.opsForHash().putAll(PRIZE_HASH_KEY, prizes);
        }
    }
    
    public Prize draw(Long userId) {
        // 检查用户抽奖限制
        checkDrawLimits(userId);
        
        // 获取所有可用奖品
        Map<Object, Object> prizeMap = redisTemplate.opsForHash().entries(PRIZE_HASH_KEY);
        List<Prize> availablePrizes = new ArrayList<>();
        
        for (Object obj : prizeMap.values()) {
            Prize prize = (Prize) obj;
            if (prize.getAvailable() && prize.getStock() > 0) {
                availablePrizes.add(prize);
            }
        }
        
        if (availablePrizes.isEmpty()) {
            throw new RuntimeException("No available prizes");
        }
        
        // 使用Lua脚本进行原子抽奖操作
        String script = "local prizes = redis.call('HGETALL', KEYS[1]) " +
                "local random = math.random(1, 10000) " +
                "local sum = 0 " +
                "local selected = nil " +
                "for id, prize in pairs(prizes) do " +
                "  if prize.available and prize.stock > 0 then " +
                "    sum = sum + prize.probability " +
                "    if random <= sum then " +
                "      selected = prize " +
                "      prize.stock = prize.stock - 1 " +
                "      if prize.stock <= 0 then " +
                "        prize.available = false " +
                "      end " +
                "      redis.call('HSET', KEYS[1], id, prize) " +
                "      break " +
                "    end " +
                "  end " +
                "end " +
                "return selected";
        
        // 由于Lua脚本在Redis中执行复杂对象有限制,我们这里简化处理,使用Java代码模拟
        // 实际生产环境建议使用更细粒度的Redis数据结构和脚本
        
        // 模拟抽奖逻辑
        Prize selectedPrize = drawPrizeFromPool(availablePrizes);
        
        // 减少库存并更新Redis
        selectedPrize.setStock(selectedPrize.getStock() - 1);
        if (selectedPrize.getStock() <= 0) {
            selectedPrize.setAvailable(false);
        }
        redisTemplate.opsForHash().put(PRIZE_HASH_KEY, selectedPrize.getId().toString(), selectedPrize);
        
        // 记录抽奖
        incrementUserDrawCount(userId);
        recordUserDraw(userId, selectedPrize);
        
        return selectedPrize;
    }
    
    private Prize drawPrizeFromPool(List<Prize> prizes) {
        int totalProbability = prizes.stream()
                .mapToInt(Prize::getProbability)
                .sum();
        
        int randomNum = new Random().nextInt(totalProbability) + 1;
        
        int probabilitySum = 0;
        for (Prize prize : prizes) {
            probabilitySum += prize.getProbability();
            if (randomNum <= probabilitySum) {
                return prize;
            }
        }
        
        // 默认返回最后一个奖品(通常是"谢谢参与")
        return prizes.get(prizes.size() - 1);
    }
    
    private void checkDrawLimits(Long userId) {
        // 检查每日抽奖次数
        String dailyKey = DAILY_DRAW_COUNT_KEY + userId + ":" + LocalDate.now();
        Integer dailyCount = (Integer) redisTemplate.opsForValue().get(dailyKey);
        
        if (dailyCount != null && dailyCount >= 3) { // 假设每日限制3次
            throw new RuntimeException("Daily draw limit exceeded");
        }
        
        // 检查总抽奖次数
        String totalKey = TOTAL_DRAW_COUNT_KEY + userId;
        Integer totalCount = (Integer) redisTemplate.opsForValue().get(totalKey);
        
        if (totalCount != null && totalCount >= 10) { // 假设总限制10次
            throw new RuntimeException("Total draw limit exceeded");
        }
    }
    
    private void incrementUserDrawCount(Long userId) {
        // 增加每日抽奖次数
        String dailyKey = DAILY_DRAW_COUNT_KEY + userId + ":" + LocalDate.now();
        redisTemplate.opsForValue().increment(dailyKey, 1);
        // 设置过期时间(第二天凌晨过期)
        long secondsUntilTomorrow = ChronoUnit.SECONDS.between(
                LocalDateTime.now(), 
                LocalDate.now().plusDays(1).atStartOfDay());
        redisTemplate.expire(dailyKey, secondsUntilTomorrow, TimeUnit.SECONDS);
        
        // 增加总抽奖次数
        String totalKey = TOTAL_DRAW_COUNT_KEY + userId;
        redisTemplate.opsForValue().increment(totalKey, 1);
    }
    
    private void recordUserDraw(Long userId, Prize prize) {
        String recordKey = DRAW_RECORD_KEY + userId;
        Map<String, Object> record = new HashMap<>();
        record.put("userId", userId);
        record.put("prizeId", prize.getId());
        record.put("prizeName", prize.getName());
        record.put("drawTime", LocalDateTime.now().toString());
        
        redisTemplate.opsForList().leftPush(recordKey, record);
    }
}

控制器实现:

@RestController
@RequestMapping("/api/draw")
public class RedisDrawController {
    
    @Autowired
    private RedisDrawService redisDrawService;
    
    @GetMapping("/redis")
    public Prize redisDraw(@RequestParam Long userId) {
        return redisDrawService.draw(userId);
    }
}

3.3 优缺点分析

优点:

  • 极高的性能,支持高并发场景
  • 原子操作保证数据一致性
  • 内存操作,响应速度快
  • Redis持久化保证数据不丢失

缺点:

  • 实现复杂度较高,尤其是Lua脚本部分
  • 依赖Redis
  • 可能需要定期同步数据到数据库

3.4 适用场景

  • 高并发抽奖活动
  • 对响应速度要求较高的场景
  • 大型营销活动
  • 需要实时库存控制的抽奖系统

四、基于权重概率的抽奖策略

4.1 基本原理

基于权重概率的抽奖策略是在普通抽奖基础上增加了更复杂的概率计算逻辑,可以根据用户特征、活动规则动态调整奖品中奖概率。

例如,可以根据用户等级、消费金额、活动参与度等因素调整抽奖权重,实现精细化控制。

4.2 实现方式

首先定义动态权重计算接口:

public interface WeightCalculator {
    // 根据用户信息计算权重调整因子
    double calculateWeightFactor(Long userId);
}

// VIP用户权重计算器
@Component
public class VipWeightCalculator implements WeightCalculator {
    
    @Autowired
    private UserService userService;
    
    @Override
    public double calculateWeightFactor(Long userId) {
        User user = userService.getUserById(userId);
        
        // 根据用户VIP等级调整权重
        switch (user.getVipLevel()) {
            case 0: return 1.0;  // 普通用户,不调整
            case 1: return 1.2;  // VIP1,提高20%中奖率
            case 2: return 1.5;  // VIP2,提高50%中奖率
            case 3: return 2.0;  // VIP3,提高100%中奖率
            default: return 1.0;
        }
    }
}

// 新用户权重计算器
@Component
public class NewUserWeightCalculator implements WeightCalculator {
    
    @Autowired
    private UserService userService;
    
    @Override
    public double calculateWeightFactor(Long userId) {
        User user = userService.getUserById(userId);
        
        // 注册时间少于7天的新用户提高中奖率
        if (ChronoUnit.DAYS.between(user.getRegistrationDate(), LocalDate.now()) <= 7) {
            return 1.5; // 提高50%中奖率
        }
        
        return 1.0;
    }
}

// 活跃度权重计算器
@Component
public class ActivityWeightCalculator implements WeightCalculator {
    
    @Autowired
    private UserActivityService userActivityService;
    
    @Override
    public double calculateWeightFactor(Long userId) {
        int activityScore = userActivityService.getActivityScore(userId);
        
        // 根据活跃度调整权重
        if (activityScore >= 100) {
            return 1.3; // 提高30%中奖率
        } else if (activityScore >= 50) {
            return 1.1; // 提高10%中奖率
        }
        
        return 1.0;
    }
}

然后实现基于权重的抽奖服务:

@Service
public class WeightedDrawService {
    
    @Autowired
    private PrizeRepository prizeRepository;
    
    @Autowired
    private DrawRecordRepository drawRecordRepository;
    
    @Autowired
    private List<WeightCalculator> weightCalculators;
    
    private final Random random = new Random();
    
    public Prize draw(Long userId) {
        // 获取所有可用奖品
        List<Prize> availablePrizes = prizeRepository.findByAvailableTrueAndStockGreaterThan(0);
        if (availablePrizes.isEmpty()) {
            throw new RuntimeException("No available prizes");
        }
        
        // 计算用户的总权重因子
        double weightFactor = calculateTotalWeightFactor(userId);
        
        // 创建带权重的奖品列表
        List<WeightedPrize> weightedPrizes = createWeightedPrizeList(availablePrizes, weightFactor);
        
        // 根据权重选择奖品
        Prize selectedPrize = selectPrizeByWeight(weightedPrizes);
        
        // 减少库存
        selectedPrize.setStock(selectedPrize.getStock() - 1);
        if (selectedPrize.getStock() <= 0) {
            selectedPrize.setAvailable(false);
        }
        prizeRepository.save(selectedPrize);
        
        // 记录抽奖
        recordDraw(userId, selectedPrize);
        
        return selectedPrize;
    }
    
    private double calculateTotalWeightFactor(Long userId) {
        // 从所有权重计算器获取权重并相乘
        return weightCalculators.stream()
                .mapToDouble(calculator -> calculator.calculateWeightFactor(userId))
                .reduce(1.0, (a, b) -> a * b);
    }
    
    private List<WeightedPrize> createWeightedPrizeList(List<Prize> prizes, double weightFactor) {
        List<WeightedPrize> weightedPrizes = new ArrayList<>();
        
        for (Prize prize : prizes) {
            WeightedPrize weightedPrize = new WeightedPrize();
            weightedPrize.setPrize(prize);
            
            // 调整中奖概率
            if (prize.getName().equals("谢谢参与")) {
                // 对于"谢谢参与",权重因子反向作用(权重越高,越不容易"谢谢参与")
                weightedPrize.setAdjustedProbability((int) (prize.getProbability() / weightFactor));
            } else {
                // 对于实际奖品,权重因子正向作用(权重越高,越容易中奖)
                weightedPrize.setAdjustedProbability((int) (prize.getProbability() * weightFactor));
            }
            
            weightedPrizes.add(weightedPrize);
        }
        
        return weightedPrizes;
    }
    
    private Prize selectPrizeByWeight(List<WeightedPrize> weightedPrizes) {
        // 计算总概率
        int totalProbability = weightedPrizes.stream()
                .mapToInt(WeightedPrize::getAdjustedProbability)
                .sum();
        
        // 生成随机数
        int randomNum = random.nextInt(totalProbability) + 1;
        
        // 根据概率选择奖品
        int probabilitySum = 0;
        for (WeightedPrize weightedPrize : weightedPrizes) {
            probabilitySum += weightedPrize.getAdjustedProbability();
            if (randomNum <= probabilitySum) {
                return weightedPrize.getPrize();
            }
        }
        
        // 默认返回最后一个奖品(通常是"谢谢参与")
        return weightedPrizes.get(weightedPrizes.size() - 1).getPrize();
    }
    
    private void recordDraw(Long userId, Prize prize) {
        DrawRecord record = new DrawRecord();
        record.setUserId(userId);
        record.setPrizeId(prize.getId());
        record.setDrawTime(LocalDateTime.now());
        drawRecordRepository.save(record);
    }
    
    // 带权重的奖品类
    @Data
    private static class WeightedPrize {
        private Prize prize;
        private int adjustedProbability;
    }
}

控制器实现:

@RestController
@RequestMapping("/api/draw")
public class WeightedDrawController {
    
    @Autowired
    private WeightedDrawService weightedDrawService;
    
    @GetMapping("/weighted")
    public Prize weightedDraw(@RequestParam Long userId) {
        return weightedDrawService.draw(userId);
    }
}

4.3 优缺点分析

优点:

  • 支持根据用户特征和业务规则动态调整中奖概率
  • 可以实现精细化营销和用户激励
  • 提高高价值用户的体验和留存
  • 灵活的权重计算机制,易于扩展

缺点:

  • 逻辑复杂,实现和维护成本高
  • 可能影响抽奖公平性,需要谨慎处理
  • 需要收集和分析更多用户数据

4.4 适用场景

  • 需要精细化运营的大型营销活动
  • 用户分层明显的应用
  • 希望提高特定用户群体体验的场景
  • 有用户激励和留存需求的平台

五、方案对比

6.1 性能对比

抽奖策略

响应速度

并发支持

资源消耗

扩展性

内存抽奖

极快

低

低

低

数据库抽奖

中等

中等

中等

高

Redis抽奖

快

高

中等

高

权重抽奖

中等

中等

高

高

6.2 功能对比

抽奖策略

奖品管理

抽奖记录

用户限制

防作弊

定制性

内存抽奖

基础

无

无

无

低

数据库抽奖

完善

完善

支持

基础

中等

Redis抽奖

完善

完善

支持

中等

高

权重抽奖

完善

完善

支持

高

极高

六、结语

在实际项目中,我们需要根据业务需求、用户规模、性能要求等因素,选择合适的抽奖策略或组合多种策略,以构建高效、可靠、安全的抽奖系统。

无论选择哪种抽奖策略,都需要关注系统的公平性、性能、可靠性和安全性,不断优化和改进。

使用springboot实现的抽奖完整源码 后台使用springboot来实现抽奖的算法逻辑完整版,可直接运行代码访问controller里的/award接口进行测试 立即下载

相关推荐

基于Java SpringBoot框架开发的抽奖游戏后台.zip

使用java开发的游戏项目源码,可用于毕业设计、课程设计、练手学习等

基于SpringBoot实现在线抽奖系统

在线抽奖系统

m0_46661757的博客 2957

java抽奖系统后台 springboot+mybatis redis队列处理高并发.rar

抽奖系统后台 springboot+mybatis redis队列处理高并发

Redis 项目实战 —— 抽奖大转盘

1. 项目介绍 这是一个基于Spring boot + Mybatis Plus + Redis 的简单案例。 主要是将活动内容、奖品信息、记录信息等缓存到Redis中,然后所有的抽奖过程全部从Redis中做数据的操作。 大致内容很简单,具体操作下面慢慢分析。 2. 项目演示 话不多说,首先上图看看项目效果,如果觉得还行的话咱们就来看看他具体是怎么实现的。 3. 表结构 该项目包含以下四张表,分别是活动表、奖项表、奖品表以及中奖记录表。具体的SQL会在文末给出。 4. 项目搭建 咱们首先先搭建一个标准

Java是世界上最好的语言 8411

FactoryTool量产神器实战:5分钟搞定多块RK3568板卡并行烧录

本文详细介绍了使用瑞芯微FactoryTool对多块RK3568板卡进行高效并行烧录的实战指南。文章从硬件连接、驱动配置、软件操作到排错技巧,提供了一套完整的量产解决方案,重点阐述了如何利用该工具在5分钟内完成多设备固件烧录,并确保eMMC存储的写入稳定性与效率,大幅提升生产线吞吐量。

b0c1d2的博客 995

如何根据芯片手册时序图编写驱动程序

如何根据芯片手册时序图编写驱动程序 对于电子开发者来说,刚刚拿到一个芯片,常用的芯片可以参考网上的例程来做深入了解,对于一个不常用的芯片来说,Datasheet几乎是使用芯片的唯一的资料,所以根据Datasheet时序图写出对应的驱动程序就尤为重要。 本文根据一个简单的例子来阐述根据时序图来编写对应的程序过程。旨在讲解对于初学者应该怎么利用芯片的时序图编写符合要求的底层驱动程序(老鸟请跳过)。 下载芯片的Datasheet,(个人常用http://www.21icsearch.com/)如..

weixin_36447711的博客 1万+

springboot企业级抽奖项目-系统设计

数据主体是活动(game),内置活动策略(game_rules),通过关联表(game_product)和奖品(product)联动,和用户(user)表一起查中奖记录。

cangshanjiang的博客 1361

中国IP发展之面面观

谢学军/邱善勤2006-1-25 9:29:28电子经理世界       IP远没有我们当初想象的那么简单   当SoC设计方法学刚刚传到国内的时候,学界为之欢呼雀跃,由于IP/SoC设计技术的使用,可以将发达国家用几年甚至十几年积累起来的设计技术直接为我所用,使中国的集成电路跳过漫长的积累阶段,迅速站到较高的起点上。因此在当时看来,IP/SoC设计技术是我国提升设计水平、发展

klxdmm305的专栏 1189

SpringBoot实现抽奖大转盘

1、项目介绍 这是一个基于Spring boot + Mybatis Plus + Redis 的简单案例。主要是将活动内容、奖品信息、记录信息等缓存到Redis中,然后所有的抽奖过程全部...

Java团长的博客 1510

在VS2019里把JSBSim飞行模型集成到你的C++项目里(附完整配置流程和常见错误解决)

本文详细介绍了如何在Visual Studio 2019中将JSBSim飞行模型集成到C++项目中,包括环境准备、源码编译、项目配置和常见错误解决方案。通过实战技巧和优化建议,帮助开发者高效实现高精度飞行仿真功能,提升开发效率。

weixin_42620202的博客 415

Ubuntu 20.04 环境下Autoware.universe 与 Carla 0.9.13 联合仿真

安装内容: ROS Galactic Autoware.universe based on ROS Galactic Carla 0.9.13 UnrealEngine 4.26 Openplanner (additional files: op-bridge/op-agent/scenariorunner/map data)

mhl1107的博客 1801

SpringBoot 项目——抽奖系统

编程语言:后端:Java 17,前端 JavaScript;后端框架:SpringBoot 3;数据库:Mysql;持久层框架:Mybatis,Mybatis-Plus;缓存:Redis;消息队列:RabbitMQ;日志服务:Slf4j;安全校验:JWT;加密解密:hutool;开发工具:lombok;其他:邮箱服务,阿里云短信服务

2201_75456895的博客 2426

STM32家电安全开发实战:手把手教你用X-CUBE-CLASSB通过IEC60730 Class B认证

本文详细解析了如何使用STM32的X-CUBE-CLASSB软件包通过IEC60730 Class B认证,涵盖认证核心要求、软件包架构、工程集成配置及调试技巧。针对家电安全开发,提供了从单元测试到压力测试的全流程方案,帮助开发者快速实现符合国际安全标准的嵌入式控制系统。

pink的博客 708

抽奖活动mysql表设计_抽奖项目的系统设计方案

我的是一个抽奖的工程实践项目,一个项目不管大小,设计需先行,所以本文是着重于大的架构风格,从各种视图来描述改项目,最后从具体的工程结构的实现和技术采用作为对架构的印证。一、软件架构风格它是对软件整体从最大的颗粒度上描绘整个的结构与特征,它类似于建筑的框架,是钢构的还是水泥浇灌的,这影响整个工程的质量与实现。本抽奖系统采用的是数据仓库风格。在仓库风格中,有两种不同的构件:中央数据结构说明当前状态,独...

weixin_32635501的博客 2282

Android日志实战——车机日志获取(十五)

这个项目中的 Log 管理系统,其实只是将系统原生 Log 进行输出并导出,并没有太复杂的操作。还有一种 Log 管理系统需要对 Android 原生 Log 系统进行重写,例如我们使用 Log.d(tag, msg) 打印 Log,需要我们根据 tag 信息将不同模块的 Log 数据写入不同的本地文件下,这样可以方便不同模块查看自己的 Log,追踪异常问题。

小旭的专栏 3781

华为OD机试真题 新系统 2026-04-22 Python&JS 实现【小学生班长选举增强版】

9 月份开学第一天,小学某班级进行班长选举活动,班级共有 N 个学生,每个学生最多可投 3 票(对同一个人只能投一票),也可以弃权不投票,大家投票时写上对应学生的名字。 假设学生不存在重名。考虑到部分少数民族名字带分隔,且整体较长,同学在投票时为了方便,允许同学写全称,也可以只写其中的部分连续段。 例如班级里只有 2 个少数民族名称带点的同学:

MISAYAONE的博客 320

《大营销平台系统》前端实战:九宫格抽奖页面设计与活动接口对接,实现抽奖N次解锁

本篇技术指南聚焦于大营销平台项目中前端 Web 端的「第 4 节:抽奖活动页面设计和对接」,讲解如何以 React 技术栈开发九宫格抽奖页面,并对接到大营销第 2 阶段的抽奖活动接口,落地「抽奖 N 次解锁奖品」的页面展示逻辑。读完本文,你将掌握活动视角下的奖品列表接口改造思路、前端解锁状态渲染方案,以及装配抽奖(armory)与活动预热接口的完整调用链路。 ## 一、本章诉求与核心目标 大营

gitblog_00568的博客 420

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

【Java项目-企悦抽】16-抽奖模块01-获取活动完整信息接口实现

本期实现抽奖模块首个接口——获取活动详细信息。控制层完成DTO到Result转换,服务层优先查Redis,无则查MySQL整合活动、奖品、人员数据,并补充幂等性知识。

弹简特的博客,步履不停,持续学习,多尝试,多复盘,多沉淀。 565

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

抽奖系统(5)

本文介绍了活动创建模块的后端实现过程,包括需求分析、数据库设计、代码实现和测试要点。系统采用多表关联设计,包含活动表、活动奖品关联表和活动人员关联表,通过事务注解保证数据一致性。后端实现包括参数校验、数据入库、Redis缓存等关键步骤,采用DTO封装完整活动信息。前端实现涉及奖品和人员列表获取、交互处理等。此外还介绍了活动列表查询功能,支持分页展示和状态校验。整个实现过程注重异常处理、性能优化和数据完整性,为后续抽奖功能提供基础支持。

2301_80293365的博客 1075

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

SpringBoot实现公正有趣好玩的年会抽奖系统

本文介绍了一个基于SpringBoot框架开发的年会抽奖系统设计方案。该系统旨在解决传统抽奖方式存在的公平性不足和互动性差的问题,通过技术手段确保抽奖过程的公正性和趣味性。系统采用SpringBoot 2.7.x作为后端框架,搭配MySQL和Redis数据库,前端使用Thymeleaf+Bootstrap+jQuery技术栈。核心功能包括员工管理、奖品设置、抽奖活动管理和中奖记录查询,采用加密随机算法保证抽奖公平性,并支持WebSocket实现实时互动。数据库设计包含员工表、奖品表、中奖记录表和抽奖活动表等

私聊前往站内信:https://i.youkuaiyun.com/#/msg/chat/weixin_44976692 539

抽奖系统lottery-system

定义好创建照片的方法因为传的参数是照片类的格式,所以使用的是multipart/form-data 类型请求,使用@RequestPart注解用来区分文件和对象。调用PrizeService中的insertPrize方法。

blamep的博客 988

使用SpringBoot实现策略模式

使用SpringBoot实现策略模式

m0_59996263的博客 648

【Java项目-企悦抽】17-抽奖模块02-抽奖接口实现

本期实现抽奖接口,采用RabbitMQ异步处理提升响应速度。核心包括:校验抽奖请求、责任链+策略模式扭转活动奖品人员状态、保存中奖记录并缓存Redis、线程池并发邮箱通知、异常回滚保证事务一致性。

弹简特的博客,步履不停,持续学习,多尝试,多复盘,多沉淀。 916

springboot企业级抽奖项目-整体展示

star截图+q:3353441618可以领取资料。

cangshanjiang的博客 503
上一篇: SpringBoot 3.0使用自定义注解+Interceptor+Redis实现幂等
下一篇: SpringBoot的5种签到打卡实现方案
程序员职业指南
博客等级 码龄4年 2140粉丝 960原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值