AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

redis安装，redis项目以来，redis和spring整合，redis的service，redis的service实现类

2018-07-19 1564
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云数据库 Tair（兼容Redis），内存型 2GB
推荐场景：
通过缓存加速数据库访问
Redis 开源版，标准版 2GB
推荐场景：
搭建游戏排行榜
简介： 一．redis安装： Redis-3.2.6.tar.gz安装，参考方式： 用源码工程来编译安装 1、 到官网下载最新stable版，这里使用的是：redis-3.2.6.tar.gz 2、 cd /usr/local 3、 make redis-src 4、 tar -zxvf redis-3.

一．redis安装：

Redis-3.2.6.tar.gz安装，参考方式：

用源码工程来编译安装

1、  到官网下载最新stable版，这里使用的是：redis-3.2.6.tar.gz

2、  cd /usr/local  

3、  make redis-src

4、  tar -zxvf    redis-3.2.6.tar.gz  -C  ./redis-src/

2、解压源码并进入目录cd  /usr/local/redis-src/redis-3.2.6

3、 先执行make，检查是否报错

如果报错提示缺少gcc，则安装gcc ：  yum install -y gcc

如果报错提示：Newer version ofjemalloc required

则在make时加参数：make MALLOC=libc （如果没有报错，直接使用make命令）

 

4、安装redis，指定安装目录,如 /usr/local/redis

make PREFIX=/usr/local/redis install

 

5、拷贝一份配置文件到安装目录下

切换到源码目录，里面有一份配置文件redis.conf，然后将其拷贝到安装路径下

cp redis.conf /usr/local/redis/

 

6、启动redis

cd /usr/local/redis

bin/redis-server redis.conf   （如果想后台进程运行，修改：daemonize yes）

 

vim redis.conf 将下面的变量修改为：

daemonize yes

 

将bind的id换成真实的ip地址，比如：

bind 192.168.1.1

 

在集群配置中，要对redis配置密码，修改的配置是将redis.conf这个文件的下面的变量配置成如下的：

requirepass cloudTplWebapp    （这里设置一个密码：cloudTplWebapp）

7、连接redis

另开一个xshell，然后：

#cd /usr/local/redis/

[root@Hadoop redis]# bin/redis-cli 

127.0.0.1:6379>

 

二．配置Maven依赖

<!-- 整合redis所需的jar包 -->

        <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>

二．配置applicationContext.xml

<?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:tx="http://www.springframework.org/schema/tx"

   xmlns:task="http://www.springframework.org/schema/task"

   xsi:schemaLocation=" 

    http://www.springframework.org/schema/beans  

    http://www.springframework.org/schema/beans/spring-beans-3.1.xsd 

    http://www.springframework.org/schema/tx  

    http://www.springframework.org/schema/tx/spring-tx-3.1.xsd

    http://www.springframework.org/schema/mvc

    http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd

    http://www.springframework.org/schema/cache

    http://www.springframework.org/schema/cache/spring-cache-3.1.xsd

    http://www.springframework.org/schema/task

    http://www.springframework.org/schema/task/spring-task-3.1.xsd

    http://www.springframework.org/schema/context  

    http://www.springframework.org/schema/context/spring-context-3.0.xsd

    http://www.springframework.org/schema/aop

    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

   

   

   <!-- 引入jdbc配置文件 -->

   <context:property-placeholder location="classpath:jdbc.properties,classpath:redis.properties" />

   

   <!—在自己的application中加入如下配置 -->

   <import resource="redis-context.xml"/>

</beans>

 其中redis-context.xml的内容如下：

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE beans PUBLIC '-//SPRING//DTD BEAN//EN' 'http://www.springframework.org/dtd/spring-beans.dtd'>
      
