Spring整合Redis缓存

最新推荐文章于 2024-07-06 18:45:00 发布

lw7551

最新推荐文章于 2024-07-06 18:45:00 发布

阅读量460

点赞数

分类专栏：工具文章标签： spring redis 缓存

本文链接：https://blog.csdn.net/lw7551/article/details/60885057

版权

工具专栏收录该内容

6 篇文章 0 订阅

订阅专栏

通常而言目前的数据库分类有几种，包括 SQL/NSQL,，关系数据库，键值数据库等等等，分类的标准也不以，Redis本质上也是一种键值数据库的，但它在保持键值数据库简单快捷特点的同时，又吸收了部分关系数据库的优点。从而使它的位置处于关系数据库和键值数据库之间。Redis不仅能保存Strings类型的数据，还能保存Lists类型（有序）和Sets类型（无序）的数据，而且还能完成排序（SORT）等高级功能，在实现INCR，SETNX等功能的时候，保证了其操作的原子性，除此以外，还支持主从复制等功能。

现在很流行用redis做缓存，本项目也先简单地将redis缓存整合到SSM项目之中，主要有以下几步:

1.pom.xml中引入jar包

	<!--redis-->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.6.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.8.0</version>
        </dependency>

2.新建spring-redis.xml配置文件

要启用缓存支持，我们需要在spring的配置文件中进行配置。Redis 不是应用的共享内存，它只是一个内存服务器，就像 MySql 似的，我们需要将应用连接到它并使用某种“语言”进行交互，因此我们还需要一个连接工厂以及一个 Spring 和 Redis 对话要用的 RedisTemplate，这些都是 Redis 缓存所必需的配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:cache="http://www.springframework.org/schema/cache"
	xsi:schemaLocation="http://www.springframework.org/schema/beans      
                        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd      
                        http://www.springframework.org/schema/context      
                        http://www.springframework.org/schema/context/spring-context-4.2.xsd      
                        http://www.springframework.org/schema/mvc      
                        http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd  
                        http://www.springframework.org/schema/cache   
                        http://www.springframework.org/schema/cache/spring-cache-4.2.xsd">

	<!-- 缓存的层级-->
 	<context:component-scan base-package="com.lw.common.utils" />
	
	<context:property-placeholder location="classpath:redis.properties" />

	<!-- redis 相关配置 -->
	<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
		<property name="maxIdle" value="${redis.maxIdle}" />
		<property name="maxWaitMillis" value="${redis.maxWait}" />
		<property name="testOnBorrow" value="${redis.testOnBorrow}" />
	</bean>

	<!-- redis单节点数据库连接配置 -->
	<bean id="JedisConnectionFactory"
		class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
		<property name="hostName" value="${redis.host}" />
		<property name="port" value="${redis.port}" />
		<property name="password" value="${redis.pass}" />
		<property name="poolConfig" ref="poolConfig" />
	</bean>

	<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
		<property name="connectionFactory" ref="JedisConnectionFactory" />
	</bean>
</beans>

在 redis.properties中设置了redis服务器的所需的参数：

redis.host=127.0.0.1
redis.port=6379
redis.pass=password
#控制一个pool最多有多少个状态为idle（空闲）的jedis实例
redis.maxIdle=100
redis.maxActive=300
# 表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间(毫秒)，则直接抛出JedisConnectionException；    
redis.maxWait=3000  
# 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的    
redis.testOnBorrow=true

配置完成后将配置文件引入到Spring配置文件中

<!-- 引入同文件夹下的redis属性配置文件 -->
<import resource="spring-redis.xml" />

3.定义redisCache类来实现对redis的操作

package com.lw.common.cache;

import java.util.List;
import java.util.Set;

import javax.annotation.Resource;

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;
import org.springframework.stereotype.Component;


@Component
public class RedisCache {

  public final static String CAHCENAME = "cache";// 缓存名
  public final static int CAHCETIME = 60;// 默认缓存时间

  @Resource
  private RedisTemplate
    
    
     
      redisTemplate;
//  private SimpleCacheManager cacheManager;

