优惠券省钱APP技术架构：优惠策略引擎、券核销与用户行为分析

大家好，我是高佣返利省赚客APP研发者阿宝！

在“省钱”成为刚需的今天，优惠券APP的核心竞争力不仅在于聚合全网海量优惠券，更在于能否毫秒级计算出“最优凑单方案”，并在高并发下保证券核销的零误差。同时，通过对用户行为的深度分析，实现“千人千面”的精准推荐。省赚客APP的技术架构正是围绕这三大核心支柱构建：基于规则引擎的动态优惠策略、分布式环境下的幂等核销机制，以及实时流计算驱动的用户画像体系。

动态优惠策略引擎：规则链与最优解算法

面对“满200减30”、“第二件半价”、“限时秒杀”、“会员专享95折”等错综复杂的叠加规则，硬编码早已失效。我们引入了轻量级规则引擎，将优惠策略抽象为可配置的规则链（Rule Chain）。系统通过责任链模式依次执行资格校验、互斥判断、金额计算，并利用回溯算法在多重优惠组合中寻找全局最优解，确保用户真正“省到底”。

package juwatech.cn.strategy.engine;

import juwatech.cn.model.CartContext;
import juwatech.cn.model.CouponRule;
import juwatech.cn.strategy.RuleExecutor;
import juwatech.cn.result.OptimizationResult;
import java.util.List;
import java.util.ArrayList;
import java.math.BigDecimal;

public class DiscountStrategyEngine {

    private final List<RuleExecutor> ruleChain;

    public DiscountStrategyEngine(List<RuleExecutor> ruleChain) {
        this.ruleChain = ruleChain;
    }

    /**
     * 计算最优优惠组合
     * @param context 购物车上下文（商品列表、用户等级、可用券池）
     * @return 最优减免方案
     */
    public OptimizationResult calculateBestDeal(CartContext context) {
        BigDecimal maxDiscount = BigDecimal.ZERO;
        List<CouponRule> bestCombination = new ArrayList<>();

        // 1. 预过滤：剔除不满足门槛的优惠券
        List<CouponRule> validRules = filterValidRules(context);

        // 2. 组合爆炸处理：针对少量高价值券进行回溯搜索
        // 实际生产中会结合剪枝算法优化性能
        List<List<CouponRule>> combinations = generateCombinations(validRules, context.getMaxStackableCount());

        for (List<CouponRule> combo : combinations) {
            BigDecimal currentDiscount = BigDecimal.ZERO;
            boolean applicable = true;

            // 3. 执行规则链校验（互斥、品类限制、时间窗口）
            for (RuleExecutor executor : ruleChain) {
                if (!executor.validate(combo, context)) {
                    applicable = false;
                    break;
                }
                currentDiscount = executor.calculate(combo, context, currentDiscount);
            }

            if (applicable && currentDiscount.compareTo(maxDiscount) > 0) {
                maxDiscount = currentDiscount;
                bestCombination = combo;
            }
        }

        return new OptimizationResult(maxDiscount, bestCombination);
    }

    private List<CouponRule> filterValidRules(CartContext context) {
        // 调用 juwatech.cn.service.CouponService 进行初步筛选
        return juwatech.cn.service.CouponService.getAvailableRules(context);
    }

    private List<List<CouponRule>> generateCombinations(List<CouponRule> rules, int limit) {
        // 组合生成逻辑省略
        return new ArrayList<>();
    }
}

高并发券核销：分布式锁与幂等性设计

领券和核销是典型的“写多读少”且对数据一致性要求极高的场景。尤其在整点抢券时，瞬间QPS可达数万。为防止超发（库存扣减为负）和重复核销，我们采用Redis Lua脚本实现原子性库存扣减，并结合数据库唯一索引与分布式锁构建双重保险。所有核销请求必须携带全局唯一的bizId，确保接口调用的幂等性。

package juwatech.cn.coupon核销.core;

import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import juwatech.cn.entity.CouponStock;
import juwatech.cn.repository.CouponRepository;
import juwatech.cn.exception.StockNotEnoughException;
import juwatech.cn.exception.DuplicateUseException;
import lombok.extern.slf4j.Slf4j;
import java.util.Collections;

@Slf4j
public class CouponVerificationService {

    private final StringRedisTemplate redisTemplate;
    private final CouponRepository couponRepository;
    private final DefaultRedisScript<Long> deductScript;