<beans>
    <!-- Jedis线程 -->
	<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
		<property name="maxTotal" value="${redis.pool.maxTotal}" />
		<property name="maxIdle" value="${redis.pool.maxIdle}" />
		<property name="maxWaitMillis" value="${redis.pool.maxWaitMillis}" />
		<property name="testOnBorrow" value="${redis.pool.testOnBorrow}" />
	</bean>
	
	<!-- 配置多个redis的方式，start -->
	<bean id="jedis.shardInfo.0" class="redis.clients.jedis.JedisShardInfo">
		<constructor-arg index="0" value="${redis.ip.0}" />
		<constructor-arg index="1" value="${redis.port.0}" />
	</bean>
	<!--
	<bean id="jedis.shardInfo.1" class="redis.clients.jedis.JedisShardInfo">
		<constructor-arg index="0" value="${redis.ip.1}" />
		<constructor-arg index="1" value="${redis.port.1}" />
	</bean>
	-->
	<bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">
		<constructor-arg index="0" ref="jedisPoolConfig" />
		<constructor-arg index="1">
			<list>
				<ref bean="jedis.shardInfo.0" />
				<!--<ref bean="jedis.shardInfo.1" />-->
			</list>
		</constructor-arg>
	</bean>
	<!-- 配置多个redis的方式，end -->
	
	<bean id="jedisConnectionFactory"
		class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
		
		<!-- 以下是配置多个redis的方式 :start  -->
		<!--<property name="shardInfo" value="shardedJedisPool"></property>-->
		<!-- 以上是配置多个reids的方式 :end -->
		
		<!-- 以下是配置单个redis的方式:start -->
		<property name="hostName" value="${redis.ip.0}" />
		<property name="port" value="${redis.port.0}" />
		<property name="password" value="${redis.pass}"/>
		<property name="timeout" value="${redis.timeout}"/>
		<property name="database" value="${redis.default.db}"/>
		<property name="poolConfig" ref="jedisPoolConfig" />
		
		<!-- 以上是配置单个redis的方式:end-->
	</bean>
	<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
		<property name="connectionFactory" ref="jedisConnectionFactory" />
	</bean>
	<bean id="redisService" class="xx.tpl.rediscache.impl.RedisServiceImpl">
		<property name="redisTemplate" ref="redisTemplate" />
		<property name="expirationtime" value="${redis.expiration}"/>
	</bean>
</beans>


编写redis.properties属性文件

#redis.pool.maxActive=1024

#redis.pool.maxIdle=200

#redis.pool.maxWait=1000

#redis.pool.testOnBorrow=true

 

redis.ip.0=192.168.1.1

redis.port.0=6379

#密码

redis.pass=cloudTplWebapp

#设置默认的连接的db

redis.default.db=0

redis.timeout=100000

redis.maxActive=300

 

redis.ip.1=192.168.1.1

redis.port.1=6379

redis.pool.maxTotal=1024

redis.pool.maxIdle=200

redis.pool.maxWaitMillis=1000

redis.pool.testOnBorrow=true

redis.expiration=300

 

Redis的RedisService如下：

package xxx.xxx.xxx.rediscache;

 

import java.io.Serializable;

import java.util.Map;

import java.util.Set;

 

/**

 * RedisService.java redis的服务操作类

 * @attention

 * @author toto

 * @date 2017-1-12

 * @note begin modify by 涂作权 2017-1-12 原始创建

 */

public interface RedisService<T> {

   

         /**

     * 将内容保存到缓存中

     *

     * @param key

     * @param value

     * @throws Exception

     * @attention

     * @author toto

     * @date 2017-1-12

     * @note  begin modify by 涂作权 2017-1-12 原始创建

     */

         public void save(final String key, Object value) throws Exception;

 

         /**

          * 获取内存中的内容

          * @param <T>

          * @param key

          * @param elementType

          * @return

          * @throws Exception

          * @attention

          * @author toto

          * @date 2017-1-12

          * @note  begin modify by 原始创建 2017-1-12  原始创建

          */

         public <T> T getByKey(final String key, Class<T> elementType) throws Exception;

        

         /**

          * 通过传递key删除所有的在缓存中的内容

          * @param key

          * @attention

          * @author toto

          * @date 2017-1-12

          * @note  begin modify by 涂作权 2017-1-12  原始创建

          */

         public void del(String... key) throws Exception;

        

         /**

          * 批量删除<br/>

          * @param pattern

          * @throws Exception

          * @attention 该操作会执行模糊查询，请尽量不要使用，以免影响性能或误删

          * @author toto

          * @date 2017-1-12

          * @note begin modify by 涂作权  2017-1-12  原始创建

          */

         public void batchDel(String... pattern) throws Exception;

 

         /**

          * 取得缓存(int型)

          * @param key

          * @return

          * @throws Exception

          * @attention 方法的使用注意事项

          * @author toto

          * @date 2017-1-12

          * @note  begin modify by 涂作权 2017-1-12 原始创建

          */

         public Integer getInt(String key) throws Exception;

        

         /**

          * 取得缓存(字符串类型) 

          * @param key

          * @return

          * @attention 方法的使用注意事项

          * @author toto

          * @date 2017-1-12

          * @note  begin modify by 涂作权 2017-1-12  原始创建

          */

