spring及springboot整合redis

前言：

redis是一种nosql数据库，以<key，value>的形式存储数据，其速度相比于MySQL之类的数据库，相当于内存读写与硬盘读写的差别，所以常常用作缓存。接下来就分别看看在spring项目和springboot项目中如何使用redis(项目都基于SSM)。

欢迎大家关注我的公众号 javawebkf，目前正在慢慢地将简书文章搬到公众号，以后简书和公众号文章将同步更新，且简书上的付费文章在公众号上将免费。

一、整合前提：

前提是你已经安装redis且支持远程连接，redis的安装这里不再赘述，有需要的可以参考我的另一篇文章：centos 7.3上安装redis。这里主要讲讲如何判断及设置redis支持远程连接。

1、判断你的redis是否支持远程连接：
①:在centos中输入如下命令找到redis-cli：
whereis redis-cli

②:根据返回的目录找到redis-cli，再执行如下命令：
redis-cli -h 192.168.1.100

③:192.168.1.100就是你的虚拟机ip地址。若这一步报错connect refused，可能是防火墙没有开放6379端口。执行如下命令查看开放的端口：
firewall-cmd --zone=public --list-ports

④:若确实没有6379，那就执行如下命令添加：
firewall-cmd --zone=public --add-port=6379/tcp --permanent

⑤:然后重启防火墙：
firewall-cmd --reload

⑥:开放了6379端口后再次执行：
redis-cli -h 192.168.1.100
出现如下结果：

image.png

⑦:这样并不能说明支持远程连接，我们输入ping，如果返回pong，说明才是支持远程连接的。

image.png

2、设置支持远程连接：
如果没有返回pong，而是报错了，执行如下操作：
①:先关闭redis:
redis-cli shutdown

②:找到redis的配置文件：
whereis redis.conf

③:根据返回的目录，用vim打开redis.conf:
vim redis.conf
把bind 127.0.0.1改成bind 0.0.0.0,
再把protected-mode=yes的yes改为no,

image.png

④:然后保存退出，重启redis,再用redis-cli连接，输入ping，就能返回pong了。

二、spring整合redis:

点我下载源码。
1、引依赖：
pom.xml:

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.7.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>

除了ssm整合以及mysql数据库需要的依赖，引入以上两个即可。
注意：
注意这两个jar包的版本搭配，有些版本搭配可能会报错，这两个版本搭配亲测可用。

2、编写RedisUtil工具类：

package com.zhu.redis.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.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;

