SSM之整合Redis_ssm框架如何同时连接多个redis-CSDN博客

本文链接：https://blog.csdn.net/Trista_1999/article/details/100878791

Redis安装与使用

第一步当然是安装Redis，这里以Windows上的安装为例。

首先下载Redis,可以选择msi或zip包安装方式
zip方式需打开cmd窗口，在解压后的目录下运行redis-server redis.windows.conf启动Redis
采用msi方式安装后Redis默认启动，不需要进行任何配置
可以在redis.windows.conf文件中修改Redis端口号、密码等配置，修改完成后使用redis-server redis.windows.conf命令重新启动
在Redis安装目录下执行redis-cli -h 127.0.0.1 -p 6379 -a 密码打开Redis操作界面
如果报错(error) ERR operation not permitted，使用auth 密码进行验证

SSM整合Redis

这里需要注意，存入Redis的pojo类必须实现Serializable接口。
具体代码已发布在Github上，地址：SSMDemo

配置pom.xml引入Redis依赖

<!--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.7.3</version>
</dependency>

redis.properties

#ip
redis.host=127.0.0.1
#端口
redis.port=6379
#密码
redis.password=redis
#最大空闲数
redis.maxIdle=100
#最大连接数
redis.maxActive=300
#连接时最大的等待时间（毫秒）
redis.maxWait=1500
#在提取一个jedis实例时，是否提前进行验证操作；如果为true，则得到的jedis实例均是可用的
redis.testOnBorrow=true

applicationContext-redis.xml

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

<!--读取properties-->
    <!--<bean id="configProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean">-->
        <!--<property name="locations">-->
            <!--&lt;!&ndash;<list>&ndash;&gt;-->
                <!--<value>classpath:properties/redis.properties</value>-->
            <!--&lt;!&ndash;</list>&ndash;&gt;-->
        <!--</property>-->
    <!--</bean>-->



    <!-- 引入redis properties属性文件 -->
    <context:property-placeholder location="classpath*:properties/redis.properties" ignore-unresolvable="true"/>


     <!--redis连接池 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
         <!--最大空闲数 -->
        <property name="maxIdle" value="${redis.maxIdle}"/>
        <!--最大连接数-->
        <property name="maxTotal" value="${redis.maxActive}"></property>
         <!--连接时最大的等待时间（毫秒） -->
        <property name="maxWaitMillis" value="${redis.maxWait}"/>
         <!--在提取一个jedis实例时，是否提前进行验证操作；如果为true，则得到的jedis实例均是可用的 -->
        <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
    </bean>


    <!--redis连接工厂-->
    <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="hostName" value="${redis.host}"/>
        <property name="port" value="${redis.port}"/>
         <!--即使没有设置密码,password可以不设置值，但这项设置一定要保留 -->
        <!--<property name="password" value="${redis.password}"/>-->
        <property name="password" value=""></property>
         <!--即使没有设置密码,password可以不设置值，但这项设置一定要保留 -->

         <!--redis连接池 -->
        <property name="poolConfig" ref="poolConfig"></property>
    </bean>

     <!--redis操作模板,使用该对象可以操作redis -->
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">

        <property name="connectionFactory" ref="connectionFactory"/>
         <!--序列化策略 -->
        <!--如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！！  -->
        <property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>
        </property>
        <property name="hashKeySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
        <property name="hashValueSerializer">
            <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer" />
        </property>

        <!--开启事务-->
        <property name="enableTransactionSupport" value="true"/>
    </bean>

    <!--自定义redis工具类,在需要缓存的地方注入此类  -->
    <bean id="redisUtil" class="com.util.RedisUtil">
        <property name="redisTemplate" ref="redisTemplate"/>
    </bean>

</beans>

RedisUtil.java 工具类

package com.util;

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

import java.io.Serializable;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * Redis工具类
 */
public class RedisUtil {
    @Autowired
    private RedisTemplate<Serializable, Object> redisTemplate;

    public void setRedisTemplate(
            RedisTemplate<Serializable, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }


    // =============================common============================

    /**
     * 功能描述：指定缓存失效时间
     *
     * @param key 键
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 功能描述：根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间（s) 返回0 代表永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 功能描述：判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(final String key) {
        return redisTemplate.hasKey(key);

    }


    /**
     * 功能描述：删除对应的value
     *
     * @param key
     */
    public void remove(final String key) {
        if (hasKey(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 功能描述：批量删除对应的value
     *
     * @param keys 可为多个
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 功能描述：批量删除key
     *
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0)
            redisTemplate.delete(keys);
    }

    // ============================String=============================
    /**
     * 功能描述：读取普通缓存
     *
     * @param key 键
     * @return 值
     */
    public Object get(final String key) {
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        Object result = operations.get(key);
        return result;
    }

    /**
     * 功能描述：写入普通缓存
     *
     * @param key 键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入普通缓存并设置时间
     * @param key key
     * @param value value
     * @param expireTime 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate
                    .opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }


    // ================================Map=================================

}