spring boot 开发—第五篇SpringDataJPA整合 Redis 实现缓存

最新推荐文章于 2024-05-25 18:33:13 发布

vesus198

最新推荐文章于 2024-05-25 18:33:13 发布

阅读量560

点赞数

分类专栏： spring boot

本文链接：https://blog.csdn.net/liuweilong07/article/details/80358688

版权

spring boot 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

对druid项目进行改造，增加redis缓存支持。

1、redis简介

Redis 是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。

Redis 与其他 key - value 缓存产品有以下三个特点：

Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。
Redis支持数据的备份，即master-slave模式的数据备份。

2、Redis 优势

性能极高 – Redis能读的速度是110000次/s,写的速度是81000次/s 。
丰富的数据类型 – Redis支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。
原子 – Redis的所有操作都是原子性的，意思就是要么成功执行要么失败完全不执行。单个操作是原子性的。多个操作也支持事务，即原子性，通过MULTI和EXEC指令包起来。
丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过期等等特性。

3、构建项目

这里写图片描述

修改pom文件，增加对redis的依赖。pom文件如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.vesus</groupId>
    <artifactId>springboot-redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>springboot-redis</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>com.vesus</groupId>
        <artifactId>spring-boot-demo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--spring jpa-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!-- mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--引入druid最新maven依赖-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.29</version>
        </dependency>
        <!--引入redis的支持-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2、配置application.properties

spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=123456
spring.jpa.show-sql=true
spring.jpa.hibernate.naming.strategy=org.hibernate.cfg.ImprovedNamingStrategy
spring.jpa.database=mysql
##########################  druid配置   ##########################
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
#最大活跃数
spring.datasource.maxActive=20
#初始化数量
spring.datasource.initialSize=5
#最小活跃数
spring.datasource.minIdle=5
#配置超市等待时间
spring.datasource.maxWait=60000
#配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
spring.datasource.timeBetweenEvictionRunsMillis=60000
#配置一个连接在池中最小生存的时间，单位是毫秒
spring.datasource.minEvictableIdleTimeMillis=300000
spring.datasource.validationQuery=SELECT 1 FROM t_user
spring.datasource.testWhileIdle=true
spring.datasource.testOnBorrow=false
spring.datasource.exceptionSorter=true
spring.datasource.testOnReturn=false
#打开PSCache，并且指定每个连接上PSCache的大小
spring.datasource.poolPreparedStatements=true
spring.datasource.maxPoolPreparedStatementPerConnectionSize=20
#配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
spring.datasource.filters=stat,wall,log4j
#通过connectProperties属性来打开mergeSql功能；慢SQL记录
spring.datasource.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
#合并多个DruidDataSource的监控数据
spring.datasource.useGlobalDataSourceStat=true
###########################redis#########################
#Redis数据库索引（默认为0）
spring.redis.database=0
#Redis服务器地址
spring.redis.host=10.211.55.5
#Redis服务器连接端口
spring.redis.port=6379
#Redis服务器连接密码（默认为空）
spring.redis.password=
#连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=10
#连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
#连接池中的最大空闲连接
spring.redis.pool.max-idle=8
#连接池中的最小空闲连接
spring.redis.pool.min-idle=0
#连接超时时间（毫秒）
spring.redis.timeout=0

3、编写RedisConfig

3.1 模板文件

Spring Data Redis提供了两个模板：

　　RedisTemplate

　　StringRedisTemplate

首先我们先创建一个RedisTemplate模板类，类型的key是String类型，value是Object类型（如果key和value都是String类型，建议使用StringRedisTemplate）

3.2、序列化

当保存一条数据的时候，key和value都要被序列化成json数据，取出来的时候被序列化成对象，key和value都会使用序列化器进行序列化，spring data redis提供多个序列化器