public class RedisUtil 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;
    }

    public String getName() {
        return this.name;
    }

    public 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 e) {
            e.printStackTrace();
        }
        return bytes;
    }

    public 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 (Exception e) {
            e.printStackTrace();
        }
        return obj;
    }

    @Override
    public Object getNativeCache() {
        return this.redisTemplate;
    }

    @Override
    public ValueWrapper get(Object key) {
        System.out.println("--------------------------- get key ----------------------------");
        final String keyf = key.toString();
        Object object = null;
        object = redisTemplate.execute(new RedisCallback<Object>() {
            public Object doInRedis(RedisConnection connection) {
                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) {
        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) {
                byte[] keyb = keyf.getBytes();
                byte[] valueb = toByteArray(valuef);
                connection.set(keyb, valueb);
                if (liveTime > 0) {
                    connection.expire(keyb, liveTime);
                }
                return 1L;
            }
        });

    }

    @Override
    public void evict(Object key) {
        System.out.println("-------------------------- del key ---------------------------");
        final String keyf = key.toString();
        redisTemplate.execute(new RedisCallback<Long>() {
            public Long doInRedis(RedisConnection connection) {
                return connection.del(keyf.getBytes());
            }
        });

    }

    @Override
    public void clear() {
        System.out.println("-------------------- clear key -------------------------");
        redisTemplate.execute(new RedisCallback<String>() {
            public String doInRedis(RedisConnection connection) {
                connection.flushDb();
                return "ok";
            }
        });

    }

    @Override
    public ValueWrapper putIfAbsent(Object key, Object value) {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public <T> T get(Object key, Class<T> type) {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public <T> T get(Object key, Callable<T> valueLoader) {
        // TODO Auto-generated method stub
        return null;
    }

}

这个类等下要在spring-redis.xml中配置。该类继承了spring的cache，提供了对缓存的一些基本操作的方法(get、del等)，还定义了一个name成员变量，在需要用缓存的地方直接用注解@Cacheable(value="name的值")即可。

3、连接参数redis.properties：
redis.properties:

redis.host=192.168.1.100
redis.port=6379
redis.dbIndex=0
redis.expiration=3000
redis.maxIdle=300
redis.maxActive=600
redis.maxWait=1000
redis.testOnBorrow=true

4、在spring-redis.xml中整合：

<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}" /> 
        <property name="maxTotal" value="${redis.maxActive}" />
        <property name="maxWaitMillis" value="${redis.maxWait}" />
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />
    </bean>

    <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="database" value="${redis.dbIndex}" />
        <property name="poolConfig" ref="poolConfig" />
    </bean>

    <bean id="redisTemplate"
        class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="jedisConnectionFactory"></property>
    </bean>
    
    <bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
        <property name="caches">
            <set>
                <!-- 自定义的RedisUtil工具类 -->
                <bean class="com.zhu.redis.util.RedisUtil">
                    <property name="redisTemplate" ref="redisTemplate"/>
                    <!-- name属性的值自己随便写，等下在注解当中用 -->
                    <property name="name" value="common"/>
                </bean>
            </set>
        </property>
    </bean>
    <!-- 开启注解，这个非常重要，否则等下使用缓存注解不生效 -->
    <cache:annotation-driven cache-manager="cacheManager"/>

注意：
我这里并没有引入redis.properties，是因为我在spring-dao.xml中引入jdbc.properties时一起引入了，所以这里无需再引入。
spring-dao.xml中引入.properties文件代码：

    <bean
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:jdbc.properties</value>
                <value>classpath:redis.properties</value>
            </list>
        </property>
    </bean>

5、在service层使用redis:

@Service
public class AreaServiceImpl implements AreaService {
    @Autowired
    private AreaDao areaDao;
    
    @Cacheable(value="common") //加入缓存
    //@CacheEvict(value="common") //清除缓存
    @Override
    public List<Area> getAreaList() {
        return areaDao.queryArea();
    }

}

注意：
要使用redis，实体类必须实现序列化接口(implements Serializable)，否则会抛java.io.NotSerializableException异常。

6、测试：
首先看一下数据库：

image.png

然后用junit测试：
BaseTest.java:(用来加载配置文件)

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({ "classpath:spring/spring-dao.xml","classpath:spring/spring-service.xml","classpath:spring/spring-redis.xml"})
public class BaseTest {

}

AreaServiceTest.java:

public class AreaServiceTest extends BaseTest {
    
    @Autowired
    private AreaService areaService;
    
    @Test
    public void test() {
        List<Area> areaList = areaService.getAreaList();
        for(Area area : areaList) {
            System.out.println(area.getAreaName());
        }
        System.out.println(areaList.size());
    }

}

看运行结果：

image.png

从图中可以看到这一次是从MySQL数据库查询的，且RedisUtil已经运行，因为打印出了put key。

再运行一次：

image.png

可以看到这次没有打印sql语句，且打印了get key，说明缓存已经生效。

把AreaService.java中的@Cacheable(value="common")注释掉，把@CacheEvict(value="common")放开，
再次运行：

image.png

可以看到又打印出了sql语句，且输出了del key，说明已经清除了缓存，再次从数据库中查找。

这样就完成了spring与redis的整合。

三、springboot整合redis:

springboot整合redis就简单了，只需要简单配置就行了。

1、引依赖：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-redis</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>

springboot整合redis,只需引入这一个依赖即可。

2、在application.properties中配置redis：

