开发者社区> 冯文议> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

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

简介: 介绍 本次主要介绍以下内容: 1、SpringMVC集成Redis 2、Spring Boot集成Redis(上) 3、Spring Boot集成Redis(中) 4、Spring Boot集成Redis(下) 5、使用redis为我们提供jar进行封装 6、使用Spring Boot提供的方法进行封装 内容比较多,会花一定的时间进行完善。
+关注继续查看

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提供了哪些方法。

RedisTemplate method 1

RedisTemplate method 2

RedisTemplate method 3

以上是部分截图。

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

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部分

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
一文带你了解Redis持久化完整版本(1)
一文带你了解Redis持久化完整版本
27 0
一文带你了解Redis持久化完整版本(2)
一文带你了解Redis持久化完整版本
34 0
Redis --- 持久化机制(RDB与AOF)
Redis --- 持久化机制(RDB与AOF)
70 0
面试必问的 Redis:RDB、AOF、混合持久化
面试必问的 Redis:RDB、AOF、混合持久化
79 0
聊聊Redis是如何做到“持久化”
前面的一篇文章分布式缓存中间件Redis入门对分布式缓存中间件做了一些简单的介绍,其实关于分布式中间件的内容远不止那些。通过前面的介绍我们知道Redis是一个内存数据库,数据保存在内存中,内存的数据变化是很快的,也容易发生丢失。所以Redis提供了持久化的机制。
96 0
Redis的持久化与数据淘汰策略
Redis的持久化与数据淘汰策略
36 0
一篇文章彻底理解Redis持久化:RDB和AOF
Redis对数据的操作都是基于内存的,当遇到了进程退出、服务器宕机等意外情况,如果没有持久化机制,那么Redis中的数据将会丢失无法恢复。有了持久化机制,Redis在下次重启时可以利用之前持久化的文件进行数据恢复。理解和掌握Redis的持久机制,对于Redis的日常开发和运维都有很大帮助,也是在大厂面试经常被问到的知识点。Redis支持的两种持久化机制:
75 0
Redis持久化的几种方式——RDB深入解析
Redis持久化的几种方式——RDB深入解析
77 0
Redis 的持久化剖析,通俗易懂
Redis 的持久化剖析,通俗易懂
65 0
+关注
冯文议
Java开发者,专注程序设计与开发
26
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
冬季实战营第三期:MySQL数据库进阶实战
立即下载