GenericToStringSerializer：使用Spring转换服务进行序列化；
JacksonJsonRedisSerializer：使用Jackson 1，将对象序列化为JSON；
Jackson2JsonRedisSerializer：使用Jackson 2，将对象序列化为JSON；
JdkSerializationRedisSerializer：使用Java序列化；
OxmSerializer：使用Spring O/X映射的编排器和解排器（marshaler和unmarshaler）实
现序列化，用于XML序列化；
StringRedisSerializer：序列化String类型的key和value。

RedisTemplate会默认使用JdkSerializationRedisSerializer，这意味着key和value都会通过Java进行序列化。StringRedisTemplate默认会使用StringRedisSerializer

3.3、实例代码如下：

package com.vesus.springbootredis.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import java.lang.reflect.Method;


//Redis 缓存配置类
public class RedisConfig extends CachingConfigurerSupport {

    //缓存对象集合中，缓存是以key-value的形式保存的,当不指定缓存key是，会使用KeyGenerator生成key
    //定义缓存数据 key 生成策略的bean包名+类名+方法名+所有参数
    @Bean
    public KeyGenerator keyGenerator(){
        return new KeyGenerator(){
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuffer buffer = new StringBuffer();
                buffer.append(target.getClass().getName());
                buffer.append(method.getName());
                for (Object obj : params) {
                    buffer.append(obj.toString());
                }
                return buffer.toString();
            }
        };
    };
    //要启用spring缓存支持,需创建一个 CacheManager的 bean，CacheManager 接口有很多实现，
    // 这里Redis 的集成，用 RedisCacheManager这个实现类
    @Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate){
        RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
        return cacheManager ;
    }
    //redis模板，Spring Data Redis提供了两个模板：RedisTemplate,StringRedisTemplate
    public RedisTemplate<String,String> redisTemplate(RedisConnectionFactory factory){
        StringRedisTemplate template = new StringRedisTemplate(factory);
        //序列化
        //spring data redis提供多个序列化器
        //GenericToStringSerializer：使用Spring转换服务进行序列化；
        //JacksonJsonRedisSerializer：使用Jackson 1，将对象序列化为JSON；
        //Jackson2JsonRedisSerializer：使用Jackson 2，将对象序列化为JSON；
        //JdkSerializationRedisSerializer：使用Java序列化；
        //OxmSerializer：使用Spring O/X映射的编排器和解排器（marshaler和unmarshaler）实
        //现序列化，用于XML序列化；
        //StringRedisSerializer：序列化String类型的key和value。
        Jackson2JsonRedisSerializer serializer = new              Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL,JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(om);
        template.setValueSerializer(serializer);
        template.afterPropertiesSet();
        return template ;

    }
}

4、编写Impl

4.1、Cache注解详解