  public 
     
     
      
       boolean putCache(String key, T obj) {
   final byte[] bkey = key.getBytes();
   final byte[] bvalue = ProtoStuffSerializerUtil.serialize(obj);
   boolean result = redisTemplate.execute(new RedisCallback
      
      
       
       () {
    @Override
    public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
     return connection.setNX(bkey, bvalue);
    }
   });
   return result;
  }

  public 
       
       
        
         void putCacheWithExpireTime(String key, T obj, final long expireTime) {
   final byte[] bkey = key.getBytes();
   final byte[] bvalue = ProtoStuffSerializerUtil.serialize(obj);
   redisTemplate.execute(new RedisCallback
        
        
          () { @Override public Boolean doInRedis(RedisConnection connection) throws DataAccessException { connection.setEx(bkey, expireTime, bvalue); return true; } }); } public 
         
           boolean putListCache(String key, List 
          
            objList) { final byte[] bkey = key.getBytes(); final byte[] bvalue = ProtoStuffSerializerUtil.serializeList(objList); boolean result = redisTemplate.execute(new RedisCallback 
           
             () { @Override public Boolean doInRedis(RedisConnection connection) throws DataAccessException { return connection.setNX(bkey, bvalue); } }); return result; } public 
            
              boolean putListCacheWithExpireTime(String key, List 
             
               objList, final long expireTime) { final byte[] bkey = key.getBytes(); final byte[] bvalue = ProtoStuffSerializerUtil.serializeList(objList); boolean result = redisTemplate.execute(new RedisCallback 
              
                () { @Override public Boolean doInRedis(RedisConnection connection) throws DataAccessException { connection.setEx(bkey, expireTime, bvalue); return true; } }); return result; } public 
               
                 T getCache(final String key, Class 
                
                  targetClass) { byte[] result = redisTemplate.execute(new RedisCallback 
                 
                   () { @Override public byte[] doInRedis(RedisConnection connection) throws DataAccessException { return connection.get(key.getBytes()); } }); if (result == null) { return null; } return ProtoStuffSerializerUtil.deserialize(result, targetClass); } public 
                  
                    List 
                   
                     getListCache(final String key, Class 
                    
                      targetClass) { byte[] result = redisTemplate.execute(new RedisCallback 
                     
                       () { @Override public byte[] doInRedis(RedisConnection connection) throws DataAccessException { return connection.get(key.getBytes()); } }); if (result == null) { return null; } return ProtoStuffSerializerUtil.deserializeList(result, targetClass); } /** * 精确删除key * * @param key */ public void deleteCache(String key) { redisTemplate.delete(key); } /** * 模糊删除key * * @param pattern */ public void deleteCacheWithPattern(String pattern) { Set 
                      
                        keys = redisTemplate.keys(pattern); redisTemplate.delete(keys); } /** * 清空所有缓存 */ public void clearCache() { deleteCacheWithPattern(RedisCache.CAHCENAME+"|*"); } }

其中ProtoStuffSerializerUtil为一个序列化和反序列化对象的工具类

package com.lw.common.utils;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.List;

import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtostuffIOUtil;
import com.dyuproject.protostuff.Schema;
import com.dyuproject.protostuff.runtime.RuntimeSchema;

/**
 * 序列话工具
 */
public class ProtoStuffSerializerUtil {

	/**
	 * 序列化对象
	 * @param obj
	 * @return
	 */
	public static 
     
     
      
       byte[] serialize(T obj) {
		if (obj == null) {
			throw new RuntimeException("序列化对象(" + obj + ")!");
		}
		@SuppressWarnings("unchecked")
		Schema
      
      
       
        schema = (Schema
       
       
        
        ) RuntimeSchema.getSchema(obj.getClass());
		LinkedBuffer buffer = LinkedBuffer.allocate(1024 * 1024);
		byte[] protostuff = null;
		try {
			protostuff = ProtostuffIOUtil.toByteArray(obj, schema, buffer);
		} catch (Exception e) {
			throw new RuntimeException("序列化(" + obj.getClass() + ")对象(" + obj + ")发生异常!", e);
		} finally {
			buffer.clear();
		}
		return protostuff;
	}

