Redis_历史价格_Springboot_价格存取顺序

1.配置项目redis

---

2.由于生产任务中历史价格数据越来越多，考虑到项目优化，将采用redis缓存原理存取历史价格

package com.nsdat.apm.po.service;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.nsdat.apm.common.KeyPrefix;
import com.nsdat.apm.po.entity.ViewPriceHistory;
import com.nsdat.apm.po.mapper.ViewPriceHistoryMapper;

@Service
public class PriceCacheService implements InitializingBean{
    
    private Logger log = LoggerFactory.getLogger(PriceCacheService.class);

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private ViewPriceHistoryMapper viewPriceHistoryMapper;
    
    /**
     * 向列表中初始化所有料号历史价格
     * 用法：用于定时任务，指定时间初始化价格
     * @param viewPriceHistory
     */
    public void initPartNoPrice() {
        //记录keys，遇到新的key，先删清除redis，再往里加
        Set<String> keys = new HashSet<>();
        String key = null;
        List<ViewPriceHistory> viewPriceHistorylist =viewPriceHistoryMapper.getViewPriceHistory();
        for (int i = 0; i < viewPriceHistorylist.size(); i++) {
            ViewPriceHistory viewPriceHistory = viewPriceHistorylist.get(i);
            key = KeyPrefix.priceCache+viewPriceHistory.getPartNo();
            if(!keys.contains(key))
            {            
                keys.add(key);
                redisTemplate.delete(key);
            }
            redisTemplate.opsForList().leftPush(key, viewPriceHistory);
            
        }
    }
    
    /**
     * 向列表中插入料号对应的ViewPriceHistory
     * -----用于提交审核后向数据库中插入数据
     * @param viewPriceHistory
     */
    public void pushPartNoPrice(ViewPriceHistory viewPriceHistory) {
            redisTemplate.opsForList().leftPush(KeyPrefix.priceCache+viewPriceHistory.getPartNo(), viewPriceHistory);
    }
    
    /**
     * 查询指定料号对应价格
     * -----用于查询该料号最近五条数据
     * @param viewPriceHistory
     */
    public List<Object> getPartNo5Price(String partNo) {
        
        List<Object> viewPriceHistorylist = redisTemplate.opsForList().range(KeyPrefix.priceCache+partNo, 0, 4);
        return viewPriceHistorylist;
    }
    
    /**
     * 查询指定料号对应价格---最近所有价格
     * -----用于查询最近20数据
     * @param viewPriceHistory
     */
    public List<Object> getPartNoAllPrice(String partNo) {
        
        List<Object> viewPriceHistorylist = redisTemplate.opsForList().range(KeyPrefix.priceCache+partNo,0,19);
        return viewPriceHistorylist;
    }
    
    /**
     * 将对应key全部删除
     */
    public void cleanPartNoPrice() {
        Set<String> keys = redisTemplate.keys(KeyPrefix.priceCache + "*");
        redisTemplate.delete(keys);
    }
    
    /**
     * 审核通过添加缓存
     * @param id
     * @param username
     * @param sign
     */
    @Transactional
    public void confirm(Integer id,String username,String sign) {
        List<ViewPriceHistory> viewPriceHistoryList = viewPriceHistoryMapper.findViewPriceHistory(id);
        for (int i = 0; i < viewPriceHistoryList.size(); i++) {
            pushPartNoPrice(viewPriceHistoryList.get(i));
        }
    }
    //spring 注入完成后,可以初始化缓存中的历史价格
    @Override
    public void afterPropertiesSet() throws Exception {
        //以下代码在定时任务开通后屏蔽即可
        //cleanPartNoPrice();
        //initPartNoPrice();        
    }

    /**
     * 查询指定料号对应价格
     * -----用于查询该料号最近Count数据   左右都闭的原则
     * @param viewPriceHistory
     */
    public List<Object> getPartNoPrice(String partNo,int count) {
        
        List<Object> viewPriceHistorylist = redisTemplate.opsForList().range(KeyPrefix.priceCache+partNo, 0, count);
        if (viewPriceHistorylist == null) {
            viewPriceHistorylist = new ArrayList<Object>();
        }
        return viewPriceHistorylist;
    }
}
 

 