         public String getStr(String key) throws Exception;

        

         /**

          * 取得缓存(字符串类型)

          * @param key

          * @param retain

          * @return

          * @throws Exception

          * @attention

          * @author toto

          * @date 2017-1-12

          * @note  begin modify by 涂作权 2017-1-12  原始创建

          */

         public String getStr(String key,boolean retain) throws Exception;

        

         /**

          * 获取缓存<br>

          * @param key

          * @return

          * @throws Exception

          * @attention 注：基本数据类型(Character除外)，请直接使用get(String key, Class<T> clazz)取值

          * @author toto

          * @date 2017-1-12

          * @note  begin modify by 涂作权 2017-1-12  原始创建

          */

         public Object getObj(String key) throws Exception;

        

         /**

          * 获取缓存<br> 

          * @param key

          * @param retain 是否保留

          * @return

          * @attention 注：java 8种基本类型的数据请直接使用get(String key, Class<T> clazz)取值

          * @author toto

          * @date 2017-1-12

          * @note  begin modify by 涂作权 2017-1-12 原始创建

          */

         public Object getObj(String key,boolean retain) throws Exception ;

        

         /**

          * 获取缓存

          * @param <T>

          * @return

          * @throws Exception

          * @attention 方法的使用注意事项

          * @author toto

          * @date 2017-1-12

          * @note  begin modify by 修改人 修改时间   修改内容摘要说明

          */

         public <T> T get(String key, Class<T> clazz) throws Exception;

        

         /**

     * 将value对象写入缓存

     * @param key

     * @param value

     * @param time 失效时间(秒)

     */

    public void set(String key,Object value,long expirationtime)throws Exception;

   

    /**

     * 递减操作

     * @param key

     * @param by

     * @return

     */

    public double decr(String key, double by)throws Exception;

   

    /**

     * 递增操作

     * @param key

     * @param by

     * @return

     */

    public double incr(String key, double by)throws Exception;

   

    /**

     * 获取double类型值

     * @param key

     * @return

     */

    public double getDouble(String key) throws Exception;

   

    /**

     * 设置double类型值

     * @param key

     * @param value

     * @param time 失效时间(秒)

     */

    public void setDouble(String key, double value,long expirationtime) throws Exception;

   

    /**

     * 设置double类型值

     * @param key

     * @param value

     * @param time 失效时间(秒)

     */

    public void setInt(String key, int value, long expirationtime) throws Exception;

   

    /**

     * 将map写入缓存

     * @param key

     * @param map

     * @param time 失效时间(秒)

     */

    public <T> void setMap(String key, Map<String, T> map, long expirationtime)throws Exception;

   

    /**

     * 向key对应的map中添加缓存对象

     * @param key

     * @param map

     */

    public <T> void addMap(String key, Map<String, T> map)throws Exception;

   

    /**

     * 向key对应的map中添加缓存对象

     * @param key   cache对象key

     * @param field map对应的key

     * @param value     值

     */ 

    public void addMap(String key, String field, String value)throws Exception;

   

    /**

     * 向key对应的map中添加缓存对象

     * @param key   cache对象key

     * @param field map对应的key

     * @param obj   对象

     */ 

    public <T> void addMap(String key, String field, T obj)throws Exception;

   

    /**

     * 获取map缓存

     * @param key

     * @param clazz

     * @return

     */ 

    public <T> Map<String, T> mget(String key, Class<T> clazz)throws Exception;

   

    /**

     * 获取map缓存中的某个对象

     * @param key

     * @param field

     * @param clazz

     * @return

     */

    public <T> T getMapField(String key, String field, Class<T> clazz)throws Exception;

   

    /**

     * 删除map中的某个对象

     * @author lh

     * @date 2016年8月10日

     * @param key   map对应的key

     * @param field map中该对象的key

     */ 

    public void delMapField(String key, String... field)throws Exception;

   

    /**

     * 指定缓存的失效时间

     *

     * @author FangJun

     * @date 2016年8月14日

     * @param key 缓存KEY

     * @param time 失效时间(秒)

     */

    public void expire(String key, long expirationtime) throws Exception;

   

    /**

     * 添加set

     * @param key

     * @param value

     */

    public void sadd(String key, String... value) throws Exception;

   

    /**

     * 删除set集合中的对象

     * @param key

     * @param value

     */ 

