前言：

本文纯手打，为了方便大家亲手操作，所以包含大量源代码，手机阅读请多包涵！

上回给大家分享了springboot框架之redis（单机+集群）实现mybatis缓存，上次的缓存是基于dao持久层的缓存本次我带着大家来搭建一个基于sercice层的缓存，对于缓存放在dao层还是service层，这个问题众说纷纭，我本人倾向于放到service层，因为从软件解耦的观点来说，dao层的实现技术并不局限于mybatis，还有可能是springJDBC，hibrenate等，所以本次我们在service层上加入缓存。

1. redis（单机版）实现spring缓存

1.1. 环境准备

使用maven搭建一套springBoot框架，并创建测试类查询userinfo表。测试代码如下：

/**

* @不开启springCache

*/

@RequestMapping("/findAllUserByJson")

@ResponseBody

public List<Map> findAllUserByJson() {

long start=System.currentTimeMillis();

List<Map> findAllUser = userInfoBizImpl.findAllUser();

long end=System.currentTimeMillis();

System.out.println("查询时间："+(end-start));

// 将findAllUser转成json字符串

return findAllUser;

}

结果截图：

1.2. 配置spring缓存

1) 修改配置文件pom.xml

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-data-redis</artifactId>

<version>1.5.8.RELEASE</version>

</dependency>

<dependency>

<groupId>redis.clients</groupId>

<artifactId>jedis</artifactId>

<version>2.9.0</version>

</dependency>

2) 修改RedisConfig配置类

/**

* 配置redis模版 ,来操作redis服务器

*TODO

*@return

*2018-7-11下午4:06:14

*/

@Bean(name = "redisTemplate")

public RedisTemplate getRedisTemplate(){

RedisTemplate template = new StringRedisTemplate(getJedisConnectionFactory());

return template;

}

/**

* 配置springcacheManager 缓存管理器

*TODO

*@return

*2018-7-11下午4:09:54

*/

@Bean

public SimpleCacheManager getMyCacheManager() {

SimpleCacheManager simpleCacheManager = new SimpleCacheManager();

Set<Cache> caches= new HashSet<Cache>();

// 初始化cache

SpringRedisCache cache = new SpringRedisCache();

cache.setName("chenjian");

cache.setRedisTemplate(getRedisTemplate());

caches.add(cache);

simpleCacheManager.setCaches(caches);

return simpleCacheManager;

}

SpringRedisCache实现org.springframework.cache.Cache;接口

package com.aaa.util;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.util.concurrent.Callable;

import org.springframework.cache.Cache;

import org.springframework.cache.support.SimpleValueWrapper;

import org.springframework.dao.DataAccessException;

import org.springframework.data.redis.connection.RedisConnection;

import org.springframework.data.redis.core.RedisCallback;

import org.springframework.data.redis.core.RedisTemplate;

/**

* @author TeacherChen

* @description springcache的实现类

* @company AAA软件

* 2018-1-13下午2:07:15

*/

public class SpringRedisCache implements Cache {

private RedisTemplate<String, Object> redisTemplate;

private String name;

public RedisTemplate<String, Object> getRedisTemplate() {

return redisTemplate;

}

public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {

this.redisTemplate = redisTemplate;

}

public void setName(String name) {

this.name = name;

}

@Override

public String getName() {

// TODO Auto-generated method stub

return this.name;

}

@Override

public Object getNativeCache() {

// TODO Auto-generated method stub

return this.redisTemplate;

}

@Override

public ValueWrapper get(Object key) {

// TODO Auto-generated method stub

System.out.println("get key");

final String keyf = key.toString();

Object object = null;

object = redisTemplate.execute(new RedisCallback<Object>() {

public Object doInRedis(RedisConnection connection)

throws DataAccessException {

byte[] key = keyf.getBytes();

byte[] value = connection.get(key);

if (value == null) {

return null;

}

return toObject(value);

}

});

return (object != null ? new SimpleValueWrapper(object) : null);

}

@Override

public void put(Object key, Object value) {

// TODO Auto-generated method stub

System.out.println("put key");

final String keyf = key.toString();

final Object valuef = value;

final long liveTime = 86400;

redisTemplate.execute(new RedisCallback<Long>() {

public Long doInRedis(RedisConnection connection)

throws DataAccessException {

byte[] keyb = keyf.getBytes();

byte[] valueb = toByteArray(valuef);

connection.set(keyb, valueb);

if (liveTime > 0) {

connection.expire(keyb, liveTime);

}

return 1L;

}

});

}

private byte[] toByteArray(Object obj) {

byte[] bytes = null;

ByteArrayOutputStream bos = new ByteArrayOutputStream();

try {

ObjectOutputStream oos = new ObjectOutputStream(bos);

oos.writeObject(obj);

oos.flush();

bytes = bos.toByteArray();

oos.close();

bos.close();

} catch (IOException ex) {

ex.printStackTrace();

}

return bytes;

}

private Object toObject(byte[] bytes) {

Object obj = null;

try {

ByteArrayInputStream bis = new ByteArrayInputStream(bytes);

ObjectInputStream ois = new ObjectInputStream(bis);

obj = ois.readObject();

ois.close();

bis.close();

} catch (IOException ex) {

ex.printStackTrace();

} catch (ClassNotFoundException ex) {

ex.printStackTrace();

}

return obj;

}

@Override

public void evict(Object key) {

// TODO Auto-generated method stub

System.out.println("del key");

final String keyf = key.toString();

redisTemplate.execute(new RedisCallback<Long>() {

public Long doInRedis(RedisConnection connection)

throws DataAccessException {

return connection.del(keyf.getBytes());

}

});

}

@Override

public void clear() {

// TODO Auto-generated method stub

System.out.println("clear key");

redisTemplate.execute(new RedisCallback<String>() {

public String doInRedis(RedisConnection connection)

throws DataAccessException {

connection.flushDb();

return "ok";

}

});

}

@Override

public <T> T get(Object key, Class<T> type) {

// TODO Auto-generated method stub

return null;

}

@Override

public <T> T get(Object arg0, Callable<T> arg1) {

// TODO Auto-generated method stub

return null;

}

@Override

public ValueWrapper putIfAbsent(Object arg0, Object arg1) {

// TODO Auto-generated method stub

return null;

}

}

