缓存springboot整合redis01

Posted 2021-11-26 lazyli

eclipse创建springboot要注意，基本的包名一定要与java中的包名一致，这样才能找到springgboot主程序的入口；
主程序是在com.lazy.cache;那么test的包也要是com.lazy.cache
src/main/java
com.lazy.cache
CacheApplication.java
src/test/java
com.lazy.cahche
UserTest.java
----
注：#开启mybatis驼峰命名,数据字段名与属性名不一致，如:t_id,tId;需要开启这个，不然查询的结果为null
mybatis.configuration.map-underscore-to-camel-case=true
--------------
springboot知识点：
springboot-cache(缓存)：
需要引入springboot缓存依赖
<dependency>
　　<groupId>org.springframework.boot</groupId>
　　<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
--------------

1、开启基于注解的缓存，在主程序入口类上面,使用注解@EnableCaching

MapperScan("com.lazy.cache.mapper")//扫描mapper接口
@SpringBootApplication
@EnableCaching
public class CacheApplication {

    public static void main(String[] args) {
        SpringApplication.run(CacheApplication.class, args);
    }
    
}

2、标注缓存注解（需要的缓存的方法上,将方法返回结果放入缓存中）
@Cacheable 对方法中的返回结果放入缓存中

/**
 * @Cacheable(key-value的形式)
 * 有几个属性：
 * cacheNames/value指定缓存组件的名字，员工放在emp组件中，里面可以放入多个key-value
 * key:缓存中的key名字，默认是方法参数的值，比如这里的id=1,那么key就是1；可以知道SpEL表达式指定key值
 *     #root.args[0]是取方法参数第一个参数等价于#id
    自定义key(名为getEmployeeById[id]): key="#root.method.name+‘[‘+#id+‘]‘";方法名加参数的形式
    自定义key生成器，
 * keyGenerator:key的生成器
 * key/keyGenerator二选一
 * cacheManager：指定缓存管理器
 * condition:指定符合条件的情况下进行缓存
 *     condition="#id>0"
 * unless:符合条件的不缓存，与condition相反
 * #result可以取到结果的返回值
 * sync:缓存是否使用异步
 */
@Cacheable(cacheNames={"emp"})
public Employee getEmployeeById(Integer id) {
    System.out.println("查询"+id+"号信息");
    Employee employee = employeeMapper.getEmployeeById(id);
    return employee;
}

原理：
1、自动配置类：CacheAutoConfiguration
2、缓存的配置类：默认redis
运行流程：
1、方法运行之前，先去查询cache，按照指定的cacheNames指定的名字获取缓存，第一次获取缓存(是为null)会先创建缓存(名为emp,这里的key是默认id)
2、去Cache中查找缓存的内容，使用一个key，默认就是方法的参数；key是按照某种策略生成的；默认是使用keyGenerator生成的，
3、没有查到缓存就调用目标方法
4、将目标方法返回结果，放进缓存中
@Cacheable标注的方法执行之前先检查缓存中有没有这个数据，默认按照参数的值作为key去查询缓存，如果没有就进入目标方法中，到数据库中查询；数据库查询的结果返回，会将该结果放入到缓存中，下次在进行这个key查询，也会先到缓存中查询，缓存中存在这个key,就直接返回这个结果，不进入方法中。
注：配置前面的直接运行，会出现异常(找不到端口).但开启redis后，可以正常运行。看视频，都能正常运行，也没开rdeis，这是什么原因，还有这样cache的数据是存储在哪里的。版本问题，在1.5springboot版本默认的是SimpleCacheConfiguration,而在2.1版本是默认的是RedisCacheConfiguration缓存生效。所以在缓存需要打开redis服务端，在配置文件配置debug=true;可以看到容器启动加载了多少类。上面的是错误的，默认的还是SimpleCacheConfiguration，造成的原因是导入了redis的starter,它会启动redis的，如果没有导入redis的starter默认的还是SimpleCacheConfiguration。
--------------

@CachePut修改了某数据，更新缓存，同步缓存
/**
 * @CachePut执行时机：是先执行目标方法，然后将方法的返回结果，更新到缓存中
 * key="#employee.id"可以用key="#result.id"
 * 属性基本相同
 */
@CachePut(value="emp",key="#employee.id")
public Employee updateEmployee(Employee employee) {
    System.out.println("更新员工："+employee);
    employeeMapper.updateEmployee(employee);
    return employee;
}