    public void srem(String key, String... value) throws Exception;

   

    /**

     * set重命名

     * @param oldkey

     * @param newkey

     */

    public void srename(String oldkey, String newkey)throws Exception;

   

    /**

     * 模糊查询keys

     * @param pattern

     * @return

     */

    public Set<Serializable> keys(String pattern)throws Exception;

}

 

Redis的RedisServiceImpl的实现类：

package xxx.xxx.xxx.rediscache.impl;

 

import java.io.Serializable;

import java.util.Map;

import java.util.Set;

import java.util.concurrent.TimeUnit;

 

import org.apache.commons.lang.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.springframework.dao.DataAccessException;

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

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

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

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

import org.springframework.util.CollectionUtils;

 

import com.ucap.tpl.rediscache.RedisService;

import com.ucap.tpl.utils.SerializeUtils;

 

@SuppressWarnings({"unchecked"})

public class RedisServiceImpl<T> implements RedisService<T> {

         @SuppressWarnings("unused")

         private static Log logger = LogFactory.getLog(RedisServiceImpl.class);

         private static RedisTemplate<Serializable, Serializable> redisTemplate;

         private long expirationtime;

        

         public long getExpirationtime() {

                   return expirationtime;

         }

 

         public RedisTemplate<Serializable, Serializable> getRedisTemplate() {

                   return redisTemplate;

         }

 

         @SuppressWarnings("static-access")

         public void setRedisTemplate(

                            RedisTemplate<Serializable, Serializable> redisTemplate) {

                   this.redisTemplate = redisTemplate;

         }

 

         public void setExpirationtime(long expirationtime) {

                   this.expirationtime = expirationtime;

         }

        

         /**

          * 保存内容到缓存中

          */

