redis使用

Redis的使用

一、Redis下载

redis的使用很简单，首先需要下载redis，在本机上或者是在远程服务器上下载均可，推荐使用docker的方式下载redis镜像。

二、spring boot环境配置

首先创建一个web项目，方便测试

maven配置

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>2.1.3.RELEASE</version>
</dependency>

application.properties配置

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

我们只需要配置spring.redis.host和spring.redis.port即可使用，由于他们的默认值分别是localhost和6379，所以如果我们把redis下载到了本地，则什么都不用配置就可以直接使用redis。

三、RedisTemplate与StringRedisTemplate

StringRedisTemplate使用的是StringRedisSerializer来序列化String。

RedisTemplate使用的是JdkSerializationRedisSerializer来序列化对象。

StringRedisTemplate指定的范型是String，因此不能用来存储对象，当存入对象的时候会报错，而RedisTemplate可以存入对象，但是它是以二进制的方式进行存储的，如果不经过序列化，存入的数据完全没有可读性，如果要让数据有可读性，需要我们自己设置序列化的方式。

在实际开发中，大多数情况都是用StringRedisTemplate来操作，如果需要存入对象，先把对象转成jsonString，再存入redis中，使用的时候再转成需要的对象。

在有特定的需求，需要在redis中存入对象的时候，我们一般不用自带的RedisTemplate，因为
默认的这个类挺不好用的，它的范型是<Object, Object>的，因此每次都要写类型转换的代码。所以我们一般自定义一个RedisTemplate，范型是<String, Object>，并设置key和value的序列化方式，综合情况下考虑，key一般使用String的序列化方式，value一般使用jackson的序列化方式。

/**
 * create by bafan 2019/04/24
 * redis配置类
 */
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }

}

Redis工具类

在开发中，一般会自己写工具类来封装RedisTemplate，这里只写了StringRedisTemplate的工具类，RedisTemplate的工具类与之类似。

@Component
public class RedisStringUtils {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**-------------------------------基础----------------------------------------*/

    /**
     * 指定缓存失效时间
     * @param key
     * @param time 时间（秒）
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if(time > 0) {
                return stringRedisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 获取缓存失效时间
     * @param key
     * @return
     */
    public long getExpire(String key) {
        return stringRedisTemplate.getExpire(key);
    }

    /**
     * 判断key是否存在
     * @param key
     * @return
     */
    public boolean hasKey(String key) {
        try {
            return stringRedisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     * @param key
     */
    public void del(String... key) {
        if(key != null && key.length > 0) {
            if(key.length == 1) {
                stringRedisTemplate.delete(key[0]);
            } else {
                stringRedisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    /**-------------------------------String----------------------------------------*/

    /**
     * 获取value
     * @param key
     * @return
     */
    public Object get(String key) {
        return key == null ? null : stringRedisTemplate.opsForValue().get(key);
    }

    /**
     * 缓存放入
     * @param key
     * @param value
     * @return
     */
    public boolean set(String key, String value) {
        try {
            stringRedisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 缓存放入并设置过期时间
     * @param key
     * @param value
     * @param time
     * @return
     */
    public boolean set(String key, String value, long time) {
        try {
            stringRedisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     * @param key
     * @param delta
     * @return
     */
    public long incr(String key, long delta) {
        if(delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return stringRedisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     * @param key
     * @param delta
     * @return
     */
    public long decr(String key, long delta) {
        if(delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return stringRedisTemplate.opsForValue().increment(key, -delta);
    }

}

测试

public class RedisTest {

    @Autowired
    private RedisStringUtils redisStringUtils;

    private User user = new User();

    @Before
    public void before() {
        user.setName("八幡");
        user.setAge(24);
    }

    /**
     * 测试普通字符串
     */
    @Test
    public void test1() {
        redisStringUtils.set("bafan1", "1");
        redisStringUtils.set("bafan2", "hello", 60);
        String bafan1 = (String)redisStringUtils.get("bafan1");
        String bafan2 = (String)redisStringUtils.get("bafan2");
        System.out.println(bafan1 + "..." + bafan2);
        boolean b1 = redisStringUtils.hasKey("bafan1");
        boolean b2 = redisStringUtils.hasKey("bafan3");
        System.out.println(b1 + "..." + b2);
        long expire1 = redisStringUtils.getExpire("bafan1");
        long expire2 = redisStringUtils.getExpire("bafan2");
        System.out.println(expire1 + "..." + expire2);
        redisStringUtils.incr("bafan1", 3l);
        //如果不是数字incr会报错
        //redisStringUtils.incr("bafan2", 3l);
        String bafan3 = (String)redisStringUtils.get("bafan1");
        String bafan4 = (String)redisStringUtils.get("bafan2");
        System.out.println(bafan3 + "..." + bafan4);
        redisStringUtils.decr("bafan1", 2l);
        String bafan5 = (String)redisStringUtils.get("bafan1");
        String bafan6 = (String)redisStringUtils.get("bafan2");
        System.out.println(bafan5 + "..." + bafan6);
        redisStringUtils.expire("bafan1", 100);
        long expire3 = redisStringUtils.getExpire("bafan1");
        System.out.println(expire3);
    }

    /**
     * 测试DTO类
     */
    @Test
    public void test2() {
        redisStringUtils.set("bafan3", JSON.toJSONString(user));
        Object o = redisStringUtils.get("bafan3");
        User user = JSON.parseObject(o.toString(), User.class);
        System.out.println(user.getName() + "..." + user.getAge());
    }

    /**
     * 测试Map
     */
    @Test
    public void test3() {
        Map<String, String> map = new HashMap<>();
        map.put("bafan1", "1");
        map.put("bafan2", "2");
        redisStringUtils.set("bafan4", JSON.toJSONString(map));
        Object o = redisStringUtils.get("bafan4");
        Map<String, String> map1 = JSON.parseObject(o.toString(), Map.class);
        System.out.println(map1);
    }

}