---

3.开启定时任务每天定时初始化

package com.nsdat.apm.atask;

import java.util.Date;
import java.util.List;
import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import com.nsdat.apm.common.KeyPrefix;
import com.nsdat.apm.mail.entity.Mail;
import com.nsdat.apm.mail.service.MailService;
import com.nsdat.apm.mrp.service.MrpService;
import com.nsdat.apm.po.mapper.PoMapper;
import com.nsdat.apm.po.service.PriceCacheService;
import com.ruoyi.framework.web.service.DictService;
import com.ruoyi.project.system.dict.domain.DictData;

/**
 * 定时任务类1
 * Created by zhangxue
 */
//要声明为bean，没有声明启动类启动无法实现定时效果

//@EnableScheduling
@Component("schedulerTask")
public class SchedulerTask {
    
    Logger log = LoggerFactory.getLogger(getClass());
    
    @Autowired
    private SchedulerService schedulerService;

    @Autowired
    private PriceCacheService priceCacheService;

    @Autowired
    private PoMapper poMapper;
    
    @Autowired
    private MrpService mrpService;

    /***
     * 订单类到货通知
     * @param days
     */
    
    public void arrivalNotice(String days)
    {
        log.info("<<----arrivalNotice begin---");
        try {
            schedulerService.arrivalNotice(Integer.valueOf(days));
        }
        catch(Exception ex)
        {
            log.error("error", ex);
        }
        log.info("----monthReport end--->>");
    }
    

    //@Scheduled(cron = "35 0 0/1 * * ?")
    public void arrivalNotice()
    {
        String days = "2";
        log.info("<<----arrivalNotice begin---");
        try {
            schedulerService.arrivalNotice(Integer.valueOf(days));
        }
        catch(Exception ex)
        {
            log.error("error", ex);
        }
        log.info("----monthReport end--->>");
    }

    /***
     * 批量更新到货日期 从po_items 到bom 
     */
    //@Scheduled(cron = "0 0/30 * * * ?")
    private void updateDiliveryTime()
    {
        log.info("------- updateDiliveryTime begin");
        try
        {
            poMapper.updateDiriveryTime();
        }catch(Exception ex)
        {
            log.error("error", ex);
        }
        log.info("------- updateDiliveryTime  end");
    }
    
    
    private static boolean mailFlag = false;

   // @Scheduled(cron = "20 0/2 * * * ?")
    private void sendMail()
    {     
        //上一个没跑完就退出
        if(mailFlag)
        {
            return;
        }
        mailFlag = true;
        try {
            schedulerService.sendMail();
        }catch(Exception ex)
        {
            log.error("error", ex);
        }
        mailFlag = false;
    }
    
    /***
     * 库存 每月结转， 一个月只跑一次 1号 1:05
     */
    //@Scheduled(cron = "5 0 1 1 * ?")
    public void monthReport()
    {
        log.info("<<----monthReport begin---");
        try
        {
            schedulerService.monthReport();
        }
        catch(Exception ex)
        {
            log.error("error", ex);
        }
        log.info("----monthReport end--->>");
    }
 
    
    /***
     * 初始化价格缓存---每天凌晨 3:01，
     */
    //@Scheduled(cron = "0 1 3 * * ?")
    public void initPriceCache()
    {
        log.info("<<----initPriceCache begin---");
        try
        {            
            //初始化
            priceCacheService.initPartNoPrice();
        }
        catch(Exception ex)
        {
            log.error("error", ex);
        }
        log.info("----initPriceCache end--->>");
    }
    
    public void prAdvise()
    {
        log.info("<<----prAdvise begin---");
        try
        {            
            mrpService.generatePrAdvise();
        }
        catch(Exception ex)
        {
            log.error("error", ex);
        }
        log.info("----prAdvise end--->>");
        
    }
    
    
}