         public void save(final String key, Object value) throws Exception {

                   final byte[] vbytes = SerializeUtils.serialize(value);

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

 

                            public Object doInRedis(RedisConnection connection)

                                               throws DataAccessException {

                                     connection.set(redisTemplate.getStringSerializer().serialize(key), vbytes);

                                     return null;

                            }

                   });

         }

        

         /**

          * 通过key取到保存在缓存中的内容

          */

         public <T> T getByKey(final String key, Class<T> elementType) throws Exception {

                   try {

                            return redisTemplate.execute(new RedisCallback<T>() {

                                     public T doInRedis(RedisConnection connection)

                                                        throws DataAccessException {

                                               byte[] keyBytes = redisTemplate.getStringSerializer().serialize(key);

                                               if (connection.exists(keyBytes)) {

                                                        byte[] valueBytes = connection.get(keyBytes);

                                                       

                                                        T value = (T) SerializeUtils.unserialize(valueBytes);

                                                        return value;

                                               }

                                               return null;

                                     }

                            });

                   } catch (Exception e) {

                            e.printStackTrace();

                   }

                   return null;

         }

        

         /**

          * 通过传递key删除所有的在缓存中的内容

          * @param key

          * @attention 这里个的key是可变参数的key

          * @author toto

          * @date 2017-1-12

          * @note  begin modify by 涂作权 2017-1-12  原始创建

          */

         public void del(String... key) throws Exception {

                   if (key != null && key.length > 0) {

                            if (key.length == 1) {

                                     redisTemplate.delete(key[0]);

                            } else {

                                     redisTemplate.delete(CollectionUtils.arrayToList(key));

                            }

                   }

         }

        

         /**

          * 批量删除<br/>

          * @param pattern

          * @throws Exception

          * @attention 该操作会执行模糊查询，请尽量不要使用，以免影响性能或误删

          * @author toto

          * @date 2017-1-12

          * @note begin modify by 涂作权  2017-1-12  原始创建

          */

         public void batchDel(String... pattern) throws Exception {

                   for (String pt : pattern) {

                            redisTemplate.delete(redisTemplate.keys(pt + "*"));

                   }

         }

 

         /**

          * 取得缓存(int型)

          * @param key

          * @return

          * @throws Exception

          * @attention 方法的使用注意事项

          * @author toto

          * @date 2017-1-12

          * @note  begin modify by 涂作权 2017-1-12 原始创建

          */

         public Integer getInt(String key) throws Exception {

                   String value = (String) redisTemplate.boundValueOps(key).get();

                   if (StringUtils.isNotBlank(value)) {

                            return Integer.valueOf(value);

                   }

                   return null;

         }

 

         /**

          * 取得缓存(字符串类型) 

          * @param key

          * @return

          * @attention 方法的使用注意事项

          * @author toto

          * @date 2017-1-12

          * @note  begin modify by 涂作权 2017-1-12  原始创建

          */

         public String getStr(String key) throws Exception {

                   return (String) redisTemplate.boundValueOps(key).get();

         }

 

         /**

          * 取得缓存(字符串类型)

          * @param key

          * @param retain

          * @return

          * @attention

          * @author toto

          * @date 2017-1-12

          * @note  begin modify by 涂作权 2017-1-12 原始创建

          */

         public String getStr(String key,boolean retain) throws Exception {

                   String value = (String) redisTemplate.boundValueOps(key).get();

                   if (!retain) {

                            redisTemplate.delete(key);

                   }

                   return value;

         }

 

         /**

          * 获取缓存<br>

          * 注：基本数据类型(Character除外)，请直接使用get(String key, Class<T> clazz)取值

          * @param key

          * @return

          */

         public Object getObj(String key) throws Exception {

                   return redisTemplate.boundValueOps(key).get();

         }

 

         /**

          * 获取缓存<br> 

          * @param key

          * @param retain 是否保留

          * @return

          * @attention 注：java 8种基本类型的数据请直接使用get(String key, Class<T> clazz)取值

          * @author toto

          * @date 2017-1-12

          * @note begin modify by 涂作权 2017-1-12  原始创建

          */

         public Object getObj(String key, boolean retain) throws Exception {

                   Object obj = redisTemplate.boundValueOps(key).get();

                   if (!retain) {

                            redisTemplate.delete(key);

                   }

                   return obj;

         }

        

         /**

     * 获取缓存<br>

     * 注：该方法暂不支持Character数据类型

     * @param key   key

     * @param clazz 类型

     * @return

     */

         public <T> T get(String key, Class<T> clazz) throws Exception {

        return (T) redisTemplate.boundValueOps(key).get();

    }

     

    /**

     * 将value对象写入缓存

     * @param key

     * @param value

     * @param time 失效时间(秒)

     */ 

    public void set(String key,Object value,long expirationtime)throws Exception { 

        if(value.getClass().equals(String.class)){

            redisTemplate.opsForValue().set(key, value.toString());

        }else if(value.getClass().equals(Integer.class)){

            redisTemplate.opsForValue().set(key, value.toString());

        }else if(value.getClass().equals(Double.class)){

            redisTemplate.opsForValue().set(key, value.toString());

        }else if(value.getClass().equals(Float.class)){

            redisTemplate.opsForValue().set(key, value.toString());

        }else if(value.getClass().equals(Short.class)){

            redisTemplate.opsForValue().set(key, value.toString());

        }else if(value.getClass().equals(Long.class)){

            redisTemplate.opsForValue().set(key, value.toString());

        }else if(value.getClass().equals(Boolean.class)){

            redisTemplate.opsForValue().set(key, value.toString());

        }else{

            redisTemplate.opsForValue().set(key, SerializeUtils.serialize(value));

        }

        if(expirationtime > 0){

            redisTemplate.expire(key, expirationtime, TimeUnit.SECONDS);

        }

    }

   

    /**

     * 递减操作

     * @param key

     * @param by

     * @return

     */

    public double decr(String key, double by)throws Exception {

        return redisTemplate.opsForValue().increment(key, -by);

    }

     

    /**

     * 递增操作

     * @param key

     * @param by

     * @return

     */

    public double incr(String key, double by)throws Exception {

        return redisTemplate.opsForValue().increment(key, by);

    }

     

    /**

     * 获取double类型值

     * @param key

     * @return

     */

    public double getDouble(String key) throws Exception {

        String value = (String) redisTemplate.boundValueOps(key).get();

        if(StringUtils.isNotBlank(value)){

            return Double.valueOf(value);

        }

        return 0d;

    }

   

    /**

     * 设置double类型值

     * @param key

     * @param value

     * @param time 失效时间(秒)

     */

    public void setDouble(String key, double value,long expirationtime) throws Exception {

        redisTemplate.opsForValue().set(key, String.valueOf(value));

        if(expirationtime > 0){

            redisTemplate.expire(key, expirationtime, TimeUnit.SECONDS);

        }

    }

   

    /**

     * 设置double类型值

     * @param key

     * @param value

     * @param time 失效时间(秒)

     */

    public void setInt(String key, int value, long expirationtime) throws Exception {

        redisTemplate.opsForValue().set(key, String.valueOf(value));

        if(expirationtime > 0){

            redisTemplate.expire(key,expirationtime, TimeUnit.SECONDS);

        }

    }

     

    /**

     * 将map写入缓存

     * @param key

     * @param map

     * @param time 失效时间(秒)

     */

    public <T> void setMap(String key, Map<String, T> map, long expirationtime)throws Exception {

        redisTemplate.opsForHash().putAll(key, map);

    }

   

    /**

     * 向key对应的map中添加缓存对象

     * @param key

     * @param map

     */

    public <T> void addMap(String key, Map<String, T> map)throws Exception {

        redisTemplate.opsForHash().putAll(key, map);

    }

   

    /**

     * 向key对应的map中添加缓存对象

     * @param key   cache对象key

     * @param field map对应的key

     * @param value     值

     */

    public void addMap(String key, String field, String value)throws Exception {

        redisTemplate.opsForHash().put(key, field, value);

    }

     

    /**

     * 向key对应的map中添加缓存对象

     * @param key   cache对象key

     * @param field map对应的key

     * @param obj   对象

     */

    public <T> void addMap(String key, String field, T obj)throws Exception {

        redisTemplate.opsForHash().put(key, field, obj);

    }

   

    /**

     * 获取map缓存

     * @param key

     * @param clazz

     * @return

     */

    public <T> Map<String, T> mget(String key, Class<T> clazz)throws Exception {

        BoundHashOperations<Serializable, String, T> boundHashOperations = redisTemplate.boundHashOps(key);

        return boundHashOperations.entries();

    } 

  

    /**

     * 获取map缓存中的某个对象

     * @param key

     * @param field

     * @param clazz

     * @return

     */

    public <T> T getMapField(String key, String field, Class<T> clazz)throws Exception {

        return (T)redisTemplate.boundHashOps(key).get(field);

    } 

     

    /**

     * 删除map中的某个对象

     * @author lh

     * @date 2016年8月10日

     * @param key   map对应的key

     * @param field map中该对象的key

     */

    public void delMapField(String key, String... field)throws Exception {

        BoundHashOperations<Serializable, String, Object> boundHashOperations = redisTemplate.boundHashOps(key);

        boundHashOperations.delete(field);

    }

     

    /**

     * 指定缓存的失效时间

     *

     * @author FangJun

     * @date 2016年8月14日

     * @param key 缓存KEY

     * @param time 失效时间(秒)

     */

    public void expire(String key, long expirationtime) throws Exception {

        if(expirationtime > 0){

            redisTemplate.expire(key, expirationtime, TimeUnit.SECONDS);

        }

    }

   

    /**

     * 添加set

     * @param key

     * @param value

     */

    public void sadd(String key, String... value) throws Exception { 

        redisTemplate.boundSetOps(key).add(value);

    }

   

    /**

     * 删除set集合中的对象

     * @param key

     * @param value

     */

    public void srem(String key, String... value) throws Exception {

        redisTemplate.boundSetOps(key).remove(value);

    }

   

    /**

     * set重命名

     * @param oldkey

     * @param newkey

     */

    public void srename(String oldkey, String newkey)throws Exception { 

        redisTemplate.boundSetOps(oldkey).rename(newkey);

    }

     

    /**

     * 模糊查询keys

     * @param pattern

     * @return

     */

    public Set<Serializable> keys(String pattern)throws Exception { 

        return redisTemplate.keys(pattern);

    }

}

 依赖的SerializeUtils.java代码如下：

