完整SpringBoot Cache整合redis缓存（二）

缓存注解概念

名称	解释
cache	缓存接口，定义缓存操作。实现有：rediscache、ehcachecache、concurrentmapcache等
cachemanager	缓存管理器，管理各种缓存（cache）组件
@cacheable	主要针对方法配置，能够根据方法的请求参数对其进行缓存
@cacheevict	清空缓存
@cacheput	保证方法被调用，又希望结果被缓存与@cacheable区别在于是否每次都调用方法，常用于更新
@enablecaching	开启基于注解的缓存
keygenerator	缓存数据时key生成策略
serialize	缓存数据时value序列化策略
@cacheconfig	统一配置本类的缓存注解的属性

安装docker、redis

安装docker

yum -y install docker-ce

 开机启动docker

systemctl start docker

检验docker是否安装成功

docker version

docker安装redis

docker pull redis

docker检测是否安装成功redis

docker images

docker启动redis并设置端口映射（-d表示后台运行）

docker run -p 6379:6379 -d redis:latest myredis

查看redis是否启动成功

docker ps

 代码实现

在看代码前先看看目录结构吧（在这里使用ssm来整合redis）

数据库表结构

pom.xml文件，这里主要是引入spring-boot-starter-cache依赖

<dependencies>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-web</artifactid>
        </dependency>

        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-test</artifactid>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupid>org.projectlombok</groupid>
            <artifactid>lombok</artifactid>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-cache</artifactid>
        </dependency>

        <!-- mybatis 与 spring boot 2.x的整合包 -->
        <dependency>
            <groupid>org.mybatis.spring.boot</groupid>
            <artifactid>mybatis-spring-boot-starter</artifactid>
            <version>1.3.2</version>
        </dependency>

        <!--mysql jdbc驱动 -->
        <dependency>
            <groupid>mysql</groupid>
            <artifactid>mysql-connector-java</artifactid>
            <version>5.1.39</version>
        </dependency>
    </dependencies>

配置文件application.yml，配置redis

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/spring_boot_cache?useunicode=true
    driver-class-name: com.mysql.jdbc.driver
    username: root
    password: lzh

  redis:
    # 这是redis所在服务器的ip
    host: 192.168.126.129
    timeout: 10000ms
    database: 0
    lettuce:
      pool:
        max-wait: -1ms
        max-active: 8
        max-idle: 8
        min-idle: 0
  cache:
    type: redis

启动类加入@enablecaching注解

package com.lzh.springbootstudytestcache;

import org.springframework.boot.springapplication;
import org.springframework.boot.autoconfigure.springbootapplication;
import org.springframework.cache.annotation.enablecaching;

@springbootapplication
@enablecaching
public class springbootstudytestcacheapplication {

    public static void main(string[] args) {
        springapplication.run(springbootstudytestcacheapplication.class, args);
    }
}

usercontroller 类暴露接口

package com.lzh.springbootstudytestcache.controller;

import com.lzh.springbootstudytestcache.model.user;
import com.lzh.springbootstudytestcache.service.userservice;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.web.bind.annotation.getmapping;
import org.springframework.web.bind.annotation.pathvariable;
import org.springframework.web.bind.annotation.requestparam;
import org.springframework.web.bind.annotation.restcontroller;

/**
 * @author lzh
 * create 2019-09-24-20:34
 */
@restcontroller
public class usercontroller {

    @autowired
    userservice userservice;

    @getmapping("/user/save")
    public user saveuser(@requestparam integer id,@requestparam string name,@requestparam integer age){
        user user= userservice.save(new user(id,name,age));
        return user;
    }

    @getmapping("/user/{id}")
    public user getuserbyid(@pathvariable integer id){

        system.out.println("id="+id);
        user user = userservice.finduserbyid(id);

        system.out.println("getuserbyid - "+user);
        return user;
    }

    @getmapping("/user/update")
    public user updateuser(@requestparam integer id,@requestparam string name,@requestparam integer age){
        user user= userservice.updateuser(new user(id,name,age));

        return user;
    }

    @getmapping("/user/del/{id}")
    public string deleteuser(@pathvariable integer id){
        system.out.println("id="+id);
        int num = userservice.deleteuser(id);
        if (num > 0){
            return "删除成功";
        } else {
            return "删除失败";
        }
    }

}

userservice接口

package com.lzh.springbootstudytestcache.service;

import com.lzh.springbootstudytestcache.model.user;

/**
 * @author lzh
 * create 2019-09-24-9:14
 */
public interface userservice {

    user save(user user);

    user finduserbyid(integer id);

    user updateuser(user user);

    int deleteuser(integer id);
}

userservice实现类

package com.lzh.springbootstudytestcache.service.impl;

import com.lzh.springbootstudytestcache.mapper.usermapper;
import com.lzh.springbootstudytestcache.model.user;
import com.lzh.springbootstudytestcache.service.userservice;
import lombok.extern.log4j.log4j2;
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;