    public CouponVerificationService(StringRedisTemplate redisTemplate, CouponRepository couponRepository) {
        this.redisTemplate = redisTemplate;
        this.couponRepository = couponRepository;
        
        // 加载Lua脚本：检查库存并扣减，返回剩余库存或-1
        String script = 
            "local key = KEYS[1] " +
            "local stock = tonumber(redis.call('get', key)) " +
            "if not stock or stock <= 0 then return -1 end " +
            "redis.call('decr', key) " +
            "return stock - 1";
        this.deductScript = new DefaultRedisScript<>(script, Long.class);
    }

    /**
     * 执行券核销
     */
    public void verifyCoupon(String userId, String couponId, String bizId) {
        String stockKey = "stock:coupon:" + couponId;
        String lockKey = "lock:verify:" + bizId;

        // 1. 幂等性检查：利用数据库唯一索引 (biz_id) 防止重复核销
        if (couponRepository.existsByBizId(bizId)) {
            throw new DuplicateUseException("Coupon already used for this order");
        }

        // 2. Redis原子扣减库存
        Long remaining = redisTemplate.execute(
            deductScript, 
            Collections.singletonList(stockKey)
        );

        if (remaining == null || remaining < 0) {
            throw new StockNotEnoughException("Coupon sold out");
        }

        try {
            // 3. 异步落库记录（最终一致性）
            // 此时库存已在Redis扣除，DB记录稍后同步，即使DB失败也可通过补偿任务修复
            juwatech.cn.mq.CouponVerifyProducer.sendVerifyMessage(userId, couponId, bizId);
            
            log.info("Coupon verified successfully: {}, remaining: {}", couponId, remaining);
        } catch (Exception e) {
            log.error("Failed to record verification, triggering compensation", e);
            // 触发回滚或补偿逻辑
            redisTemplate.opsForValue().increment(stockKey);
            throw e;
        }
    }
}

实时用户行为分析与个性化推荐

为了提升转化率，我们需要实时捕捉用户的浏览、搜索、加购行为，构建动态用户画像。基于Flink的实时计算平台，我们将用户行为日志流与商品特征流进行Join，实时计算用户的“价格敏感度”、“品类偏好”及“活跃时段”，并将结果写入Redis供推荐引擎毫秒级读取，实现“刚搜过奶粉，首页即推尿裤”的精准体验。

package juwatech.cn.analytics.flink;

import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;
import juwatech.cn.model.UserBehaviorEvent;
import juwatech.cn.model.UserProfile;
import juwatech.cn.state.UserProfileState;
import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;

public class UserBehaviorAnalyzer extends KeyedProcessFunction<String, UserBehaviorEvent, UserProfile> {

    private transient ValueState<UserProfile> profileState;

    @Override
    public void open(org.apache.flink.configuration.Configuration parameters) {
        ValueStateDescriptor<UserProfile> descriptor = 
            new ValueStateDescriptor<>("userProfile", UserProfile.class);
        profileState = getRuntimeContext().getState(descriptor);
    }

    @Override
    public void processElement(UserBehaviorEvent event, Context ctx, Collector<UserProfile> out) throws Exception {
        UserProfile profile = profileState.value();
        if (profile == null) {
            profile = new UserProfile(event.getUserId());
        }

        // 实时更新用户特征
        updateCategoryPreference(profile, event.getCategoryId());
        updatePriceSensitivity(profile, event.getPrice());
        updateLastActiveTime(profile, event.getTimestamp());

        // 保存状态
        profileState.update(profile);

        // 输出更新后的画像到下游（如Redis Sink）
        out.collect(profile);
        
        // 注册定时器：若用户30分钟无操作，标记为“潜在流失”
        long timer = event.getTimestamp() + 1800000;
        ctx.timerService().registerEventTimeTimer(timer);
    }

    private void updateCategoryPreference(UserProfile profile, String categoryId) {
        // 增加该品类权重逻辑
        profile.incrementCategoryScore(categoryId, 1.0);
    }

    private void updatePriceSensitivity(UserProfile profile, double price) {
        // 更新平均客单价及价格区间偏好
        profile.updatePriceStats(price);
    }
    
    @Override
    public void onTimer(long timestamp, OnTimerContext ctx, Collector<UserProfile> out) {
        // 处理超时逻辑，如发送召回通知
        UserProfile profile = profileState.value();
        if (profile != null) {
            profile.setRiskLevel("POTENTIAL_CHURN");
            out.collect(profile);
        }
    }
}

数据闭环与智能决策

上述三个模块并非孤立存在。优惠策略的执行结果会反哺给用户行为分析，优化后续的推荐模型；用户的行为反馈又会指导运营调整优惠券的发放策略。省赚客APP通过这套闭环架构，实现了从“人找券”到“券找人”的智能化跃迁，在保障系统高可用的同时，最大化了用户的省钱体验和平台的商业价值。

本文著作权归 省赚客app 研发团队，转载请注明出处！