service

 1.ActivityInfoServiceImpl

import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.integrated.ac.entity.ActivityInfo;
import com.integrated.ac.mapper.ActivityInfoMapper;
import com.integrated.ac.service.ActivityInfoService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.integrated.dt.entity.Question;
import com.integrated.dt.service.QuestionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author yan
 * @since 2021-10-05
 */
@Service
public class ActivityInfoServiceImpl extends ServiceImpl<ActivityInfoMapper, ActivityInfo> implements ActivityInfoService {

    @Autowired
    private QuestionService questionService;

    @Override
    public void loadActivityQuestion() {
        List<ActivityInfo> activityInfoList = this.list(new QueryWrapper<>(new ActivityInfo().setIisEffect(1)));
        if (CollectionUtil.isNotEmpty(activityInfoList)) {
            activityInfoList.forEach(activityInfo ->
                    questionService.loadActivityQuestion(activityInfo.getId()));

        }
    }
}

2.QuestionServiceImpl

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.integrated.dt.entity.Question;
import com.integrated.dt.mapper.QuestionMapper;
import com.integrated.dt.service.QuestionService;
import com.integrated.dt.vo.QuestionVo;
import com.integrated.util.CommonUtil;
import com.integrated.util.ExecutorManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;

import static java.util.stream.Collectors.groupingBy;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author yan
 * @since 2021-10-02
 */
@Service
public class QuestionServiceImpl extends ServiceImpl<QuestionMapper, Question> implements QuestionService {

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    private Map<Integer, List<QuestionVo>> caches = null;

    @Autowired
    private QuestionMapper questionMapper;


    private List<QuestionVo> getRandomQuestions(Integer key, int num, Integer activityId) {

        /*List<QuestionVo> questionVoList = caches.get(key);*/
        List<QuestionVo> questionVoList = loadActivityQuestion(activityId).get(key);
        if (CollectionUtils.isEmpty(questionVoList)) {
            return new ArrayList<>();
        }
        List<QuestionVo> questionVos = CommonUtil.getRandomList(questionVoList, num);
        return questionVos;

    }

    /*
        @Cacheable(value = "userQuestion" ,key = "#w3Id"*//*,sync = true*//*)*/
    public List<QuestionVo> getUserQuestion(Integer activityId) {
        List<QuestionVo> questionVoList = getRandomQuestions(1, 2, activityId);
        List<QuestionVo> questionVoList2 = getRandomQuestions(2, 1, activityId);
        questionVoList.addAll(questionVoList2);
        return questionVoList;
    }

    public void loadDataDictAgain() {
        loadDataDict();
    }

    /**
     * 加载问题
     */
    public @PostConstruct
    void loadDataDict() {
        ExecutorManager.getInstance().execute(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.writeLock().lock();
                  /*  lock.writeLock().lock();
                    caches = new HashMap<Integer, List<QuestionVo>>();
                    List<QuestionVo> questionVoList = questionMapper.getQuestions();
                    addCache(questionVoList);//添加到caches*/
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.writeLock().unlock();
                }
            }
        });
    }

    private void addCache(List<QuestionVo> page) {
        if (!CollectionUtils.isEmpty(page)) {
            caches = page.stream()
                    .collect(groupingBy(QuestionVo::getLevel));

        }
    }


    @Override
    @Cacheable(value = "activityQuestion", key = "#activityId")
    public Map<Integer, List<QuestionVo>> loadActivityQuestion(Integer activityId) {

        List<QuestionVo> questionVoList = questionMapper.selectActivityQuestion(activityId);
        if (!CollectionUtils.isEmpty(questionVoList)) {
            return questionVoList.stream()
                    .collect(groupingBy(QuestionVo::getLevel));

        }
        return new HashMap<>();
    }
}

3. UserQuestionStaticServiceImpl

import cn.hutool.crypto.SecureUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.integrated.common.ErrorCodeEnum;
import com.integrated.common.ResponseVo;
import com.integrated.dt.entity.UserQuestionRecord;
import com.integrated.dt.entity.UserQuestionStatic;
import com.integrated.dt.mapper.UserQuestionRecordMapper;
import com.integrated.dt.mapper.UserQuestionStaticMapper;
import com.integrated.dt.service.UserQuestionStaticService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.integrated.dt.vo.QuestionVo;
import com.integrated.dt.vo.UserQuestionVo;
import com.integrated.util.CommonUtil;
import com.integrated.util.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Objects;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author yan
 * @since 2021-10-02
 */
@Service
public class UserQuestionStaticServiceImpl extends ServiceImpl<UserQuestionStaticMapper, UserQuestionStatic> implements UserQuestionStaticService {


    @Autowired
    private QuestionServiceImpl questionService;
    @Autowired
    private UserQuestionStaticMapper userQuestionStaticMapper;
    @Autowired
    private UserQuestionRecordMapper userQuestionRecordMapper;

    @Autowired
    private RedisUtil redisUtil;

    @Override
    @Transactional
    public ResponseVo<UserQuestionVo> getQuestion(String w3Id, HttpServletRequest request) {
        if (redisUtil.hasKey("user_question:"+w3Id)) {
            UserQuestionVo data = (UserQuestionVo) redisUtil.get("user_question:"+w3Id);
            //UserQuestionVo userQuestionVo = JSONUtil.toBean(data, UserQuestionVo.class);
            return ResponseVo.getSuccessResponse(data);
        }
        String ip = CommonUtil.getIpAddr(request);
        UserQuestionStatic userQuestionStaticTemp = userQuestionStaticMapper
                .selectOne(new QueryWrapper<UserQuestionStatic>().eq("ip", ip));
        if (Objects.isNull(userQuestionStaticTemp)) {
            List<QuestionVo> questionVoList = questionService.getUserQuestion(1);
            if (!CollectionUtils.isEmpty(questionVoList)) {
                UserQuestionStatic userQuestionStatic = new UserQuestionStatic();
                userQuestionStatic.setAcNumber(0);
                userQuestionStatic.setAqNumber(3);
                userQuestionStatic.setCreatTime(LocalDateTime.now());
                userQuestionStatic.setUserId(1);
                userQuestionStatic.setIp(ip);
                userQuestionStatic.setUserOnlyToken(SecureUtil.md5(w3Id+"activityId:"+1));
                userQuestionStaticMapper.insert(userQuestionStatic);
                questionVoList.forEach(questionVo -> {
                    UserQuestionRecord userQuestionRecord = new UserQuestionRecord();
                    userQuestionRecord.setCreatTime(LocalDateTime.now())
                            .setIisCorrect("0")
                            .setQuestionId(questionVo.getId())
                            .setUserQuestionId(userQuestionStatic.getId());
                    userQuestionRecordMapper.insert(userQuestionRecord);
                    questionVo.setUserQuestionRecordId(userQuestionRecord.getId());
                });
                UserQuestionVo userQuestionVo = new UserQuestionVo();
                userQuestionVo.setQuestionVoList(questionVoList).setUserQuestionStaticId(userQuestionStatic.getId());
                redisUtil.set("user_question:" + w3Id, (userQuestionVo));
                return ResponseVo.getSuccessResponse(userQuestionVo);
            }
        }else {
            return ResponseVo.getErrorResponse("ip重复");
        }
        return ErrorCodeEnum.ERROR_COMMON_SYSTEM.getResponseVo();
    }
}