SpringBoot简单操作Redis

一。添加pom依赖

<dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-data-redis</artifactId>

</dependency>

二。application 配置

# Redis 数据库索引（默认为0）

spring.redis.database=0  

# Redis 服务器地址

spring.redis.host=192.168.137.128

# Redis 服务器连接端口

spring.redis.port=6379  

# Redis 服务器连接密码（默认为空）

spring.redis.password=  root

# 连接池最大连接数（使用负值表示没有限制）

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

三。单元测试

1.注入RedisTemplate

     

 @Autowired
 private RedisTemplate redisTemplate;

2.添加单元测试方法

/**
 * 放置缓存
 * */
@Test
public void test() throws Exception {
   //放置缓存
   stringRedisTemplate.opsForValue().set("abc", "测试");
   //获取Redis缓存数据
   ValueOperations<String, String> redisGetValues = stringRedisTemplate.opsForValue();
   System.out.println("Redis值："+redisGetValues.get("abc"));
}

/**
 * 超时失效
 * */
@Test
public void testExpire() throws InterruptedException {
   /*
   * 要缓存的JavaBean必须实现Serializable接口，因为Spring会将对象先序列化再存入 Redis
   * */
   TestUser user=new TestUser(123, "test", "123456");
   ValueOperations<String, TestUser> operations=redisTemplate.opsForValue();
   operations.set("expire", user,100, TimeUnit.MILLISECONDS);
   Thread.sleep(1000);
   boolean exists=redisTemplate.hasKey("test");
   if(exists){
      System.out.println("true");
   }else{
      System.out.println("false");
   }
}
/**
 * 删除数据
 * */
@Test
public void testDelete() {
   ValueOperations<String, TestUser> operations=redisTemplate.opsForValue();
   redisTemplate.opsForValue().set("deletekey", "testDelete");
   redisTemplate.delete("deletekey");
   boolean exists=redisTemplate.hasKey("deletekey");
   if(exists){
      System.out.println("true");
   }else{
      System.out.println("false");
   }
}

/**
 * 放置List
 * */
@Test
public void testList() {
   ListOperations<String, String> list = redisTemplate.opsForList();
   list.leftPush("list","list1");
   list.leftPush("list","list2");
   list.leftPush("list","list3");
   String value=(String)list.leftPop("list");
   System.out.println("list value :"+value.toString());
}

3.封装Redis方法（方便调用）

package com.example.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Service;

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

/**
 * ClassName: RedisService
 * Description: Redis封装类
 * Author Lu.Mrs
 * Date: 2018/12/12下午 4:46
 * Version: 1.0
 */
@Service
public class RedisService {
    private Logger logger = LoggerFactory.getLogger(RedisService.class);
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * set value
     * @param key
     * @param value
     * @return
     */
    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) {
            logger.error("set error: key {}, value {}",key,value,e);
        }
        return result;
    }

    /**
     * set value with expireTime
     * @param key
     * @param value
     * @param expireTime
     * @return
     */
    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) {
            logger.error("set error: key {}, value {},expireTime {}",key,value,expireTime,e);
        }
        return result;
    }

    /**
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     * remove single key
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * batch delete
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * batch delete with pattern
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0)
            redisTemplate.delete(keys);
    }

    /**
     * hash set
     * @param key
     * @param hashKey
     * @param value
     */
    public void hashSet(String key, Object hashKey, Object value){
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        hash.put(key,hashKey,value);
    }

    /**
     * hash get
     * @param key
     * @param hashKey
     * @return
     */
    public Object hashGet(String key, Object hashKey){
        HashOperations<String, Object, Object>  hash = redisTemplate.opsForHash();
        return hash.get(key,hashKey);
    }

    /**
     *  list push
     * @param k
     * @param v
     */
    public void push(String k,Object v){
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(k,v);
    }

    /**
     *  list range
     * @param k
     * @param l
     * @param l1
     * @return
     */
    public List<Object> range(String k, long l, long l1){
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.range(k,l,l1);
    }

    /**
     *  set add
     * @param key
     * @param value
     */
    public void setAdd(String key,Object value){
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key,value);
    }

    /**
     * set get
     * @param key
     * @return
     */
    public Set<Object> setMembers(String key){
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        return set.members(key);
    }

    /**
     * ordered set add
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key,Object value,double scoure){
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key,value,scoure);
    }

    /**
     * rangeByScore
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set<Object> rangeByScore(String key,double scoure,double scoure1){
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rangeByScore(key, scoure, scoure1);
    }
}

4.1 调用时只需注入即可

@Autowired
private RedisService redisService;

@Test
public void testObj(){
   TestUser user=new TestUser(123, "test", "123456");
   boolean testUser = redisService.set("testUser", user);
   if(testUser){
      Object resultUser = redisService.get("testUser");
      System.out.println("user: "+resultUser.toString());
   }
}