package xx.tpl.utils;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * SerializeUtils.java 序列化相关的操作类
 * @attention
 * @author toto
 * @date 2017-1-12
 * @note begin modify by 涂作权 2017-1-12 原始创建
 */
public class SerializeUtils {
	
	/**
	 * 将对象进行序列化
	 * @param object
	 * @return
	 * @attention 传递对象，将
	 * @author toto
	 * @date 2017-1-12 
	 * @note  begin modify by 修改人 修改时间   修改内容摘要说明
	 */
	public static byte[] serialize(Object object) {
		ObjectOutputStream oos = null;
		ByteArrayOutputStream baos = null;
		try {
			// 序列化
			baos = new ByteArrayOutputStream();
			oos = new ObjectOutputStream(baos);
			oos.writeObject(object);
			byte[] bytes = baos.toByteArray();
			return bytes;
		} catch (Exception e) {
			throw new RuntimeException(e.getMessage(), e);
		}
	}
    
    /**
     * 反序列化
     * @param bytes
     * @return
     * @attention 反序列化的操作
     * @author toto
     * @date 2017-1-12 
     * @note  begin modify by 涂作权 2017-1-12 原始创建
     */
	public static Object unserialize(byte[] bytes) {
		ByteArrayInputStream bais = null;
		try {
			// 反序列化
			bais = new ByteArrayInputStream(bytes);
			ObjectInputStream ois = new ObjectInputStream(bais);
			return ois.readObject();
		} catch (Exception e) {
			throw new RuntimeException(e.getMessage(), e);
		}
	}
}


