Comment implémenter le cache distribué Redis et la vente flash

Puisqu'il s'agit d'une commande d'enregistrement, le fichier AOF sera beaucoup plus volumineux que le fichier RDB. Bien que AOF enregistre plusieurs opérations d'écriture sur la même clé, seule la dernière opération d'écriture parmi elles est significative. Vous pouvez utiliser la commande bgrewriteaof pour compléter la fonction de réécriture de fichiers AOF avec le nombre minimum de commandes.

set id 1
set name nezha
set id 2

bgrewriteaof

mset name nezha id 2

Redis réécrira également automatiquement le fichier AOF lorsque le seuil est déclenché. Le seuil peut également être configuré dans redis.conf :

# Le pourcentage de croissance du fichier AOF par rapport au dernier fichier déclenchera une réécriture auto-aof-rewrite-percentage 100# La taille minimale du fichier AOF déclenchera une réécriture automatique. aof. -rewrite-min-size 64mb

RDB et AOF ont chacun leurs propres avantages et inconvénients Si les exigences en matière de sécurité des données sont élevées, ils sont souvent utilisés en combinaison dans le développement réel.

4. Optimisation Redis Processus de vente flash

1. Étapes de la vente flash :

1. Rechercher des coupons

2. Vérifier l'inventaire des produits de la vente flash

3. Vérifier les commandes ; Réduire les stocks ;

4. Créer une commande ;

6. 2. Étapes de vente flash d'optimisation Redis :

Si la vente flash réussit, l'identifiant du coupon, l'identifiant de l'utilisateur et l'identifiant du produit sont encapsulés dans la file d'attente de blocage ;

1. Activez les tâches asynchrones, lisez en continu les informations de la file d'attente de blocage et implémentez la commande asynchrone

3. Script Lua pour les ventes flash
4. 4. Appelez le script Lua pour les ventes flash

   public Result seckillVoucher(Long voucherId) {
        Long userId = UserHolder.getUser().getId();
        long orderId = redisIdWorker.nextId("order");
        // 1.执行lua脚本
        Long result = stringRedisTemplate.execute(
                SECKILL_SCRIPT,
                Collections.emptyList(),
                voucherId.toString(), userId.toString(), String.valueOf(orderId)
        );
        int r = result.intValue();
        // 2.判断结果是否为0
        if (r != 0) {
            // 2.1.不为0 ，代表没有购买资格
            return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
        }
        // 3.返回订单id
        return Result.ok(orderId);
    }

   Copier après la connexion
   . 5. Grâce au pool de threads, l'opération bloque la file d'attente

// 线程池
private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();

/**
* 在类初始化完成后执行
*/
@PostConstruct
private void init() {
    SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
}

// 阻塞队列
private BlockingQueue<VoucherOrder> orderTasks = new ArrayBlockingQueue<>(1024 * 1024);
private class OrderHandler implements Runnable{

    @Override
    public void run() {
        while (true){
            try {
                doSomething();
            } catch (Exception e) {
                log.error("处理订单异常", e);
            }
        }
    }
}

Copier après la connexion

Connexion basée sur une session

Connexion à une session partagée basée sur Redis

public class RefreshTokenInterceptor implements HandlerInterceptor {

    private StringRedisTemplate stringRedisTemplate;

    public RefreshTokenInterceptor(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1、获取请求头中的token
        String token = request.getHeader("authorization");
        if (StrUtil.isBlank(token)) {
            return true;
        }
        // 2、基于TOKEN获取redis中的用户
        String key  = LOGIN_USER_KEY + token;
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(key);
        // 3、判断用户是否存在
        if (userMap.isEmpty()) {
            return true;
        }
        // 5、将查询到的hash数据转为UserDTO
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
        // 6、存在，保存用户信息到 ThreadLocal
        UserHolder.saveUser(userDTO);
        // 7、刷新token有效期
        stringRedisTemplate.expire(key, LOGIN_USER_TTL, TimeUnit.MINUTES);
        // 8、放行
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 移除用户
        UserHolder.removeUser();
    }
}