3) 开启springcache注解

4) 在service实现类上添加注解

要在需要缓存的方法或者类上加缓存注解

spring缓存注解@Cacheable

可以标记在一个方法上，也可以标记在一个类上。当标记在一个方法上时表示该方法是支持缓存的，当标记在一个类上时则表示该类所有的方法都是支持缓存的（value key condition)

value属性是必须指定的，其表示当前方法的返回值是会被缓存在哪个Cache上的，对应Cache的名称。其可以是一个Cache也可以是多个Cache，当需要指定多个Cache时其是一个数组。

key属性是用来指定Spring缓存方法的返回结果时对应的key的。该属性支持SpringEL表达式。当我们没有指定该属性时，Spring将使用默认策略生成key。

/**

* 查询所有用户，@Cacheable代表将返回信息放入缓存，缓存名称为"chenjian"的缓存

*/

@Cacheable(value="chenjian")

@Override

public List<Map> findAllUser() {

return userInfoDao.findAllUser();

}

condition有的时候我们可能并不希望缓存一个方法所有的返回结果。通过condition属性可以实现这一功能。condition属性默认为空，表示将缓存所有的调用情形。其值是通过SpringEL表达式来指定的，当为true时表示进行缓存处理；当为false时表示不进行缓存处理，即每次调用该方法时该方法都会执行一次。如下示例表示只有当empno为偶数时才会进行缓存。

/**

* 按照用户id来查询

*TODO key="#id"使用id作为redis缓存key，condition="#id%2==0"代表至缓存id为偶数的数据

*@return

*2018-7-11下午4:28:32

*/

@Cacheable(value="chenjian",key="#id",condition="#id%2==0")

@Override

public UserInfo findUserById(Integer id) {

return userInfoDao.findUserById(id);

}

5) spring缓存注解@CacheEvict

是用来标注在需要清除缓存元素的方法或类上的。当标记在一个类上时表示其中所有的方法的执行都会触发缓存的清除操作

/**

* 根据id删除员工

* CacheEvict能够实时刷新缓存中的数据

*/

@CacheEvict(value="chenjian",key="#id")

@Override

public int deleteUserById(Integer id) {

return userInfoDao.deleteUserById(id);

}

6) spring缓存注解@CachePut

CachePut也可以声明一个方法支持缓存功能。与@Cacheable不同的是使用@CachePut标注的方法在执行前不会去检查缓存中是否存在之前执行过的结果，而是每次都会执行该方法，并将执行结果以键值对的形式存入指定的缓存中。

/**

* 修改员工信息，并同步更新缓存中的员工信息

* @CachePut不管缓存中有没有，没有的话放入缓存，有的话替换缓存

*/

@CachePut(value="chenjian",key="#user.id")

@Override

public UserInfo editUser(UserInfo user) {

userInfoDao.editUser(user);

return user;

}

测试步骤，

首先不加@CachePut(value="chenjian",key="#user.id")

，查询一条数据，这条数据自动缓存到redis，然后修改这条数据，再次查询数据库变化，缓存不变，查询的结果不对。

加上@CachePut(value="chenjian",key="#user.id")

，再次修改同一条数据，查询发现数据库和缓存同步修改。

2. redis（集群版）实现spring缓存

2.1. 修改配置类RedisConfig

@Bean(name = "redisTemplate")

public RedisTemplate getRedisTemplate(){

RedisTemplate template = new StringRedisTemplate(getJedisConnectionFactory());

return template;

}

/**

* 创建redis集群配置信息

*

*/

/*@Bean

public RedisClusterConfiguration getRedisClusterConfiguration() {

RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();

redisClusterConfiguration.setMaxRedirects(3);

Set<RedisNode> nodes= new HashSet<RedisNode>();

// 初始化集群节点

for (int i = 7001; i < 7007; i++) {

RedisNode redisNode= new RedisNode(hostName,i);

nodes.add(redisNode);

}

redisClusterConfiguration.setClusterNodes(nodes);

return redisClusterConfiguration;

}*/

/**

* 创建Spring-redis连接池管理工厂 类（bean）(集群版)

*TODO

*@return

*2018-7-11下午1:56:23

*/

/*@Bean

public JedisConnectionFactory getJedisConnectionFactory() {

//构造注入集群信息clusterConfig和redis poolconfig

JedisConnectionFactory jedisConnectionFactory= new JedisConnectionFactory(getRedisClusterConfiguration(),getPoolConfig());

return jedisConnectionFactory;

}*/

本文使用的技术在之前的文章内都有讲过，包括：

redis集群：

建哥手把手系列之30分钟搞定动态添加删除redis集群节点

建哥手把手系列之30分钟搞定动态添加删除redis集群节点

springboot入门：

SpringBoot快速入门及整合mybatis

SpringBoot快速入门及整合mybatis

springMVC版缓存：

redis之30分钟搞定mybatis缓存（单机+集群）

redis之30分钟搞定mybatis缓存（单机+集群）

redis之20分钟轻松搞定springCache缓存（单机+集群）

redis之20分钟轻松搞定springCache缓存（单机+集群）

本文配套有代码和笔记以及高清视频，如有需要请关注我，私信发送关键字“视频”，必回！