spring.redis.host=192.168.1.100
spring.redis.port=6379
#连接池最大连接数
spring.redis.jedis.pool.max-active=8
#最小空闲连接
spring.redis.jedis.pool.min-idle=0
#最大阻塞等待时间，负值表示没有限制
spring.redis.jedis.pool.max-wait=-1
#最大空闲连接
spring.redis.jedis.pool.max-idle=8
#连接超时时间(毫秒)
spring.redis.timeout=20

3、在springboot启动类上加上@EnableCaching注解，如下图：

image.png

4、接下来就可以使用redis缓存了：
在需要使用的地方加上注解即可。
AreaServiceImpl.java:

@Service
public class AreaServiceImpl implements AreaService {

    @Autowired
    private AreaDao areaDao;


    @Override
    @Transactional
    @Cacheable(value = "common")
    //@CacheEvict(value="common")
    public List<Area> getAreaList() {
        return areaDao.queryArea();
    }

}

5、测试：
AreaServiceTest.java:

@RunWith(SpringRunner.class)
@SpringBootTest
public class AreaServiceTest {
    
    @Autowired
    private AreaService areaService;
    
    @Test
    public void test() {
        List<Area> areaList = areaService.getAreaList();
        for(Area area : areaList) {
            System.out.println(area.getAreaName());
        }
    }

}

第一次运行：

image.png

打印出了sql语句，是从数据库查询的。

第二次运行：

image.png

没有sql语句，是从缓存中读取的。

把@Cacheable(value = "common")注释掉，把@CacheEvict(value="common")放开，
再运行：

image.png

又是从数据库中读取的，说明redis清除成功。

总结：

spring整合redis：
总的来说就是引依赖、编写RedisUtil、编写redis.properties、在spring-redis.xml中配置，最后在需要使用的地方用注解就行了。
spring boot整合redis:
总的来说就是引依赖、在application.properties中配置、在启动类上加@EnableCaching注解，然后在需要使用的地方用注解就行了。
注意事项：
1、首先你的redis得支持远程连接。
2、实体类必须实现序列化接口。
3、redis的注解是@Cacheable(value = "?",key="?")这样的key、value形式，value必须自己指定，可以随便写，key可以不写，不写会自动生成。
4、如果要使用缓存的方法的参数是引用类型，比如方法是getStudent(Student stu)那么该引用类型的必须重写toString方法，即Student实体类必须重写toString方法，否则使用缓存时会报错can not convert com.zhu.entity.Student toString。
5、若项目发布到服务器上，一开始redis可以正常使用，一段时间后redis不能正常使用，用redis-cli -h xx.xxx.x.xxx -p 6379命令连接显示connection timeout，访问项目中用到了redis的路由会报错could not get a resource from pool，可按如下步骤解决：
先kill掉redis的服务：
ps aux | grep redis
kill -9 redis服务的pid
换端口开启redis服务：
redis-server redis.conf --port 6000 &
这里指定的6000端口，也可以是其他的，&表示后台启动。再用redis-cli -h xx.xxx.x.xxx -p 6000就可以连接上了。然后把项目中的redis配置的端口换成6000，重新发布项目即可。
项目说明：
1、springboot是springboot2.x，springboot 1.5整合redis与这个不一样。
2、上述两个项目之所以会打印查询的sql语句，是因为在mybatis-config.xml中进行了如下配置：

    <settings>
        <!-- 打印查询语句 -->
        <setting name="logImpl" value="STDOUT_LOGGING" />
    </settings>

以上内容属于个人笔记整理，如有错误，欢迎批评指正！

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 159,015评论 4赞 362
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 67,262评论 1赞 292
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 108,727评论 0赞 243
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 43,986评论 0赞 205
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 52,363评论 3赞 287
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,610评论 1赞 219
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,871评论 2赞 312
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,582评论 0赞 198
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,297评论 1赞 242
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,551评论 2赞 246
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 32,053评论 1赞 260
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,385评论 2赞 253
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 33,035评论 3赞 236
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,079评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,841评论 0赞 195
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,648评论 2赞 274
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,550评论 2赞 270