	/**
	 * 反序列化对象
	 * @param paramArrayOfByte
	 * @param targetClass
	 * @return
	 */
	public static 
        
        
         
          T deserialize(byte[] paramArrayOfByte, Class
         
         
           targetClass) { if (paramArrayOfByte == null || paramArrayOfByte.length == 0) { throw new RuntimeException("反序列化对象发生异常,byte序列为空!"); } T instance = null; try { instance = targetClass.newInstance(); } catch (InstantiationException | IllegalAccessException e) { throw new RuntimeException("反序列化过程中依据类型创建对象失败!", e); } Schema 
          
            schema = RuntimeSchema.getSchema(targetClass); ProtostuffIOUtil.mergeFrom(paramArrayOfByte, instance, schema); return instance; } /** * 序列化列表 * @param objList * @return */ public static 
           
             byte[] serializeList(List 
            
              objList) { if (objList == null || objList.isEmpty()) { throw new RuntimeException("序列化对象列表(" + objList + ")参数异常!"); } @SuppressWarnings("unchecked") Schema 
             
               schema = (Schema 
              
                ) RuntimeSchema.getSchema(objList.get(0).getClass()); LinkedBuffer buffer = LinkedBuffer.allocate(1024 * 1024); byte[] protostuff = null; ByteArrayOutputStream bos = null; try { bos = new ByteArrayOutputStream(); ProtostuffIOUtil.writeListTo(bos, objList, schema, buffer); protostuff = bos.toByteArray(); } catch (Exception e) { throw new RuntimeException("序列化对象列表(" + objList + ")发生异常!", e); } finally { buffer.clear(); try { if (bos != null) { bos.close(); } } catch (IOException e) { e.printStackTrace(); } } return protostuff; } /** * 反序列化列表 * @param paramArrayOfByte * @param targetClass * @return */ public static 
               
                 List 
                
                  deserializeList(byte[] paramArrayOfByte, Class 
                 
                   targetClass) { if (paramArrayOfByte == null || paramArrayOfByte.length == 0) { throw new RuntimeException("反序列化对象发生异常,byte序列为空!"); } Schema 
                  
                    schema = RuntimeSchema.getSchema(targetClass); List 
                   
                     result = null; try { result = ProtostuffIOUtil.parseListFrom(new ByteArrayInputStream(paramArrayOfByte), schema); } catch (IOException e) { throw new RuntimeException("反序列化对象列表发生异常!", e); } return result; } }

工具类又需要引入额外的jar包

<dependency>
	<groupId>com.dyuproject.protostuff</groupId>
	<artifactId>protostuff-core</artifactId>
	<version>1.0.8</version>
</dependency>

<dependency>
	<groupId>com.dyuproject.protostuff</groupId>
	<artifactId>protostuff-runtime</artifactId>
	<version>1.0.8</version>
</dependency>

至此Spring整合redis缓存的配置工作便准备完成，下面便可在service层使用

package com.lw.service;

import javax.annotation.Resource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import com.lw.common.utils.RedisCache;
import com.lw.dao.UserMapper;
import com.lw.entity.User;

@Service
public class UserService {
  
  private static final Logger log = LoggerFactory.getLogger(UserService.class);
  
  @Resource
  private UserMapper userMapper;
  @Resource
  private RedisCache redisCache;
  
  public User getUserById(int userId) {
    String cache_key = RedisCache.CAHCENAME+"|getUserById"+userId;
    User user = redisCache.getCache(cache_key, User.class);
    if(user != null){
      log.info("get cache with key:"+cache_key);
    }else {
      user = userMapper.selectByPrimaryKey(userId);
      redisCache.putCacheWithExpireTime(cache_key, user, RedisCache.CAHCETIME);
      log.info("put cache with key:"+cache_key);
    }
    return user;
  }
}

当系统获取用户信息时，先从缓存中查找，如果缓存中由数据便直接返回，如果没有便从数据库中获取，并将结果存入到缓存中。