Redis | 尝试封装一个操作工具类

Redis | 尝试封装一个操作工具类

介绍

本次主要介绍以下内容:

1、SpringMVC集成Redis

2、Spring Boot集成Redis(上)

3、Spring Boot集成Redis(中)

4、Spring Boot集成Redis(下)

5、使用redis为我们提供jar进行封装

6、使用Spring Boot提供的方法进行封装

内容比较多,会花一定的时间进行完善。

第一部分:SpringMVC集成Redis

第一步:依赖

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>${redis.version}</version>
        </dependency>

第二步:bean注入

    <!-- 引入jedis的properties配置文件 -->
    <!--如果你有多个数据源需要通过<context:property-placeholder管理,且不愿意放在一个配置文件里,那么一定要加上ignore-unresolvable=“true"-->
    <context:property-placeholder location="classpath:properties/redis.properties" ignore-unresolvable="true" />

    <bean id="jedisPool" class="redis.clients.jedis.JedisPool">
        <constructor-arg name="poolConfig" ref="jedisPoolConfig" />
        <constructor-arg name="host" value="${redis.host}" />
        <constructor-arg name="port" value="${redis.port}" type="int" />
        <constructor-arg name="timeout" value="${redis.timeout}" type="int" />
        <constructor-arg name="password" value="${redis.password}" />
        <constructor-arg name="database" value="${redis.database}" type="int" />
    </bean>

    <bean class="redis.clients.jedis.JedisPoolConfig" id="jedisPoolConfig" />

这样,集成就算告一段落了,什么意思?简单来说,你可以开始编写操作Redis的代码了,所以,我们会放到后面说。

第二部分:Spring Boot集成Redis(上)

这部分主要说,将我们的项目换成Spring Boot,应该怎么操作呢?

有两种操作办法,1、依然通过引入配置文件的办法,简单来说,我们需要写一个配置,加载配置文件。2、也就是下面要说的。

jar还是之前那个。

application.yml 中添加如下配置:

# redis
redis:
  host: 
  port: 6379
  timeout: 3
  password: 
  poolMaxTotal: 10
  poolMaxIdle: 10
  poolMaxWait: 3

配置代码:

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * @author Wenyi Feng
 * @since 2018-12-04
 */
@Component
@ConfigurationProperties(prefix = "redis")
@Data
public class RedisConfig {
    private String host;
    private int port;
    private int timeout;// 秒
    private String password;
    private int poolMaxTotal;
    private int poolMaxIdle;
    private int poolMaxWait;// 秒
}

构造连接池:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * @author Wenyi Feng
 * @since 2018-12-04
 */
@Service
public class RedisPoolFactory {

    @Autowired
    RedisConfig redisConfig;

    @Bean
    public JedisPool jedisPoolFactory() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(redisConfig.getPoolMaxIdle());
        jedisPoolConfig.setMaxTotal(redisConfig.getPoolMaxTotal());
        jedisPoolConfig.setMaxWaitMillis(redisConfig.getPoolMaxWait() * 1000);
        return new JedisPool(jedisPoolConfig, redisConfig.getHost(), redisConfig.getPort(),
                redisConfig.getTimeout() * 1000,
                redisConfig.getPassword(), 0);
    }

}

第三部分:Spring Boot集成Redis(中)

使用Spring Boot的初衷就是简化我们的配置,那我们该怎么做呢?

第一步:依赖

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

第二步:配置

spring:
  redis:
    host: 
    port: 6379
    password: 

这样就行了。
什么?这样就行了?
没错。
当然,操作代码,我们放到后面说。

第四部分:Spring Boot集成Redis(下)

上面是单台Redis,那么集群应该怎么做呢?如下:

spring:
  redis:
    host: 
    port: 6379
    password: 
    cluster:
      nodes: 

使用英文逗号(,)隔开

第五部分:使用redis为我们提供jar进行封装

首先,要明确,Redis十分强大,所以,也是相当负责。当然你也可以觉得很简单。

我们知道redis是以key-value的形式保存数据的,那么这里就有一个问题,集合对象应该怎么保存呢?

所以,这里提供两种解决思路:一是将其转成String进行保存(这是Spring推荐的);二是使用byte[](这是Redis推荐的)。

好了,话不多少,我们开始撸代码。

依赖:

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>${redis.version}</version>
        </dependency>

方案1:

    /**
     * 获取数据
     * @param prefix 前缀
     * @param key
     * @param clazz
     * @param <T>
     * @return
     */
    public <T> T get(KeyPrefix prefix, String key, Class<T> clazz) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();

            // 真正的key
            String realKey = prefix.getPrefix() + key;
            String str = jedis.get(realKey);
            return stringToBean(str, clazz);
        } finally {
            returnToPool(jedis);
        }
    }

    /**
     * 设置对象
     * @param prefix 前缀
     * @param key
     * @param obj
     * @param <T>
     * @return
     */
    public <T> boolean set(KeyPrefix prefix, String key, T obj) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            String str = beanToString(obj);
            if (StringUtils.isEmpty(str)) {
                return false;
            }
            // 生成真正的key
            String realKey = prefix.getPrefix() + key;
            int seconds = prefix.expireSeconds();
            if (seconds <= 0) {
                jedis.set(realKey, str);
            } else {
                jedis.setex(realKey, seconds, str);
            }
            return true;
        } finally {
            returnToPool(jedis);
        }
    }

方案2:

    /**
     * 将值存到Redis中
     * @param key 唯一标识
     * @param value 二进制格式数据
     * @return 返回二进制格式数据,表示操作成功,反之,操作失败
     */
    public byte[] set(byte[] key, byte[] value) {
        Jedis jedis = getResource();
        try {
            jedis.set(key, value);
            return value;
        } finally {
            jedis.close();
        }
    }

    /**
     * 通过一个key获取value
     * @param key 唯一标识
     * @return 二进制格式数据
     */
    public byte[] get(byte[] key) {
        Jedis jedis = getResource();
        try {
            return jedis.get(key);
        } finally {
            jedis.close();
        }
    }

方案一和方案二操作是一样的,不同的处理思路不一样,一个将对象转成字符串(启发:JSON),一个是将对象当作数据,进行序列化进行存储和读取。

第六部分:使用Spring Boot提供的方法进行封装

前面你是不是觉得好简单啊,其实我一直也是这么认为的。下面我们看看Spring是如何为我们解读Redis的。

首先我们知道Spring为我们提供了两个东东。

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Autowired
    private RedisTemplate redisTemplate;

这下,你也应该明白我 前面说的了吧,Spring居然为String单独写了一个,而代码不足10行。

我们看看RedisTemplate提供了哪些方法。

Redis | 尝试封装一个操作工具类

Redis | 尝试封装一个操作工具类

Redis | 尝试封装一个操作工具类

以上是部分截图。

我们来尝试写一个简单的例子:

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

import javax.annotation.Resource;

/**
 * @author Wenyi Feng
 * @since 2018-12-04
 */
@Service
public class ByteRedisService {

    @Resource
    private RedisTemplate<byte[], byte[]> redisTemplate;

    public void set(byte[] key, byte[] value) {
        redisTemplate.opsForValue().set(key, value);
    }

    public byte[] get(byte[] key) {
        return redisTemplate.opsForValue().get(key);
    }

}

参考文档

[1] Shiro安全框架入门 - Redis部分

[2] Java秒杀系统方案优化 高性能高并发实战 - Redis部分

上一篇:数据中心运维管理体系的数字化转型(演讲实录)


下一篇:lzg_ad:如何自定义Shell组件