前言：

废话不多讲，redis的安装，redis中的数据结构及介绍就不讲了。本篇只讲解，redis结合ideal实现缓存查询

一.工作流程

二. RedisConfig类

package com.dmdd.java13redis.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
@EnableCaching
@Configuration
public class RedisConfig {
    //向IOC容器提供一个Redis操作对象，配置键和值的序列化
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        //创建Redis模板对象
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        //设置连接
        template.setConnectionFactory(factory);
        // 配置JSON序列化器
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置字符串序列化器
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson序列化器
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        // 完成配置
        template.afterPropertiesSet();
        return template;
    }

    //配置声明式缓存
    @Bean
    public RedisCacheConfiguration provideRedisCacheConfiguration(){
        //加载默认配置
        RedisCacheConfiguration conf = RedisCacheConfiguration.defaultCacheConfig();
        //返回Jackson序列化器
        return conf.serializeValuesWith(
                RedisSerializationContext.SerializationPair
                        .fromSerializer(new GenericJackson2JsonRedisSerializer()));
    }
}

主要实现Redis中键和值的序列化

三.application.properties

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/edu_user?serverTimezone=UTC&useUnicode=true&useSSL=false&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=jly720609

mybatis-plus.type-aliases-package=com.dmdd.java13redis.entity
mybatis-plus.mapper-locations=classpath:mapper/*.xml

spring.redis.host=192.168.56.188
spring.redis.port=6379
spring.redis.database=0
spring.redis.jedis.pool.max-active=100
spring.redis.jedis.pool.max-wait=100ms
spring.redis.jedis.pool.max-idle=100
spring.redis.jedis.pool.min-idle=10

redis.host的ip是linux虚拟机的ip，redis的默认端口是6379，其他的配置就不讲解了，懂得都懂。

四.开启linux中的redis

1.进入redis下的src目录

2.输入 ./redis-server ../redis.conf

五.使用redis结合数据库进行数据查询

5.1编程式缓存

package com.dmdd.java13redis.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.dmdd.java13redis.entity.User;
import com.dmdd.java13redis.mapper.UserMapper;
import com.dmdd.java13redis.service.IUserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author xray
 * @since 2023-01-31
 */
@Slf4j
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
    private static  final String KEY="User-";
    @Autowired
    private RedisTemplate<String,Object>  redisTemplate;



    @Override
    public User getUserById(Long id) {
        //获得String类型的操作对象
        ValueOperations<String, Object> ops = redisTemplate.opsForValue();
        //查询redis中的用户
        User user = (User) ops.get(KEY + id);
        //如果Redis中不存在
        if (user==null){
            log.info("在redis中找不到");
            //在数据中查找
            user = this.getById(id);
            if (user!=null){
                log.info("在数据库中存在，保存到redis中 id为"+id);
                ops.set(KEY+id,user);
                //返回给服务器
                return user;
            }
        }
        //redis中存在
        else {
            log.info("redis中存在，返回该对象 id为"+id);
            return user;
        }
        return null;
    }
//    @Cacheable(cacheNames = "User",key = "T(String).valueOf(#id)")
//    @Override
//    public User getUserById(Long id) {
//        return this.getById(id);
//    }
}

第一种查询写法是编程式缓存遵循以下流程执行

先查询缓存

如果查到直接返回

如果查不到，查询数据库

数据库查到，保存缓存中

数据库查不到返回null

编程式缓存使用复杂，代码侵入性高，推荐使用声明式缓存，通过注解来实现热点数据缓存。

5.2声明式缓存

5.2.1在启动类上添加注解

//启动缓存
@EnableCaching

5.2.2实现代码

@Cacheable(cacheNames = "User",key = "T(String).valueOf(#id)")
    @Override
    public User getUserById(Long id) {
        return this.getById(id);
    }