@CacheEvict清除缓存
/**
 * 删除缓存
 * allEntries默认是false,
 * @CacheEvict(value="emp",allEntries=true)")清除emp组件中所有缓存
 * beforeInvocation默认是false,清除缓存在方法之后执行。
 *     设置为true，可以在方法前执行，尽管方法中出现异常也可以清除数据库
 */
@CacheEvict(value="emp",key="#id",allEntries=true)
public void DeleteEmployee(Integer id) {
    System.out.println("将缓存中的数据清除!,这里并没有把数据库中的数据删除");
}
----------
/**
 * 组合成复杂的缓存，
 * @Cacheable(value="emp",key="#lastName")执行目标方法前
 * @CachePut(value="emp",key="#result.id"),
 * 将执行方法后以key="#result.id"，key="#result.email存入缓存中
 * @param lastName
 * @return
 * 出现异常信息
 */
/*@Caching(
    cacheable = {
            @Cacheable(value="emp",key="#lastName")
    },
    put = {
            @CachePut(value="emp",key="#result.id"),
            @CachePut(value="emp",key="#result.email")
    }
)*/
public Employee getEmpByLastName(String lastName) {
    Employee employee = employeeMapper.getEmpByLastName(lastName);
    return employee;
}

springboot整合redis
1、使用docker安装redis,这里使用widows版本，可以在redis官方文档中有详细的信息
2、引入redis的依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
3、在配置文件中配置redis(不需要指定端口，默认的是6379)
spring.redis.host=127.0.0.1

public class RedisTest {

    @Autowired
    private EmployeeMapper employeeMapper;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;//key-value是字符串形式
    @Autowired
    private RedisTemplate redisTemplate;//key-value是Object-Object的形式
    @Autowired
    private RedisTemplate<Object, Employee> empRedisTemplate;//自定义的redis模板，以json序列化
    
    /**
     * 以stringRedisTemplate操作redis
     * redis可以存储五种类型的数据结构,String类型，hash类型，set,list,zset
     * stringRedisTemplate.opsForValue()是操作String类型的
     * stringRedisTemplate.opsForHash()是操作hash类型
     * stringRedisTemplate.opsForSet()是操作Set类型
     * stringRedisTemplate.opsForZSet()是操作ZSet类型
     * stringRedisTemplate.opsForList()是操List类型
     */
    @Test
    public void demoRedis(){
        //向redis中添加一个string类型的数据
        //stringRedisTemplate.opsForValue().append("msg", "hello");
        //获取redis中的元素
        //String msg = stringRedisTemplate.opsForValue().get("msg");
        //System.out.println(msg);
        //添加一个list数据,是从左边插入的，
        //stringRedisTemplate.opsForList().leftPush("mylist", "first");
        //stringRedisTemplate.opsForList().leftPush("mylist", "second");
        //获取list的数据
        String result = stringRedisTemplate.opsForList().leftPop("mylist");
        System.out.println(result);
    }
    
    /**
     * 使用redisTemplate操作存储对象
     */
    @Test
    public void testRedis(){
        Employee employee = employeeMapper.getEmployeeById(1);
        //这里存放到redis是jdk序列化的数据，不是像json的数据类型
        //如果要对象在redis中以json数据呈现，需要设置配置类，序列化(使用json Serializable)
        //redisTemplate.opsForValue().set("emp01", employee);
        empRedisTemplate.opsForValue().set("emp01", employee);
    }    
}
----------------
@Configuration
public class MyRedisConfig {

    @Bean
    public RedisTemplate<Object,Employee> empRedisTemplate(
            RedisConnectionFactory redisConnectionFactory)
                    throws UnknownHostException {
        RedisTemplate<Object, Employee> template = new RedisTemplate<Object, Employee>();
        template.setConnectionFactory(redisConnectionFactory);
        //设置序号化形式，以json
        Jackson2JsonRedisSerializer<Employee> serializer = new Jackson2JsonRedisSerializer<>(Employee.class);
        template.setDefaultSerializer(serializer);
        return template;
    }
    
}

上面的是测试：现在在项目中运用，保存对象时，还是默认的jdk序列化。要保存json的话：
1、引入redis的starter,cacheMananger变为RedisCacheManager
2、默认创建的RedisCacheManager操作redis的时候使用的是RedisTemplate<Object,Object>,
3、RedisTemplate<Object,Object>默认使用是JDK序列化，
4、自定义CacheMananger,

