您的位置：首页 > 数据库 > Redis

springboot+gradle集成redis实现动态存储值

2017-09-23 19:25 615 查看

我的项目是使用的gradle构建的项目，项目使用redis实现共享缓存需要依赖项目jar包

//redis缓存
compile group: 'redis.clients', name: 'jedis', version: '2.9.0'
compile group: 'org.springframework.boot', name: 'spring-boot-starter-redis', version: '1.3.5.RELEASE'
compile group: 'org.springframework.data', name: 'spring-data-redis', version: '1.7.2.RELEASE'

主配置文件application.properties添加一下内容

# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=600000

项目使用redis核心配置RedisConfiguration.java

package com.lxy.config.redis;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

@Configuration
@EnableCaching
public class RedisConfig  extends CachingConfigurerSupport {
/**
* 管理缓存
*/
@Bean
public CacheManager cacheManager(RedisTemplate redisTemplate) {
RedisCacheManager rcm = new RedisCacheManager(redisTemplate);
return rcm;
}
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
{
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
template.setConn
17614
ectionFactory(redisConnectionFactory);
template.setKeySerializer(jackson2JsonRedisSerializer);
template.setValueSerializer(jackson2JsonRedisSerializer);
template.setHashKeySerializer(jackson2JsonRedisSerializer);
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}

}

封装操作redis的工具

package com.lxy.utils;

import com.google.gson.Gson;
import org.springframework.beans.factory.annotation.Autowired;
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.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Component
public class RedisClient {
@Autowired
private RedisTemplate redisTemplate;
private static final int DefaultTime = Integer.valueOf(PropertiesHander.getPropertiesValue("redis.cache.timeOut"));

/**
* 添加key到redis数据库中
*/
public void set(String key, String value) throws Exception {
ValueOperations<String, String> operations = redisTemplate.opsForValue();
operations.set(key, value);
}
public void set(String key, String value,int timeOut) throws Exception {
ValueOperations<String, String> operations = redisTemplate.opsForValue();
int times = 0;
if(timeOut>0){
times = timeOut * 60;
}else {
times = DefaultTime;
}
operations.set(key, value, times, TimeUnit.SECONDS);
}
/**
* 取值key到redis数据库中
*/
public String get(String key) throws Exception  {
ValueOperations<String, String> operations = redisTemplate.opsForValue();
return operations.get(key);
}
/**
* 删除指定key
*/
public void del(String key){
redisTemplate.delete(key);
}
/**
* 保存obj对象到redis数据库
*/
public void setObj(Object obj){
ValueOperations<Object, Object> operations = redisTemplate.opsForValue();
operations.set(obj.getClass().getName(),obj);
}
public void setObj(Object obj,int timeOut) throws Exception {
ValueOperations<Object, Object> operations = redisTemplate.opsForValue();
int times = 0;
if(timeOut>0){
times = timeOut * 60;
}else {
times = DefaultTime;
}
operations.set(obj.getClass().getName(),obj, times, TimeUnit.SECONDS);
}
/**
* 根据指定o获取Object
*/
public <T> T getObj(Object obj,Class<T> clazz){

ValueOperations<Object, Object> operations = redisTemplate.opsForValue();
return (T)operations.get(obj.getClass().getName());
}

/**
* 删除obj对象在redis数据库
*/
public void delObj(Object o){
redisTemplate.delete(o);
}
/**
* Set集合的赋值去取
*/
public void setSetCollections(String key,Set value){
redisTemplate.opsForSet().add(key,value);
}
public String getSetCollections(String key){
String result = new Gson().toJson(redisTemplate.opsForSet().members(key));
return result.substring(1,result.length()-1);
}
public Set<String> getMapKeys(String key){
Set<String>resultMapSet=redisTemplate.opsForHash().keys(key);
return resultMapSet;
}

/**
* Map集合的赋值去取
*/
public void setMapCollections(String key,Map<String,Object> value){
redisTemplate.opsForHash().putAll(key,value);
}
public String getMapCollections(String key){
return new Gson().toJson(redisTemplate.opsForHash().entries(key));
}

/**
* List集合的赋值去取
*/
public void setLists(String key,List list){
redisTemplate.opsForList().leftPush(key, list);
}

public String getListStartEnd(String key,int start,int end){
String result =new Gson().toJson(redisTemplate.opsForList().range(key, start, end));
return result.substring(1,result.length()-1);
}
/**查询key的剩余存活时间*/
public long getKeyExpireTime(String key){
return  redisTemplate.getExpire(key);
}

/**设置key的剩余存活时间*/
public boolean setKeyExpireTime(String key,int timeOut){
long times = 0;
if(timeOut>0){
times = timeOut * 60;
}else {
times = DefaultTime;
}
return  redisTemplate.expire(key,times,TimeUnit.SECONDS);
}
/**判断key是否存在*/
public boolean exitsKey(String key){
Object obj = redisTemplate.execute(new RedisCallback() {
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
return connection.exists(key.getBytes());
}
});
boolean flag=true;
if (obj.toString().equals("false")){
return false;
}
return flag;
}
}

