电商后台管理系统架构设计与实战

/**
 * SKU服务 - 基于属性组合动态生成SKU
 */
@Service
public class SkuServiceImpl implements SkuService {
    
    @Autowired
    private SkuMapper skuMapper;
    
    @Autowired
    private StringRedisTemplate redisTemplate;
    
    private final Cache localCache = Caffeine.newBuilder()
        .maximumSize(10000)
        .expireAfterWrite(10, TimeUnit.MINUTES)
        .build();
    
    /**
     * 根据属性组合获取SKU，支持懒加载
     */
    @Override
    public SkuDTO getSkuByAttributes(Long spuId, Map attributes) {
        String cacheKey = buildSkuCacheKey(spuId, attributes);
        
        // L1本地缓存
        SkuDTO sku = localCache.getIfPresent(cacheKey);
        if (sku != null) {
            return sku;
        }
        
        // L2 Redis缓存
        String cached = redisTemplate.opsForValue().get(cacheKey);
        if (cached != null) {
            sku = JSON.parseObject(cached, SkuDTO.class);
            localCache.put(cacheKey, sku);
            return sku;
        }
        
        // 缓存穿透保护 - 互斥锁
        String lockKey = "lock:sku:" + cacheKey;
        Boolean locked = redisTemplate.opsForValue()
            .setIfAbsent(lockKey, "1", 10, TimeUnit.SECONDS);
        
        if (Boolean.TRUE.equals(locked)) {
            try {
                // 双重检查
                cached = redisTemplate.opsForValue().get(cacheKey);
                if (cached != null) {
                    return JSON.parseObject(cached, SkuDTO.class);
                }
                
                // 动态生成或查询SKU
                sku = generateOrQuerySku(spuId, attributes);
                if (sku != null) {
                    redisTemplate.opsForValue().set(cacheKey, 
                        JSON.toJSONString(sku), 30, TimeUnit.MINUTES);
                    localCache.put(cacheKey, sku);
                } else {
                    // 空值缓存，防止穿透
                    redisTemplate.opsForValue().set(cacheKey, "null", 
                        5, TimeUnit.MINUTES);
                }
            } finally {
                redisTemplate.delete(lockKey);
            }
        }
        
        return sku;
    }
}

-- 库存扣减Lua脚本
-- KEYS[1]: 库存key
-- KEYS[2]: 用户已购key(防重复购买)
-- ARGV[1]: 扣减数量
-- ARGV[2]: 用户ID
-- ARGV[3]: 库存预占超时时间(秒)

local stock = tonumber(redis.call('get', KEYS[1]) or 0)
local userBought = tonumber(redis.call('get', KEYS[2]) or 0)
local deductNum = tonumber(ARGV[1])

-- 检查库存是否充足
if stock < deductNum then
    return -1  -- 库存不足
end

-- 检查用户是否已购买(限购逻辑)
if userBought > 0 then
    return -2  -- 已购买
end

-- 扣减库存并记录用户购买
redis.call('decrby', KEYS[1], deductNum)
redis.call('setex', KEYS[2], ARGV[3], deductNum)

-- 发送库存变更消息到Stream(供下游消费)
redis.call('xadd', 'stock:change:stream', '*', 
    'skuId', KEYS[1], 
    'change', -deductNum,
    'userId', ARGV[2],
    'type', 'deduct')

return 1  -- 扣减成功

/**
 * 订单状态机配置
 * 定义状态流转规则和业务校验
 */
@Configuration
@EnableStateMachine
public class OrderStateMachineConfig extends StateMachineConfigurerAdapter<OrderStatus, OrderEvent> {
    
    @Override
    public void configure(StateMachineStateConfigurer<OrderStatus, OrderEvent> states) 
            throws Exception {
        states.withStates()
            .initial(OrderStatus.CREATED)
            .states(EnumSet.allOf(OrderStatus.class))
            .end(OrderStatus.COMPLETED)
            .end(OrderStatus.CANCELLED)
            .end(OrderStatus.REFUNDED);
    }
    