/**
 * @author lzh
 * create 2019-09-24-9:14
 */
@service
@log4j2
public class userserviceimpl implements userservice {

    @autowired
    usermapper usermapper;

    @cacheable(value = "user",key = "#user.id")
    @override
    public user save(user user) {
        int savenum = usermapper.saveuser(user);
        system.out.println("savenum="+savenum);
        return user;
    }

    @cacheable(value = "user",key = "#id")
    @override
    public user finduserbyid(integer id) {
        log.info("进入finduserbyid方法");
        return usermapper.finduserbyid(id);
    }

    @cacheput(value = "user", key = "#user.id")
    @override
    public user updateuser(user user) {
        int num = usermapper.updateuser(user);
        system.out.println("num="+num);
        return user;
    }

    @cacheevict(value = "user")
    @override
    public int deleteuser(integer id) {
        return usermapper.deleteuser(id);
    }
}

user实体类，加入@data相当于加入getset方法，@allargsconstructor全参构造方法，@tostring重写tostring方法，引入lombok简化代码

package com.lzh.springbootstudytestcache.model;


import lombok.allargsconstructor;
import lombok.data;
import lombok.tostring;

import java.io.serializable;

/**
 * @author levin
 * @since 2018/5/10 0007
 */
@data
@allargsconstructor
@tostring
public class user implements serializable {

    private integer id;
    private string name;
    private integer age;

}

usermapper持久层，使用mybatis注解@select、@update、@insert、@delete实现

package com.lzh.springbootstudytestcache.mapper;

import com.lzh.springbootstudytestcache.model.user;
import org.apache.ibatis.annotations.*;

/**
 * @author lzh
 * create 2019-09-24-20:39
 */
@mapper
public interface usermapper {


    @select("select * from user where id = #{id}")
    user finduserbyid(integer id);

    @update("update user set name=#{name},age=#{age} where id=#{id}")
    int updateuser(user user);

    @insert("insert into user set name=#{name},age=#{age}")
    int saveuser(user user);

    @delete("delete from user where id=#{id}")
    int deleteuser(integer id);
}

改变默认jdk序列化器

package com.lzh.springbootstudytestcache.config;

import com.fasterxml.jackson.annotation.jsonautodetect;
import com.fasterxml.jackson.annotation.propertyaccessor;
import com.fasterxml.jackson.databind.objectmapper;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
import org.springframework.data.redis.connection.redisconnectionfactory;
import org.springframework.data.redis.core.redistemplate;
import org.springframework.data.redis.serializer.*;

/**
 * @author lzh
 * create 2019-09-24-22:22
 */
import org.springframework.cache.cachemanager;
import org.springframework.context.annotation.primary;
import org.springframework.data.redis.cache.rediscacheconfiguration;
import org.springframework.data.redis.cache.rediscachemanager;
import org.springframework.data.redis.cache.rediscachewriter;

import java.time.duration;

//@configuration
public class myredisconfig {

    //@bean(name = "redistemplate")
    public redistemplate<string,object> redistemplate(redisconnectionfactory redisconnectionfactory){

        redistemplate<string,object> redistemplate = new redistemplate<>();

        redistemplate.setconnectionfactory(redisconnectionfactory);
        redistemplate.setkeyserializer(keyserializer());
        redistemplate.sethashkeyserializer(keyserializer());
        redistemplate.setvalueserializer(valueserializer());
        redistemplate.sethashvalueserializer(valueserializer());
        return redistemplate;
    }

    //@primary
    //@bean
    public cachemanager cachemanager(redisconnectionfactory redisconnectionfactory){
        //缓存配置对象
        rediscacheconfiguration rediscacheconfiguration = rediscacheconfiguration.defaultcacheconfig();

        rediscacheconfiguration = rediscacheconfiguration.entryttl(duration.ofminutes(30l)) //设置缓存的默认超时时间：30分钟
                .disablecachingnullvalues()             //如果是空值，不缓存
                .serializekeyswith(redisserializationcontext.serializationpair.fromserializer(keyserializer()))         //设置key序列化器
                .serializevalueswith(redisserializationcontext.serializationpair.fromserializer((valueserializer())));  //设置value序列化器

        return rediscachemanager
                .builder(rediscachewriter.nonlockingrediscachewriter(redisconnectionfactory))
                .cachedefaults(rediscacheconfiguration).build();
    }


    private redisserializer<string> keyserializer() {
        return new stringredisserializer();
    }

    private redisserializer<object> valueserializer() {
        return new genericjackson2jsonredisserializer();
    }
}

测试

启动srpingboot访问

 使用redis可视化工具查看发现多了一个user对象，这就是在执行查询语句的时候保存的缓存

 看控制台这里打印出了日志，这是第一次查询，说明执行了sql语句

 再次访问，没有执行finduserbyid方法说明没有执行sql语句，而是直接从redis缓存中读取