完成缓存搭建

但是感觉这个工程没有必要搭建缓存，查询是动态的不合适，只能在一些固定的页面上家，就当做是熟悉功能吧。

引入依赖

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

然后写一个properties文件

spring.redis.database=0
spring.redis.host=localhost
spring.redis.port=6379
# 连接超时时间 单位 ms（毫秒）
spring.redis.timeout=3000

# 连接池中的最大空闲连接，默认值也是8。
redis.pool.max-idle=8
#连接池中的最小空闲连接，默认值也是0。
redis.pool.min-idle=0
# 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
redis.pool.max-active=8
# 等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException
redis.pool.max-wait=-1

#################redis哨兵设置#################
# Redis服务器master的名字
#spring.redis.sentinel.master=master8026
# redis-sentinel的配置地址和端口
#spring.redis.sentinel.nodes=10.189.80.25:26379,10.189.80.26:26379,10.189.80.27:26378

还有一个config配置类（后面可能要做分布式配置中心）

@Configuration
@EnableCaching
public class RedisConfig{

    private Logger logger = LoggerFactory.getLogger(this.getClass());

    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private int port;

    @Value("${spring.redis.timeout}")
    private int timeout;

//    @Value("${spring.redis.password}")
//    private String password;

    @Value("${spring.redis.database}")
    private int database;

    @Value("${redis.pool.max-idle}")
    private int maxIdle;

    @Value("${redis.pool.min-idle}")
    private int minIdle;

    /**
     * redis模板，存储关键字是字符串，值是Jdk序列化
     * @Description:
     * @param factory
     * @return
     */
    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(redisSerializer);
        redisTemplate.setHashKeySerializer(redisSerializer);
        //JdkSerializationRedisSerializer序列化方式;
        JdkSerializationRedisSerializer jdkRedisSerializer=new JdkSerializationRedisSerializer();
        redisTemplate.setValueSerializer(jdkRedisSerializer);
        redisTemplate.setHashValueSerializer(jdkRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

接着使用一个工具类

不贴了

service逻辑搭建，以及防穿透

@Override
public JobOne selectJobById(Long jobId){

    JobOne jobOne=null;

    if ("".equals(redisUtils.get(String.valueOf(jobId)))){

        logger.info("\n从缓存返回空值");
        return jobOne;
    }
    try {

        if (redisUtils.get(String.valueOf(jobId)) != null) {
            logger.info("\n" + "从缓存中查询单条数据");
            jobOne = (JobOne) redisUtils.get(String.valueOf(jobId));
        } else {
            logger.info("\n" + "从数据库查询单条数据");
            jobOne = jobOneMapper.selectJobById(jobId);
            if (jobOne != null) {
                redisUtils.set(String.valueOf(jobId), jobOne,60*60*2);
                logger.info("\n" + "新增单条缓存数据:" + redisUtils.get(String.valueOf(jobId)));
            } else {
                redisUtils.set(String.valueOf(jobId),"", 60*60);
                logger.info("\n" + "将空值存到缓存中");
            }
        }
    } catch (Throwable t) {
        t.printStackTrace();
    }
    return jobOne;
}

@Override
public CompanyOne selectCompanyById(Long companyId) {

    CompanyOne companyOne=null;

    if ("".equals(redisUtils.get(String.valueOf(companyId)))){

        logger.info("\n从缓存返回空值");
        return companyOne;
    }
    try {

        if (redisUtils.get(String.valueOf(companyId)) != null) {
            logger.info("\n" + "从缓存中查询单条数据");
            companyOne = (CompanyOne) redisUtils.get(String.valueOf(companyId));
        } else {
            logger.info("\n" + "从数据库中查询单条数据");
            companyOne = companyOneMapper.selectCompanyById(companyId);
            if (companyOne != null) {
               redisUtils.set(String.valueOf(companyId), companyOne,60*60*2);
                logger.info("\n" + "新增单条缓存数据:" + redisUtils.get(String.valueOf(companyId)));
            } else {
                redisUtils.set(String.valueOf(companyId),"", 60*60);
                logger.info("\n" + "将空值存到缓存");
            }
        }
    } catch (Throwable t) {
        t.printStackTrace();
    }
    return companyOne;
}

明天计划的事情：

开始做一下权限的功能