    @Override
    public void configure(StateMachineTransitionConfigurer<OrderStatus, OrderEvent> transitions) 
            throws Exception {
        transitions
            // 创建订单 -> 待支付
            .withExternal()
                .source(OrderStatus.CREATED)
                .target(OrderStatus.PENDING_PAY)
                .event(OrderEvent.CREATE)
                .guard(orderCreateGuard())
                .action(orderCreateAction())
            .and()
            // 支付成功 -> 待发货
            .withExternal()
                .source(OrderStatus.PENDING_PAY)
                .target(OrderStatus.PENDING_SHIP)
                .event(OrderEvent.PAY_SUCCESS)
                .guard(paymentGuard())
                .action(paymentSuccessAction())
            .and()
            // 发货 -> 待收货
            .withExternal()
                .source(OrderStatus.PENDING_SHIP)
                .target(OrderStatus.PENDING_RECEIVE)
                .event(OrderEvent.SHIP)
                .action(shipAction())
            .and()
            // 支付超时 -> 取消
            .withExternal()
                .source(OrderStatus.PENDING_PAY)
                .target(OrderStatus.CANCELLED)
                .event(OrderEvent.PAY_TIMEOUT)
                .action(cancelAction());
    }
    
    /**
     * 订单创建动作 - 扣减库存、发送延迟消息
     */
    @Bean
    public Action<OrderStatus, OrderEvent> orderCreateAction() {
        return context -> {
            Order order = context.getMessage().getHeaders().get("order", Order.class);
            
            // 扣减库存
            inventoryService.deduct(order);
            
            // 发送支付超时延迟消息(30分钟)
            rabbitTemplate.convertAndSend("order.delay.exchange", 
                "order.pay.timeout", 
                order.getOrderNo(), 
                msg -> {
                    msg.getMessageProperties().setDelay(30 * 60 * 1000);
                    return msg;
                });
            
            // 发布订单创建事件
            eventPublisher.publish(new OrderCreatedEvent(order));
        };
    }
}

/**
 * 数据权限SQL拦截器
 * 基于MyBatis-Plus拦截器自动注入数据范围条件
 */
@Component
@Intercepts({
    @Signature(type = Executor.class, method = "query", 
        args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
})
public class DataScopeInterceptor implements Interceptor {
    
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        Object[] args = invocation.getArgs();
        MappedStatement ms = (MappedStatement) args[0];
        Object parameter = args[1];
        
        // 获取当前用户数据权限
        DataScope dataScope = SecurityUtils.getCurrentUserDataScope();
        if (dataScope == null || dataScope.getScopeType() == DataScopeType.ALL) {
            return invocation.proceed();
        }
        
        // 解析并修改SQL
        BoundSql boundSql = ms.getBoundSql(parameter);
        String originalSql = boundSql.getSql();
        
        // 构建数据权限过滤SQL
        String dataScopeSql = buildDataScopeSql(originalSql, dataScope);
        
        // 重建BoundSql
        BoundSql newBoundSql = new BoundSql(ms.getConfiguration(), dataScopeSql,
            boundSql.getParameterMappings(), boundSql.getParameterObject());
        
        // 复制参数
        boundSql.getAdditionalParameters().forEach(newBoundSql::setAdditionalParameter);
        
        // 执行修改后的查询
        return executeQuery(invocation, ms, newBoundSql);
    }
    
    private String buildDataScopeSql(String originalSql, DataScope dataScope) {
        StringBuilder scopeCondition = new StringBuilder();
        
        switch (dataScope.getScopeType()) {
            case DEPT_ONLY:
                scopeCondition.append("dept_id = ").append(dataScope.getDeptId());
                break;
            case DEPT_AND_CHILD:
                scopeCondition.append("dept_id IN (")
                    .append(StringUtils.join(dataScope.getChildDeptIds(), ","))
                    .append(")");
                break;
            case SELF_ONLY:
                scopeCondition.append("create_by = ").append(dataScope.getUserId());
                break;
            case CUSTOM:
                scopeCondition.append(dataScope.getCustomSql());
                break;
            default:
                return originalSql;
        }
        
        // 使用JSqlParser解析并修改SQL
        try {
            Statement statement = CCJSqlParserUtil.parse(originalSql);
            Select select = (Select) statement;
            PlainSelect plainSelect = (PlainSelect) select.getSelectBody();
            
            Expression where = plainSelect.getWhere();
            AndExpression dataScopeWhere = new AndExpression(where, 
                CCJSqlParserUtil.parseCondExpression(scopeCondition.toString()));
            plainSelect.setWhere(dataScopeWhere);
            
            return select.toString();
        } catch (JSQLParserException e) {
            log.error("解析SQL失败", e);
            return originalSql;
        }
    }
}