@CacheConfig：主要用于配置该类中会用到的一些共用的缓存配置。在这里@CacheConfig(cacheNames = “users”)：配置了该数据访问对象中返回的内容将存储于名为users的缓存对象中，我们也可以不使用该注解，直接通过@Cacheable自己配置缓存集的名字来定义。
@Cacheable：配置了findByName函数的返回值将被加入缓存。同时在查询时，会先从缓存中获取，若不存在才再发起对数据库的访问。该注解主要有下面几个参数：
- value、cacheNames：两个等同的参数（cacheNames为Spring 4新增，作为value的别名），用于指定缓存存储的集合名。由于Spring 4中新增了@CacheConfig，因此在Spring 3中原本必须有的value属性，也成为非必需项了
- key：缓存对象存储在Map集合中的key值，非必需，缺省按照函数的所有参数组合作为key值，若自己配置需使用SpEL表达式，比如：@Cacheable(key = “#p0”)：使用函数第一个参数作为缓存的key值.
- condition：缓存对象的条件，非必需，也需使用SpEL表达式，只有满足表达式条件的内容才会被缓存，比如：@Cacheable(key = “#p0”, condition = “#p0.length() < 3”)，表示只有当第一个参数的长度小于3的时候才会被缓存，若做此配置上面的AAA用户就不会被缓存，读者可自行实验尝试。
- unless：另外一个缓存条件参数，非必需，需使用SpEL表达式。它不同于condition参数的地方在于它的判断时机，该条件是在函数被调用之后才做判断的，所以它可以通过对result进行判断。
- keyGenerator：用于指定key生成器，非必需。若需要指定一个自定义的key生成器，我们需要去实现org.springframework.cache.interceptor.KeyGenerator接口，并使用该参数来指定。需要注意的是：该参数与key是互斥的
- cacheManager：用于指定使用哪个缓存管理器，非必需。只有当有多个时才需要使用
- cacheResolver：用于指定使用那个缓存解析器，非必需。需通过org.springframework.cache.interceptor.CacheResolver接口来实现自己的缓存解析器，并用该参数指定。

除了这里用到的两个注解之外，还有下面几个核心注解：

@CachePut：配置于函数上，能够根据参数定义条件来进行缓存，它与@Cacheable不同的是，它每次都会真是调用函数，所以主要用于数据新增和修改操作上。它的参数与@Cacheable类似，具体功能可参考上面对@Cacheable参数的解析
@CacheEvict
：配置于函数上，通常用在删除方法上，用来从缓存中移除相应数据。除了同
@Cacheable
一样的参数之外，它还有下面两个参数：
- allEntries：非必需，默认为false。当为true时，会移除所有数据
- beforeInvocation：非必需，默认为false，会在调用方法之后移除数据。当为true时，会在调用方法之前移除数据。

4.2、实例代码

package com.vesus.springbootredis.service.impl;

import com.vesus.springbootredis.model.User;
import com.vesus.springbootredis.repository.UserRepository;
import com.vesus.springbootredis.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    UserRepository userRepository ;

    //@Cacheable,如果没有指定key则方法参数作为key保存到缓存中。
    @Cacheable(value = "users")
    public List<User> findAll() {
        return userRepository.findAll();
    }

    //@CachePut缓存新增的或更新的数据到缓存,其中缓存名字是 user 。数据的key是user的id
    @CachePut(value = "user",key = "#user.id")
    public void saveUser(User user) {
        userRepository.save(user);
    }

    @Cacheable(value = "user",key = "#id")
    public User findOne(long id) {
        User user =  userRepository.findOne(id);
        return user ;
    }

    //@CacheEvict 从缓存user中删除key为id 的数据
    @CacheEvict(value = "user",key = "#id")
    public void delete(long id) {

    }

    @Override
    public List<User> findByName(String name) {
        return null;
    }
}

5、编写controller

package com.vesus.springbootredis.controller;

import com.vesus.springbootredis.model.User;
import com.vesus.springbootredis.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class UserController {

    @Autowired
    UserService userService ;

    @RequestMapping(value = "/userlist")
    public List<User> getUserList(){

        return userService.findAll() ;
    }

    @RequestMapping(value = "/save")
    public void saveUser(){
        User user = new User() ;
        user.setId(2);
        user.setName("user2");
        user.setAge(22);
        userService.saveUser(user);
    }

    @RequestMapping(value = "/findbyid")
    public User findById(){

        return userService.findOne(new Long(1));
    }

    @RequestMapping(value = "/delid")
    public void delid(){

        userService.delete(new Long(1));
    }
}

6、访问http://localhost:8080/findbyid

第一次查询数据库

Hibernate: select user0_.t_id as t_id1_0_0_, user0_.t_address as t_addres2_0_0_, user0_.t_age as t_age3_0_0_, user0_.t_name as t_name4_0_0_, user0_.t_pwd as t_pwd5_0_0_ from t_user user0_ where user0_.t_id=?

再次刷新，不访问数据库

访问http://localhost:8080/delid清除缓存，再次访问http://localhost:8080/findbyid查询数据库

源码：https://gitee.com/vesus198/springboot-demo/tree/master/springboot-redis

vesus198

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
spring boot 开发—第五篇SpringDataJPA整合 Redis 实现缓存

对druid项目进行改造，增加redis缓存支持。1、redis简介Redis 是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。Redis 与其他 key - value 缓存产品有以下三个特点：Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。Redis不仅仅支持简单的key-value类型的数据，同时还...
复制链接

扫一扫