在BaseController 中引入如下的内容：

/** 获取redis的service连接 */

@Resource(name = "redisService")

protected RedisServiceImpl redisService;

最后，在项目中就可以通过redisService调用其它的redis方法了。

文章标签：
云数据库 Tair（兼容 Redis）
Redis
NoSQL
缓存
Java
Spring
C语言
前端开发
数据安全/隐私保护
Maven
数据库连接
关键词：
Spring redis
云数据库 Tair（兼容 Redis）项目
Spring项目
云数据库 Tair（兼容 Redis）安装
云数据库 Tair（兼容 Redis）spring
相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务，基于高可靠双机热备架构及可无缝扩展的集群架构，满足高读写性能场景及容量需弹性变配的业务需求。 产品详情：https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验：数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引，您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接，领取免费ECS&amp;RDS资源，30分钟完成数据库上云实战！https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
优惠码优惠
目录
相关文章
蓝易云
|
8天前
|
存储 NoSQL Java
使用lock4j-redis-template-spring-boot-starter实现redis分布式锁
通过使用 `lock4j-redis-template-spring-boot-starter`，我们可以轻松实现 Redis 分布式锁，从而解决分布式系统中多个实例并发访问共享资源的问题。合理配置和使用分布式锁，可以有效提高系统的稳定性和数据的一致性。希望本文对你在实际项目中使用 Redis 分布式锁有所帮助。
蓝易云
27 5
蓝易云
|
25天前
|
存储 运维 安全
Spring运维之boot项目多环境(yaml 多文件 proerties)及分组管理与开发控制
通过以上措施，可以保证Spring Boot项目的配置管理在专业水准上，并且易于维护和管理，符合搜索引擎收录标准。
蓝易云
39 2
蓝易云
|
29天前
|
消息中间件 NoSQL Java
Spring Boot整合Redis
通过Spring Boot整合Redis，可以显著提升应用的性能和响应速度。在本文中，我们详细介绍了如何配置和使用Redis，包括基本的CRUD操作和具有过期时间的值设置方法。希望本文能帮助你在实际项目中高效地整合和使用Redis。
蓝易云
45 2
2的n次方_
|
2月前
|
设计模式 前端开发 Java
Spring MVC——项目创建和建立请求连接
MVC是一种软件架构设计模式，将应用分为模型、视图和控制器三部分。Spring MVC是基于MVC模式的Web框架，通过`@RequestMapping`等注解实现URL路由映射，支持GET和POST请求，并可传递参数。创建Spring MVC项目与Spring Boot类似，使用`@RestController`注解标记控制器类。
2的n次方_
39 1
Spring MVC——项目创建和建立请求连接
2的n次方_
|
2月前
|
Java 关系型数据库 MySQL
Maven——创建 Spring Boot项目
Maven 是一个项目管理工具，通过配置 `pom.xml` 文件自动获取所需的 jar 包，简化了项目的构建和管理过程。其核心功能包括项目构建和依赖管理，支持创建、编译、测试、打包和发布项目。Maven 仓库分为本地仓库和远程仓库，远程仓库包括中央仓库、私服和其他公共库。此外，文档还介绍了如何创建第一个 SpringBoot 项目并实现简单的 HTTP 请求响应。
2的n次方_
142 1
Maven——创建 Spring Boot项目
东方睿赢
|
2月前
|
缓存 NoSQL Java
Spring Boot与Redis：整合与实战
【10月更文挑战第15天】本文介绍了如何在Spring Boot项目中整合Redis，通过一个电商商品推荐系统的案例，详细展示了从添加依赖、配置连接信息到创建配置类的具体步骤。实战部分演示了如何利用Redis缓存提高系统响应速度，减少数据库访问压力，从而提升用户体验。
东方睿赢
108 2
智物科技库
|
2月前
|
Java Apache Maven
Java/Spring项目的包开头为什么是com？
本文介绍了 Maven 项目的初始结构，并详细解释了 Java 包命名惯例中的域名反转规则。通过域名反转（如 `com.example`），可以确保包名的唯一性，避免命名冲突，提高代码的可读性和逻辑分层。文章还讨论了域名反转的好处，包括避免命名冲突、全球唯一性、提高代码可读性和逻辑分层。最后，作者提出了一个关于包名的问题，引发读者思考。
智物科技库
73 0
Java/Spring项目的包开头为什么是com？
刘大猫.
|
1月前
|
JavaScript NoSQL Java
CC-ADMIN后台简介一个基于 Spring Boot 2.1.3 、SpringBootMybatis plus、JWT、Shiro、Redis、Vue quasar 的前后端分离的后台管理系统
CC-ADMIN后台简介一个基于 Spring Boot 2.1.3 、SpringBootMybatis plus、JWT、Shiro、Redis、Vue quasar 的前后端分离的后台管理系统
刘大猫.
38 0
codyl
|
缓存 NoSQL Redis
NoSQL之Redis（三） --- Redis在项目中的运用
codyl
3238 0
东方睿赢
|
2月前
|
消息中间件 缓存 NoSQL
Redis 是一个高性能的键值对存储系统，常用于缓存、消息队列和会话管理等场景。
【10月更文挑战第4天】Redis 是一个高性能的键值对存储系统，常用于缓存、消息队列和会话管理等场景。随着数据增长，有时需要将 Redis 数据导出以进行分析、备份或迁移。本文详细介绍几种导出方法：1）使用 Redis 命令与重定向；2）利用 Redis 的 RDB 和 AOF 持久化功能；3）借助第三方工具如 `redis-dump`。每种方法均附有示例代码，帮助你轻松完成数据导出任务。无论数据量大小，总有一款适合你。
东方睿赢
78 6