具体的测试接口

package com.lxy.controller;
import com.lxy.commons.Response;
import com.lxy.entity.User;
import com.lxy.utils.GsonUtils;
import com.lxy.utils.RedisClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.*;
@Controller
@RequestMapping({ "/redis" })
public class RedisController {

@Autowired
private RedisClient redisClinet;
/**设置key和value到redis*/
@RequestMapping("/set")
@ResponseBody
public String set(String key, String value) throws Exception{
redisClinet.set(key, value, 10);
return "success";
}
/**根据key获取value*/
@RequestMapping("/get")
@ResponseBody
public String get(String key) throws Exception {
return redisClinet.get(key);
}

/**设置object对象到redis*/
@RequestMapping("/setObj")
@ResponseBody
public String setObj(User user) throws Exception {
redisClinet.setObj(user);
return "success";
}
/**根据key获取Object对象*/
@RequestMapping("/getObj")
@ResponseBody
public String getObj(User user) throws Exception {
return GsonUtils.changeStr(redisClinet.getObj(user,User.class));
}
/**根据key获取set集合*/
@RequestMapping("/setSet")
@ResponseBody
public String setSet(String key) throws Exception {
Set<String> set = new HashSet<String>();
set.add("a");
set.add("b");
set.add("c");
redisClinet.setSetCollections(key,set);
return "success";
}

/**根据key获取set集合*/
@RequestMapping("/getSet")
@ResponseBody
public String getSet(String key) throws Exception {
String resultStr = redisClinet.getSetCollections(key);
List<String> setList = GsonUtils.chanageList(resultStr, List.class);
Set<String> set = new HashSet<String>(setList);
return resultStr+"-------"+GsonUtils.changeStr(set);
}
/**设置map集合到redis*/
@RequestMapping("/setMap")
@ResponseBody
public String setMap(String key) throws Exception {
Map<String,Object> map = new HashMap<String,Object>();
map.put("a","hanson");
map.put("b","loly");
map.put("c","zhangsan");
redisClinet.setMapCollections(key,map);
return "success";
}
/**根据key获取map集合*/
@RequestMapping("/getMap")
@ResponseBody
public String getMap(String key) throws Exception {
String resultStr = redisClinet.getMapCollections(key);
Set<String> keySets = redisClinet.getMapKeys(key);
Map<String,Object> setList = GsonUtils.chanageList(resultStr, Map.class);

return resultStr+"-------"+GsonUtils.changeStr(setList)+"---------"+GsonUtils.changeStr(keySets);
}
/**设置list集合到redis*/
@RequestMapping("/setList")
@ResponseBody
public String setList(String key) throws Exception {
List<String> stringList = new ArrayList<String>();
stringList.add("d");
stringList.add("e");
stringList.add("f");
redisClinet.setLists(key,stringList);
return "success";
}
/**获取key对应的list集合*/
@RequestMapping("/getList")
@ResponseBody
public String getList(String key) throws Exception {
String resultStr = redisClinet.getListStartEnd(key,0,-1);
List<String> setList = GsonUtils.chanageList(resultStr, List.class);
return resultStr+"------ ----"+GsonUtils.changeStr(setList);
}
/**删除key*/
@RequestMapping("/del")
@ResponseBody
public String del(String key) throws Exception {
redisClinet.del(key);
return "被删除的key："+redisClinet.get(key);
}
@RequestMapping("/expire")
@ResponseBody
/**查询key的剩余存活时间*/
public Response getKeyExpireTime(String key){
long expireTime = redisClinet.getKeyExpireTime(key);
return  Response.ok(200,key+"剩余存活时间："+expireTime);
}
@RequestMapping("/exitsKey")
@ResponseBody
/**判断key是否存在*/
public Response exitsKey(String key){
boolean exitsFlag = redisClinet.exitsKey(key);
return  Response.ok(200,key+"是否存在："+exitsFlag);
}

@RequestMapping("/setKeyExpireTime")
@ResponseBody
/**判断key是否存在*/
public Response setKeyExpireTime(String key,int time){
long beforeExpireTime = redisClinet.getKeyExpireTime(key);
redisClinet.setKeyExpireTime(key,time);
long afterExpireTime = redisClinet.getKeyExpireTime(key);
return  Response.ok(200,key+"设置之前剩余时间："+beforeExpireTime+"----设置之后剩余时间："+afterExpireTime);
}
}

