zoukankan      html  css  js  c++  java
  • Spring Boot 整合Redis 实现缓存

     

     
    本文提纲
    一、缓存的应用场景
    二、更新缓存的策略
    三、运行 springboot-mybatis-redis 工程案例
    四、springboot-mybatis-redis 工程代码配置详解
     
    运行环境
    Mac OS 10.12.x
    JDK 8 +
    Redis 3.2.8
    Spring Boot 1.5.1.RELEASE
     

    一、缓存的应用场景

    什么是缓存?
    在互联网场景下,尤其 2C 端大流量场景下,需要将一些经常展现和不会频繁变更的数据,存放在存取速率更快的地方。缓存就是一个存储器,在技术选型中,常用 Redis 作为缓存数据库。缓存主要是在获取资源方便性能优化的关键方面。
     
    Redis 是一个高性能的 key-value 数据库。GitHub 地址:https://github.com/antirez/redis 。Github 是这么描述的:
    Redis is an in-memory database that persists on disk. The data model is key-value, but many different kind of values are supported: Strings, Lists, Sets, Sorted Sets, Hashes, HyperLogLogs, Bitmaps.
     
    缓存的应用场景有哪些呢?
    比如常见的电商场景,根据商品 ID 获取商品信息时,店铺信息和商品详情信息就可以缓存在 Redis,直接从 Redis 获取。减少了去数据库查询的次数。但会出现新的问题,就是如何对缓存进行更新?这就是下面要讲的。
     

    二、更新缓存的策略

    参考《缓存更新的套路》http://coolshell.cn/articles/17416.html,缓存更新的模式有四种:Cache aside, Read through, Write through, Write behind caching。
     
    这里我们使用的是 Cache Aside 策略,从三个维度:(摘自 耗子叔叔博客)
    失效:应用程序先从cache取数据,没有得到,则从数据库中取数据,成功后,放到缓存中。
    命中:应用程序从cache中取数据,取到后返回。
    更新:先把数据存到数据库中,成功后,再让缓存失效。
     
    大致流程如下:
    获取商品详情举例
    a. 从商品 Cache 中获取商品详情,如果存在,则返回获取 Cache 数据返回。
    b. 如果不存在,则从商品 DB 中获取。获取成功后,将数据存到 Cache 中。则下次获取商品详情,就可以从 Cache 就可以得到商品详情数据。
    c. 从商品 DB 中更新或者删除商品详情成功后,则从缓存中删除对应商品的详情缓存
     
     

    三、运行 springboot-mybatis-redis 工程案例

     
    git clone 下载工程 springboot-learning-example ,项目地址见 GitHub – https://github.com/JeffLi1993/springboot-learning-example
     
    下面开始运行工程步骤(Quick Start):
     
    1.数据库和 Redis 准备
    a.创建数据库 springbootdb:
    1
    CREATE DATABASE springbootdb;
     
    b.创建表 city :(因为我喜欢徒步)
    1
    2
    3
    4
    5
    6
    7
    8
    DROP TABLE IF EXISTS  `city`;
    CREATE TABLE `city` (
      `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '城市编号',
      `province_id` int(10) unsigned  NOT NULL COMMENT '省份编号',
      `city_name` varchar(25) DEFAULT NULL COMMENT '城市名称',
      `description` varchar(25) DEFAULT NULL COMMENT '描述',
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
     
    c.插入数据
    1
    INSERT city VALUES (1 ,1,'温岭市','BYSocket 的家在温岭。');
     
    d.本地安装 Redis
    详见写过的文章《 Redis 安装 》http://www.bysocket.com/?p=917
     
    2. springboot-mybatis-redis 工程项目结构介绍
    1
    2
    3
    4
    5
    6
    7
    springboot-mybatis-redis 工程项目结构如下图所示:
    org.spring.springboot.controller - Controller 层
    org.spring.springboot.dao - 数据操作层 DAO
    org.spring.springboot.domain - 实体类
    org.spring.springboot.service - 业务逻辑层
    Application - 应用启动类
    application.properties - 应用配置文件,应用启动会自动读取配置
     
    3.改数据库配置
    打开 application.properties 文件, 修改相应的数据源配置,比如数据源地址、账号、密码等。
    (如果不是用 MySQL,自行添加连接驱动 pom,然后修改驱动名配置。)
     
    4.编译工程
    在项目根目录 springboot-learning-example,运行 maven 指令:
    1
    mvn clean install
     
    5.运行工程
    右键运行 springboot-mybatis-redis 工程 Application 应用启动类的 main 函数。
     
    项目运行成功后,这是个 HTTP OVER JSON 服务项目。所以用 postman 工具可以如下操作
    根据 ID,获取城市信息
    GET http://127.0.0.1:8080/api/city/1
    再请求一次,获取城市信息会发现数据获取的耗时快了很多。服务端 Console 输出的日志:
    1
    2
    2017-04-13 18:29:00.273  INFO 13038 --- [nio-8080-exec-1] o.s.s.service.impl.CityServiceImpl       : CityServiceImpl.findCityById() : 城市插入缓存 >> City{id=12, provinceId=3, cityName='三亚', description='水好,天蓝'}
    2017-04-13 18:29:03.145  INFO 13038 --- [nio-8080-exec-2] o.s.s.service.impl.CityServiceImpl       : CityServiceImpl.findCityById() : 从缓存中获取了城市 >> City{id=12, provinceId=3, cityName='三亚', description='水好,天蓝'}
    可见,第一次是从数据库 DB 获取数据,并插入缓存,第二次直接从缓存中取。
     
    更新城市信息
    PUT http://127.0.0.1:8080/api/city
    删除城市信息
    DELETE http://127.0.0.1:8080/api/city/2
    这两种操作中,如果缓存有对应的数据,则删除缓存。服务端 Console 输出的日志:
    1
    2017-04-13 18:29:52.248  INFO 13038 --- [nio-8080-exec-9] o.s.s.service.impl.CityServiceImpl       : CityServiceImpl.deleteCity() : 从缓存中删除城市 ID >> 12
     

    四、springboot-mybatis-redis 工程代码配置详解

    这里,我强烈推荐 注解 的方式实现对象的缓存。但是这里为了更好说明缓存更新策略。下面讲讲工程代码的实现。
     
    pom.xml 依赖配置:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    <?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>springboot</groupId>
        <artifactId>springboot-mybatis-redis</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>springboot-mybatis-redis :: 整合 Mybatis 并使用 Redis 作为缓存</name>
     
        <!-- Spring Boot 启动父依赖 -->
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>1.5.1.RELEASE</version>
        </parent>
     
        <properties>
            <mybatis-spring-boot>1.2.0</mybatis-spring-boot>
            <mysql-connector>5.1.39</mysql-connector>
            <spring-boot-starter-redis-version>1.3.2.RELEASE</spring-boot-starter-redis-version>
        </properties>
     
        <dependencies>
     
            <!-- Spring Boot Reids 依赖 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-redis</artifactId>
                <version>${spring-boot-starter-redis-version}</version>
            </dependency>
     
            <!-- Spring Boot Web 依赖 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
     
            <!-- Spring Boot Test 依赖 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
     
            <!-- Spring Boot Mybatis 依赖 -->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis-spring-boot}</version>
            </dependency>
     
            <!-- MySQL 连接驱动依赖 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql-connector}</version>
            </dependency>
     
            <!-- Junit -->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
            </dependency>
        </dependencies>
    </project>
    包括了 Spring Boot Reids 依赖、 MySQL 依赖和 Mybatis 依赖。
     
     
    在 application.properties 应用配置文件,增加 Redis 相关配置
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    ## 数据源配置
    spring.datasource.url=jdbc:mysql://localhost:3306/springbootdb?useUnicode=true&characterEncoding=utf8
    spring.datasource.username=root
    spring.datasource.password=123456
    spring.datasource.driver-class-name=com.mysql.jdbc.Driver
     
    ## Mybatis 配置
    mybatis.typeAliasesPackage=org.spring.springboot.domain
    mybatis.mapperLocations=classpath:mapper/*.xml
     
    ## Redis 配置
    ## Redis数据库索引(默认为0)
    spring.redis.database=0
    ## Redis服务器地址
    spring.redis.host=127.0.0.1
    ## Redis服务器连接端口
    spring.redis.port=6379
    ## Redis服务器连接密码(默认为空)
    spring.redis.password=
    ## 连接池最大连接数(使用负值表示没有限制)
    spring.redis.pool.max-active=8
    ## 连接池最大阻塞等待时间(使用负值表示没有限制)
    spring.redis.pool.max-wait=-1
    ## 连接池中的最大空闲连接
    spring.redis.pool.max-idle=8
    ## 连接池中的最小空闲连接
    spring.redis.pool.min-idle=0
    ## 连接超时时间(毫秒)
    spring.redis.timeout=0
     
    详细解释可以参考注释。对应的配置类:org.springframework.boot.autoconfigure.data.redis.RedisProperties
     
    CityRestController 控制层依旧是 Restful 风格的,详情可以参考《Springboot 实现 Restful 服务,基于 HTTP / JSON 传输》。 http://www.bysocket.com/?p=1627 domain 对象 City 必须实现序列化,因为需要将对象序列化后存储到 Redis。如果没实现 Serializable ,控制台会爆出以下异常:
     
    1
    2
    Serializable
    java.lang.IllegalArgumentException: DefaultSerializer requires a Serializable payload but received an object of type
     
    City.java 城市对象:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    package org.spring.springboot.domain;
     
    import java.io.Serializable;
     
    /**
     * 城市实体类
     *
     * Created by bysocket on 07/02/2017.
     */
    public class City implements Serializable {
     
        private static final long serialVersionUID = -1L;
     
        /**
         * 城市编号
         */
        private Long id;
     
        /**
         * 省份编号
         */
        private Long provinceId;
     
        /**
         * 城市名称
         */
        private String cityName;
     
        /**
         * 描述
         */
        private String description;
     
        public Long getId() {
            return id;
        }
     
        public void setId(Long id) {
            this.id = id;
        }
     
        public Long getProvinceId() {
            return provinceId;
        }
     
        public void setProvinceId(Long provinceId) {
            this.provinceId = provinceId;
        }
     
        public String getCityName() {
            return cityName;
        }
     
        public void setCityName(String cityName) {
            this.cityName = cityName;
        }
     
        public String getDescription() {
            return description;
        }
     
        public void setDescription(String description) {
            this.description = description;
        }
     
        @Override
        public String toString() {
            return "City{" +
                    "id=" + id +
                    ", provinceId=" + provinceId +
                    ", cityName='" + cityName + ''' +
                    ", description='" + description + ''' +
                    '}';
        }
    }
     
    如果需要自定义序列化实现,只要实现 RedisSerializer 接口去实现即可,然后在使用 RedisTemplate.setValueSerializer 方法去设置你实现的序列化实现。
     
    主要还是城市业务逻辑实现类 CityServiceImpl.java:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    package org.spring.springboot.service.impl;
     
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.spring.springboot.dao.CityDao;
    import org.spring.springboot.domain.City;
    import org.spring.springboot.service.CityService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.data.redis.core.ValueOperations;
    import org.springframework.stereotype.Service;
     
    import java.util.List;
    import java.util.concurrent.TimeUnit;
     
    /**
     * 城市业务逻辑实现类
     * <p>
     * Created by bysocket on 07/02/2017.
     */
    @Service
    public class CityServiceImpl implements CityService {
     
        private static final Logger LOGGER = LoggerFactory.getLogger(CityServiceImpl.class);
     
        @Autowired
        private CityDao cityDao;
     
        @Autowired
        private RedisTemplate redisTemplate;
     
        /**
         * 获取城市逻辑:
         * 如果缓存存在,从缓存中获取城市信息
         * 如果缓存不存在,从 DB 中获取城市信息,然后插入缓存
         */
        public City findCityById(Long id) {
            // 从缓存中获取城市信息
            String key = "city_" + id;
            ValueOperations<String, City> operations = redisTemplate.opsForValue();
     
            // 缓存存在
            boolean hasKey = redisTemplate.hasKey(key);
            if (hasKey) {
                City city = operations.get(key);
     
                LOGGER.info("CityServiceImpl.findCityById() : 从缓存中获取了城市 >> " + city.toString());
                return city;
            }
     
            // 从 DB 中获取城市信息
            City city = cityDao.findById(id);
     
            // 插入缓存
            operations.set(key, city, 10, TimeUnit.SECONDS);
            LOGGER.info("CityServiceImpl.findCityById() : 城市插入缓存 >> " + city.toString());
     
            return city;
        }
     
        @Override
        public Long saveCity(City city) {
            return cityDao.saveCity(city);
        }
     
        /**
         * 更新城市逻辑:
         * 如果缓存存在,删除
         * 如果缓存不存在,不操作
         */
        @Override
        public Long updateCity(City city) {
            Long ret = cityDao.updateCity(city);
     
            // 缓存存在,删除缓存
            String key = "city_" + city.getId();
            boolean hasKey = redisTemplate.hasKey(key);
            if (hasKey) {
                redisTemplate.delete(key);
     
                LOGGER.info("CityServiceImpl.updateCity() : 从缓存中删除城市 >> " + city.toString());
            }
     
            return ret;
        }
     
        @Override
        public Long deleteCity(Long id) {
     
            Long ret = cityDao.deleteCity(id);
     
            // 缓存存在,删除缓存
            String key = "city_" + id;
            boolean hasKey = redisTemplate.hasKey(key);
            if (hasKey) {
                redisTemplate.delete(key);
     
                LOGGER.info("CityServiceImpl.deleteCity() : 从缓存中删除城市 ID >> " + id);
            }
            return ret;
        }
     
    }
     
    首先这里注入了 RedisTemplate 对象。联想到 Spring 的 JdbcTemplate ,RedisTemplate 封装了 RedisConnection,具有连接管理,序列化和 Redis 操作等功能。还有针对 String 的支持对象 StringRedisTemplate。
    Redis 操作视图接口类用的是 ValueOperations,对应的是 Redis String/Value 操作。还有其他的操作视图,ListOperations、SetOperations、ZSetOperations 和 HashOperations 。ValueOperations 插入缓存是可以设置失效时间,这里设置的失效时间是 10 s。
     
    回到更新缓存的逻辑
    a. findCityById 获取城市逻辑:
    如果缓存存在,从缓存中获取城市信息
    如果缓存不存在,从 DB 中获取城市信息,然后插入缓存
     
    b. deleteCity 删除 / updateCity 更新城市逻辑:
    如果缓存存在,删除
    如果缓存不存在,不操作
     
    其他不明白的,可以 git clone 下载工程 springboot-learning-example ,工程代码注解很详细。 https://github.com/JeffLi1993/springboot-learning-example。
     

    五、小结

    本文涉及到 Spring Boot 在使用 Redis 缓存时,一个是缓存对象需要序列化,二个是缓存更新策略是如何的。
  • 相关阅读:
    Logstash使用mongodb插件报错: ArgumentError: wrong number of arguments (given 2, expected 1)
    Vim注释行的方法
    设计模式之单例模式
    ssh命令的常用使用场景
    Flask 和Django
    Git 常用命令大全
    实例 静态 类
    python的各种推导式(列表推导式、字典推导式、集合推导式)
    MongoDB
    MySql变量说明
  • 原文地址:https://www.cnblogs.com/Soy-technology/p/11025089.html
Copyright © 2011-2022 走看看