领导问我：为什么一个点赞功能你做了五天？

CREATE TABLE `like_records` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `user_id` int(11) DEFAULT NULL,
  `target_id` int(11) DEFAULT NULL,
  `type` int(4) DEFAULT NULL,
  `created_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP,
  `updated_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP,
  `value` int(4) DEFAULT '0',
  PRIMARY KEY (`id`),
  KEY `like_records_target_id_IDX` (`target_id`,`user_id`,`type`) USING BTREE,
  KEY `like_records_user_id_IDX` (`user_id`,`target_id`,`type`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4;

import { Injectable } from '@nestjs/common';
import { InjectEntityManager } from '@nestjs/typeorm';
import { EntityManager } from 'typeorm';
import { Order } from './order.entity';
import { Product } from './product.entity';

@Injectable()
export class OrderService {
  constructor(
    @InjectEntityManager()
    private readonly entityManager: EntityManager,
  ) {}

  async createOrderAndDeductStock(productId: number, quantity: number): Promise<Order> {
    return await this.entityManager.transaction(async transactionalEntityManager => {
      // 查找产品并检查库存是否充足
      const product = await transactionalEntityManager.findOne(Product, productId);
      if (!product || product.stock < quantity) {
        throw new Error('Product not found or insufficient stock');
      }

      // 创建订单
      const order = new Order();
      order.productId = productId;
      order.quantity = quantity;
      await transactionalEntityManager.save(order);

      // 扣除库存
      product.stock -= quantity;
      await transactionalEntityManager.save(product);

      return order;
    });
  }
}

  async getLock(key: string) {
    const res = await this.redis.setnx(key, 'lock');
    if (res) {
        // 10秒锁过期
        await this.redis.expire(key, 10);
    }
    return res;
  }

  async unLock(key: string) {
    return this.del(key);
  }

  const pipeline = this.redisService.multi();
  const setKey = this.getSetKey(targetId, type);
  if (value === ELike.LIKE) {
    pipeline.sadd(setKey, userId);
  } else {
    pipeline.srem(setKey, userId);
  }
  pipeline.expire(setKey, this.ttl);
  await pipeline.exec();

  async toggleLike(params: {
    userId: number;
    targetId: number;
    type: ELikeType;
    value: ELike;
  }) {
    const { userId, targetId, type, value } = params;
    const LOCK_KEY = `${userId}::${targetId}::${type}::toggleLikeLock`;
    const canGetLock = await this.redisService.getLock(LOCK_KEY);
    if (!canGetLock) {
      console.log('获取锁失败');
      await wait();
      return this.toggleLike(params);
    }
    const record = await this.likeRepository.findOne({
      where: { userId, targetId, type },
    });
    if (record && record.value === value) {
      await this.redisService.unLock(LOCK_KEY);
      throw Error('不可重复操作');
    }

    await this.entityManager.transaction(async (transactionalEntityManager) => {
      if (!record) {
        const likeEntity = new LikeEntity();
        likeEntity.targetId = targetId;
        likeEntity.type = type;
        likeEntity.userId = userId;
        likeEntity.value = value;
        await transactionalEntityManager.save(likeEntity);
      } else {
        const id = record.id;
        await transactionalEntityManager.update(LikeEntity, { id }, { value });
      }
      const isSuccess = await this.tryToFreshCache(params);

      if (!isSuccess) {
        await this.redisService.unLock(LOCK_KEY);
        throw Error('操作失败');
      }
    });
    await this.redisService.unLock(LOCK_KEY);
    return true;
  }
  
private async tryToFreshCache(
    params: {
      userId: number;
      targetId: number;
      type: ELikeType;
      value: ELike;
    },
    retry = 3,
  ) {
    if (retry === 0) {
      return false;
    }
    const { targetId, type, value, userId } = params;
    try {
      const pipeline = this.redisService.multi();
      const setKey = this.getSetKey(targetId, type);
      if (value === ELike.LIKE) {
        pipeline.sadd(setKey, userId);
      } else {
        pipeline.srem(setKey, userId);
      }
      pipeline.expire(setKey, this.ttl);
      await pipeline.exec();
      return true;
    } catch (error) {
      console.log('tryToFreshCache error', error);
      await wait();
      return this.tryToFreshCache(params, retry - 1);
    }
  }

  async getLikes(params: {
    targetId: number;
    type: ELikeType;
    userId: number;
  }) {
    const { targetId, type, userId } = params;
    const setKey = this.getSetKey(targetId, type);
    const cacheExsit = await this.redisService.exist(setKey);
    if (!cacheExsit) {
      await this.getLikeFromDbAndSetCache(params);
    }
    const count = await this.redisService.getSetLength(setKey);
    const isLike = await this.redisService.isMemberOfSet(setKey, userId);
    return { count, isLike };
  }

  private async getLikeFromDbAndSetCache(params: {
    targetId: number;
    type: ELikeType;
    userId: number;
  }) {
    const { targetId, type, userId } = params;
    const LOCK_KEY = `${targetId}::${type}::getLikesLock`;
    const canGetLock = await this.redisService.getLock(LOCK_KEY);
    if (!canGetLock) {
      console.log('获取锁失败');
      await wait();
      return this.getLikeFromDbAndSetCache(params);
    }
    const setKey = this.getSetKey(targetId, type);
    const cacheExsit = await this.redisService.exist(setKey);
    if (cacheExsit) {
      await this.redisService.unLock(LOCK_KEY);
      return true;
    }
    const data = await this.likeRepository.find({
      where: {
        targetId,
        userId,
        type,
        value: ELike.LIKE,
      },
      select: ['userId'],
    });
    if (data.length !== 0) {
      await this.redisService.setAdd(
        setKey,
        data.map((item) => item.userId),
        this.ttl,
      );
    }
    await this.redisService.unLock(LOCK_KEY);
    return true;
  }

useEffect(() => {
    if (!article.list) {
      return;
    }
    const shouldGetLikeIds = article.list
      .filter((item: any) => !item.likeInfo)
      .map((item: any) => item.id);
    if (shouldGetLikeIds.length === 0) {
      return;
    }
    console.log("shouldGetLikeIds", shouldGetLikeIds);
    getLikes({
      targetIds: shouldGetLikeIds,
      type: 1,
    }).then((res) => {
      const map = res.data;
      const newList = [...article.list];
      for (let i = 0; i < newList.length; i++) {
        if (!newList[i].likeInfo && map[newList[i].id]) {
          newList[i].likeInfo = map[newList[i].id];
        }
      }
      const newArticle = { ...article };
      newArticle.list = newList;
      setArticle(newArticle);
    });
  }, [article]);

   <Space
    onClick={(e) => {
      e.stopPropagation();
      if (lockMap.current?.[item.id]) {
        return;
      }
      lockMap.current[item.id] = true;
      const oldValue = item.likeInfo.isLike;
      const newValue = !oldValue;
      const updateValue = (value: any) => {
        const newArticle = { ...article };
        const newList = [...newArticle.list];
        const current = newList.find(
          (_) => _.id === item.id
        );
        current.likeInfo.isLike = value;
        if (value) {
          current.likeInfo.count++;
        } else {
          current.likeInfo.count--;
        }
        setArticle(newArticle);
      };
      updateValue(newValue);
      toggleLike({
        targetId: item.id,
        value: Number(newValue),
        type: 1,
      })
        .catch(() => {
          updateValue(oldValue);
        })
        .finally(() => {
          lockMap.current[item.id] = false;
        });
    }}
  >
    <LikeOutlined
      style={
        item.likeInfo.isLike ? { color: "#1677ff" } : {}
      }
    />
    {item.likeInfo.count}
  </Space>