windows下安装redis客户端可参考：http://blog.csdn.net/zhousenshan/article/details/49127333

linux下安装redis可如下操作

参考网址：http://www.cnblogs.com/hanyinglong/p/5036558.html

下载地址：http://download.redis.io/releases/redis-3.0.5.tar.gz

提示下图信息证明redis的源码包已经下载成功

安装Unix的Tcl工具，如果不安装的话后期我们将无法对Redis进行测试，完成安装之后make
test会报错

tcl包的下载地址是：http://downloads.sourceforge.net/tcl/tcl8.6.3-src.tar.gz

下载tcl成功的截图如下

在centos下面安装gcc，我们使用yum(包管理器)安装，因为gcc依赖了很多东西，而有些包系统可能已经安装了，有些没有，所以下面的命令最后都执行一遍，在Xshell中执行下面的命令每次中图确认是都输入Y

yuminstall cpp

yuminstall binutils

yuminstall glibc-kernheaders

yuminstall glibc-common

yuminstall glibc-devel

yuminstall gcc

yuminstall make

备注：以上所有的包信息在安装完成的时候都会提示Complete，如果没有是Complete，而是Nothing to do，则说明服务器已经安装了这个包，不需要再次安装，所以没关系，继续执行下一个命令即可。

c.如果安装过程中没有报错，则说明gcc的安装已经完成了，下面继续安装tcl

将上传的tcl包解压，解压之后重命名为tcl，如图所示

tar -zxvf tcl8.6.3-src.tar.gz

mv tcl8.6.3 tcl

cd tcl

d.解压完成之后使用下面的命令安装，命令执行顺序按照我写的即可。

cd unix/

./configure

Make

make install

通过上面几步之后，准备工作已经完成，即可以开始安装redis了。

将上传的redis包解压，解压之后重命名为redis，如图所示：

tar -zxvf redis-3.0.5.tar.gz

mv redis-3.0.5 redis

cd redis

当对包解压完成之后，便可以开始对其进行安装了，安装的命令为(在redis目录下执行)：

执行 make结果图如下

如果执行make出现错误，当再次执行make的话，我们建议，清理一下在执行，命令为：make clean。

下面到 cd src/   make test

make install

最后执行make install，不出现错误的话则说明redis安装成功，如图所示

当安装完redis之后，就需要进行测试，以下简单做一个测试来验证我们的redis是否安装成功。

首先我们启动redis服务，启动和关闭redis服务命令如下：

src/redis-server & 加上&表示使redis以后台程序方式运行

redis-server/usr/local/kencery/redis/redis.conf 启动redis

src/redis-cli shutdown    关闭redis

　输入启动redis的命令，启动redis，如图所示：

当redis启动完成之后，使用netstat -ntlp |grep 6379 查看端口是否在使用中，如果在使用中，则说明安装成功，否则安装没有成功。成功图如下

连接redis并且测试，连接命令为：src/redis-cli，最后的测试结果如图所示：

reids的安装和测试工作全部完成了

给文件添加权限，使用脚本文件可以执行，命令为：chmod755 /etc/init.d/redis

serviceredis start 开启redis服务

serviceredis stop 关闭redis服务

首先设置redis.config中的daemonize为yes,确保守护进行开启,执行以下命令：

vim redis.conf 开启配置文件，找到daemonize属性酒设置为yes，保存并且退出即可。

然后设置开机启动，命令：chkconfig redis on

开机自启动可按照设定即可 http://blog.csdn.net/liqi_q/article/details/78042882

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航