热门文章

最新文章

  • 1
    Spring-boot+Dubbo应用启停源码分析
  • 2
    SpringMvc+Spring+MyBatis 基于注解整合
  • 3
    Spring(二)之入门示例
  • 4
    包办婚姻的Spring IoC
  • 5
    升级到Spring Cloud 2021.0.3 常见问题
  • 6
    【Spring常见错误】Rocketmq 闪退
  • 7
    Spring源码(二-3)-XML文件的读取-factory-method的使用
  • 8
    【Spring实战】—— 5 设值注入
  • 9
    spring入门
  • 10
    【spring bean】 spring中bean之间的引用以及内部bean
  • 1
    不懂这些，简历上都不敢写自己熟悉Redis
    105
  • 2
    【Golang】国密SM2公钥私钥序列化到redis中并加密解密实战_sm2反编(1)
    165
  • 3
    【redis源码学习】持久化机制，java程序员面试算法宝典pdf
    79
  • 4
    实战：第十一篇：StringRedisTemplate获取redis信息，面试官突击一问
    51
  • 5
    Redis为什么会这么快？Redis到底有多快？【大厂经典面试题】
    459
  • 6
    利用Redis构建高性能的缓存系统
    105
  • 7
    Linux安装Redis（详细教程）
    339
  • 8
    Redis实现数据持久性主要依赖两种机制
    46
  • 9
    Redis中的常用命令非常丰富，涵盖了各种数据类型的基本操作以及服务器管理和维护的相关指令
    60
  • 10
    Redis的主要内存淘汰策略
    84

    • 相关课程

    更多
  • 大数据实战项目：反爬虫系统（Lua+Spark+Redis+Hadoop框架搭建）第一阶段
  • 大数据实战项目：反爬虫系统（Lua+Spark+Redis+Hadoop框架搭建）第三阶段
  • 大数据实战项目 - 反爬虫系统（Lua+Spark+Redis+Hadoop框架搭建）第七阶段
  • Redis入门实战演练
  • 云数据库 Redis 版使用教程
  • Redis数据库入门

    • 相关电子书

    更多
  • Redis集群演化的心路历程——从2.x到3.0时代
  • 微博的Redis定制之路
  • 云数据库Redis版的开源之路

    • 相关实验场景

    更多
  • 如何通过数据库Redis内网访问
  • Tair for Redis数据闪回：任意时间点数据恢复
  • 如何开通Redis的专属集群
  • 从零搭建Spring Boot的Hello World
  • 基于Redis实现在线游戏积分排行榜
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月