redis操作模板

1.  引入pom.xml
   			<!-- redis -->
            <dependency>  
    		    <groupId>org.springframework.boot</groupId>  
    		    <artifactId>spring-boot-starter-redis</artifactId>  
    		    <version>1.4.7.RELEASE</version>
    		</dependency>

2.redis工具类
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;

import com.redis.entity.User;

/**
 * 
 * @author 01375042
 * redis操作数据工具类
 *
 */

@Configuration
@Component
public class RedisUtils {

	@Autowired
    private StringRedisTemplate stringRedisTemplate;
	
	@Autowired
	private RedisTemplate redisTemplate;
	
	//@Resource(name="redisTemplate")
   // private ListOperations<String, String> listOps;
	
	//读取缓存
	public String get(final String key) {
		return redisTemplate.opsForValue().get(key)+"";
	}
 
	//写入缓存
	public boolean set(final String key, String value) {
		boolean result = false;
		try {
			redisTemplate.opsForValue().set(key, value);
			result = true;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}
	
	//写入定义过期缓存
	public boolean setTimeout(final String key, String value) {
		boolean result = false;
		try {
			redisTemplate.opsForValue().set(key, value, 20, TimeUnit.SECONDS);
			result = true;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}
 
	//更新缓存
	public boolean getAndSet(final String key, String value) {
		boolean result = false;
		try {
			redisTemplate.opsForValue().getAndSet(key, value);
			result = true;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}
 
	//删除
	public boolean delete(final String key) {
		boolean result = false;
		try {
			redisTemplate.delete(key);
			result = true;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}
	
	//从右边添加
	public Long rightpush(String name,String value){
		ListOperations<String, String> listOps = redisTemplate.opsForList();
		return listOps.rightPush(name, value);
	}
	
	//查询(从第0个开始查询到最后一个 -1表示最后一个)
	public List<String> getpush(String name){
		ListOperations<String, String> listOps = redisTemplate.opsForList();
		return listOps.range(name, 0, -1);
	}
	
	//修改index表示第几个
	public void updatepush(String name,long index,String value){
		ListOperations<String, String> listOps = redisTemplate.opsForList();
		listOps.set(name, index, value);
	}
	
	//删除 
	/** count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT。
	 *  count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 COUNT 的绝对值。
	 *  count = 0 : 移除表中所有与 VALUE 相等的值
	 */
	public long deletepush(String name,String value){
		ListOperations<String, String> listOps = redisTemplate.opsForList();
		return listOps.remove(name, 0, value);
	}
	
	//批量添加
	public Long rightpushall(String name,List<String> userList){
		ListOperations<String, String> listOps = redisTemplate.opsForList();
		return listOps.rightPushAll(name, userList);
	}
	
	//trim截取集合元素长度，保留长度内的数据。
	public void dotrim(String name,long start,long end){
		ListOperations<String, String> listOps = redisTemplate.opsForList();
		listOps.trim(name, 0, 2);
	}
	
	//插入对象
	public void setUser(User user){
		redisTemplate.opsForValue().set("user", user);
	}
	
	//获取对象
	public User getUser(String user){
		return (User)redisTemplate.opsForValue().get(user);
	}
	
	//集合set
	public void addSet(String key,Object value){
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key,value);
    }
	
	//集合set查询
	public Set<Object> setMembers(String key){
		SetOperations<String, Object> set = redisTemplate.opsForSet();
	    return set.members(key);
	}
	
	//有序集合
	public void zAdd(String key,Object value,double scoure){
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key,value,scoure);
    }
	
	//有序集合获取
	public Set<Object> rangeByScore(String key,double scoure,double scoure1){
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rangeByScore(key, scoure, scoure1);
    }
}

3.测试redis类
import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.redis.entity.User;
import com.redis.service.RedisClientTemplate;
import com.redis.service.RedisUtils;


@Controller
public class TestController {

	@Autowired
	RedisUtils redisUtil;
	
	//redis集群
	@Autowired
	RedisClientTemplate redisClusterTemplate;
	
	@RequestMapping("test")
	@ResponseBody
	public String test(){
		//新增
		boolean bool = redisUtil.set("rediskey", "redisValue1");
		System.out.println("新增=="+bool);
		
		//查询
		String value = redisUtil.get("rediskey");
		System.out.println("查询=="+value+"--不存在的key=="+redisUtil.get("abc"));
		
		//更新
		boolean bool1 = redisUtil.getAndSet("rediskey", "redisValue12");
		System.out.println("修改=="+bool1+",修改后的值="+redisUtil.get("rediskey"));
		
		//删除
		boolean bool2 = redisUtil.delete("rediskey");
		System.out.println("删除=="+bool2);
		//System.out.println("删除后的值=="+redisUtil.get("rediskey"));
		
		//从右边添加
		for (int i = 0; i < 3; i++) {
			long lp = redisUtil.rightpush("test", i+"value");
			System.out.println(lp+"--");
		}
		
		//删除
		long result = redisUtil.deletepush("test", "0value");
		System.out.println("删除了"+result+"个");
		
		//获取pushlist
		List list = redisUtil.getpush("test");
		System.out.println(list.size()+"===");
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		
		//删除所有key为test的数据
		redisUtil.delete("test");
		list = redisUtil.getpush("test");
		System.out.println("删除后=="+list.size());
		
		redisUtil.delete("user");
		//批量插入
		String values = "";
		List<String> userList = new ArrayList<String>();
		for (int i = 0; i < 5; i++) {
			//values=values+i+"userpwd;";
			userList.add(i+"userpwd");
		}
		redisUtil.rightpushall("user", userList);
		
		redisUtil.updatepush("user",1,"updatepwd");
		
		list = redisUtil.getpush("user");
		System.out.println(list.size()+"===截取前");
		//trim截取从第0个到第2个,其他全部删除
		redisUtil.dotrim("user",0,2);
		list = redisUtil.getpush("user");
		System.out.println(list.size()+"===截取后");
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i)+"集合");
		}
		return "1";
	}
	
	//写入缓存过期
	@RequestMapping("setTimeout")
	@ResponseBody
	public synchronized int setTimeout(){
		String key="time";
		String value="out";
		boolean bl = redisUtil.setTimeout(key, value);
		System.out.println("写入缓存过期时间=="+bl);
		return 0;
	}
	
	//获取缓存过期
	@RequestMapping("getTimeout")
	@ResponseBody
	public synchronized String getTimeout(){
		String key="time";
		String value = redisUtil.get(key);
		System.out.println("缓存过期的值"+value);
		return value;
	}
	
	//对象操作
	@RequestMapping("operObject")
	@ResponseBody
	public synchronized int operObject(){
		User user = new User();
		user.setId(1);user.setName("用户名1");user.setPwd("密码1");user.setType("类型1");
		redisUtil.setUser(user);
		user = redisUtil.getUser("user");
		System.out.println(user.getId()+"--"+user.getName()+"--"+user.getPwd()+"--"+user.getType());
		return 1;
	}