@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisTest {

    @Autowired
    private EmployeeMapper employeeMapper;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;//key-value是字符串形式
    @Autowired
    private RedisTemplate redisTemplate;//key-value是Object-Object的形式
    //@Autowired
    //private RedisTemplate<Object, Employee> empRedisTemplate;//自定义的redis模板，以json序列化
    
    /**
     * 以stringRedisTemplate操作redis
     * redis可以存储五种类型的数据结构,String类型，hash类型，set,list,zset
     * stringRedisTemplate.opsForValue()是操作String类型的
     * stringRedisTemplate.opsForHash()是操作hash类型
     * stringRedisTemplate.opsForSet()是操作Set类型
     * stringRedisTemplate.opsForZSet()是操作ZSet类型
     * stringRedisTemplate.opsForList()是操List类型
     */
    @Test
    public void demoRedis(){
        //向redis中添加一个string类型的数据
        //stringRedisTemplate.opsForValue().append("msg", "hello");
        //获取redis中的元素
        //String msg = stringRedisTemplate.opsForValue().get("msg");
        //System.out.println(msg);
        //添加一个list数据,是从左边插入的，
        //stringRedisTemplate.opsForList().leftPush("mylist", "first");
        //stringRedisTemplate.opsForList().leftPush("mylist", "second");
        //获取list的数据
        String result = stringRedisTemplate.opsForList().leftPop("mylist");
        System.out.println(result);
    }
    
    /**
     * 使用redisTemplate操作存储对象
     */
    @Test
    public void testRedis(){
        Employee employee = employeeMapper.getEmployeeById(1);
        //这里存放到redis是jdk序列化的数据，不是像json的数据类型
        //如果要对象在redis中以json数据呈现，需要设置配置类，序列化(使用json Serializable)
        //redisTemplate.opsForValue().set("emp01", employee);
        redisTemplate.opsForValue().set("emp01", employee);
    }    
}
------------
@Configuration
public class MyRedisConfig {
    /**
     * 直接使用模板操作redis需要这样设置
     * @param redisConnectionFactory
     * @return
     * @throws UnknownHostException
     */
    @Bean
    public RedisTemplate<Object,Employee> empRedisTemplate(
            RedisConnectionFactory redisConnectionFactory)
                    throws UnknownHostException {
        RedisTemplate<Object, Employee> template = new RedisTemplate<Object, Employee>();
        template.setConnectionFactory(redisConnectionFactory);
        //设置序号化形式，以json
        Jackson2JsonRedisSerializer<Employee> serializer = new Jackson2JsonRedisSerializer<>(Employee.class);
        template.setDefaultSerializer(serializer);
        return template;
    }
    /**
     * 这是在项目中，将对象存入redis中以json形式，
     *，2.x版本没有new RedisCacheManager(RedisTemplate)构造方法
     * 使用这个的话new RedisCacheManager(RedisTemplate)，
     * 在项目中需要给每个存储对象都写RedisTemplate<Object,Object);
     * 下面这个设置可以通用
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisCacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory) {
        //初始化一个RedisCacheWriter
        RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);
        RedisSerializer<Object> jsonSerializer = new GenericJackson2JsonRedisSerializer();
        RedisSerializationContext.SerializationPair<Object> pair = RedisSerializationContext.
                SerializationPair.fromSerializer(jsonSerializer);
        RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig()
                .serializeValuesWith(pair);
        
        return new RedisCacheManager(redisCacheWriter, defaultCacheConfig);
    }
    
     /**
     * 缓存管理器
     */
   /* @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        //初始化一个RedisCacheWriter
        RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);
        //设置CacheManager的值序列化方式为json序列化
        RedisSerializer<Object> jsonSerializer = new GenericJackson2JsonRedisSerializer();
        RedisSerializationContext.SerializationPair<Object> pair = RedisSerializationContext.SerializationPair
                                                    .fromSerializer(jsonSerializer);
        RedisCacheConfiguration defaultCacheConfig=RedisCacheConfiguration.defaultCacheConfig()
                                                    .serializeValuesWith(pair);
        //设置默认超过期时间是30秒
        defaultCacheConfig.entryTtl(Duration.ofSeconds(30));
        //初始化RedisCacheManager
        return new RedisCacheManager(redisCacheWriter, defaultCacheConfig);
    }*/
}

注：可以使用两种方法进行redis缓存，一种是注入RedisTemplate模板操作，这种操作比较复杂，但比较灵活，在程序指定的位置进行放入。
第二种方式使用注解方式，@Cachalbe,等等
----------
不使用注解：
注入缓存管理器
Cache dept = deptCacheManager.getCache("dept");//dept是上面注解的@Cacheable(value="dept")形式
dept.put("dept:1",department);