ideal整合reids实现缓存查询

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虚拟机的ipredis的默认端口是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);
    }