关于如何在ssm项目中加入redis缓存

这两天主管让我给官网加上redis缓存因为原来打开页面太慢了，原来也没接触过redis所以花了两天走了不少弯路，为免忘记，在这记录一下。提醒一下这是我redis安装完成且配置了密码和服务为前提做的操作，没有安装redis的先安装redis。我也在另一篇写一下怎么安装redis吧。

首先要在项目中添加依赖jar包，我项目用的maven管理所以直接在pom里添加了如下代码，如果没用maven，jar包就要自己去下载。

<!-- 添加对redis依赖 -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.6.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.7.3</version>
        </dependency>
        <dependency>
            <groupId>commons-pool</groupId>
            <artifactId>commons-pool</artifactId>
            <version>1.5.6</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.4.2</version>
        </dependency>

网上大部分都只说要前两个jar包，但是我原来一直报错，后来找到说还要后两个jar包，项目完成后我试过删了后两个jar包启动立马报错……

接下来新建一个redis.properties文件保存配置参数，我的配置如下：

redis.host=localhost
redis.port=6379
redis.password=redis
redis.timeout=100000

redis.maxIdle=100
redis.maxActive=300
redis.maxWait=1000
redis.testOnBorrow=true

然后在applicationContext.xml文件中进行配置：

<!-- 读取redis配置文件 -->
    <context:property-placeholder location="classpath:redis.properties" file-encoding="UTF-8" ignore-unresolvable="true"/>
    
    <!-- jedis 配置 -->  
    <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="connectionFactory"  class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" >  
         <property name="poolConfig" ref="poolConfig" />  
         <property name="port" value="${redis.port}" />  
         <property name="hostName" value="${redis.host}" />  
         <property name="password" value="${redis.password}" />  
         <property name="timeout" value="${redis.timeout}" ></property>  
    </bean >  
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" >  
         <property name="connectionFactory" ref="connectionFactory" />  
         <property name="keySerializer" >  
             <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />  
         </property>  
         <property name="valueSerializer" >  
             <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />  
         </property>  
    </bean >
    
    <!-- redis工具类 -->
    <bean id="redisUtil" class="com.haylion.util.RedisUtil"></bean>

ignore-unresolvable="true"属性是我还读取了别的properties文件所以加的，而且另外那个读取properties文件的标签也要加这个属性。最后的RedisUtil是我建的工具类所以接下来建一个工具类RedisUtil，内容如下：

/**
 * 操作redis缓存的工具类
 * 部分方法未验证正确性
 */

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

@Component
public final class RedisUtil {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    
    /**
     * 写入缓存
     * 
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<String, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            System.out.println("set cache error");
        }
        return result;
    }
    
    /**
     * 读取缓存
     * 
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<String, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }
    
    /**
     * 删除对应的value
     * 
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }
    
    /**
     * 批量读取缓存
     * @param pattern
     * @return
     */
     
    public List<Object> getBatch(final String pattern) {
        List<Object> result = new ArrayList<Object>();
        Set<String> keys = redisTemplate.keys(pattern);
        for (String key : keys) {
            result.add(key);
        }
        return result;
    }
    
    /**
     * 批量删除对应的value
     * 
     * @param keys
     */
    public void removeBatch(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 模糊匹配批量删除key
     * 
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set<String> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0)
            redisTemplate.delete(keys);
    }

    /**
     * 判断缓存中是否有对应的value
     * 
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 写入缓存(规定缓存时间)
     * 
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<String, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            System.out.println("set cache error");
        }
        return result;
    }
    
    public long increment(final String key , long delta){
         return redisTemplate.opsForValue().increment(key, delta);
    }

}

我只用到了get();set();removePattern();其他方法没用到，不保证正确，你要用可以自己看着改。

之后就可以在要用redis缓存的地方用RedisUtil进行操作了。

比如我的一个用到redis缓存的方法如下：

@Autowired

private RedisUtil redisUtil;

public List<News> getlist(News news) {
        List<News> list_news=new ArrayList<News>();
        List<News> str=new ArrayList<News>();
        try {
            //从缓存中读取数据
            str = (List<News>) redisUtil.get(news.getPageSize()+"_"+news.getPageNum()+"_"+news.getTypeid()+"_"+news.getLangid());
        } catch (Exception e) {
            System.out.println("redis出错");
        }
            //缓存中若无要查找的数据则到数据库查找
            if(str==null||str.isEmpty()) {
                //从数据库查找数据
                list_news=newsDao.getlist(news);
                try {
                    //将数据库查找出的数据存入缓存，key为传入的参数以‘_’拼接而成
                    redisUtil.set(news.getPageSize()+"_"+news.getPageNum()+"_"+news.getTypeid()+"_"+news.getLangid(), list_news);
                } catch (Exception e) {
                    System.out.println("redis出错");
                }
            }else {
                list_news=str;
            }
        return list_news;
    }

因为我要存到缓存的是List<News>,所以News类还要实现序列化。而且原来我找网上的好多说存List集合要用什么json转换，但用了以后发现直接存取List集合就可以,按网上转换还报错……现在我是怎么简单怎么来也不知道有没有什么弊端。而且因为我这个方法传入的是对象有四个参数，我也不知道怎么存redis才好所以就把参数加'_'作为了key值，因为我这样存的是数据集合所以如果修改了数据库，我会调用removePattern（"*"）方法清空缓存，不过好在数据修改不频繁。如果有什么其他的好方法敬请告知。