Redis(单机&集群)Pipeline工具类

最新推荐文章于 2024-07-29 09:51:19 发布
最新推荐文章于 2024-07-29 09:51:19 发布
阅读量1.7k 收藏 4
点赞数 1
分类专栏： Redis 文章标签： pipeline工具类 redis的pipeline pipeline使用示例 pipeline操作集群 pipeline
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/justry_deng/article/details/110299579
版权

笔者语录： 我只想让一切变得简单。
提示： 本文会先给出测试代码及测试效果(使用示例)，然后再贴工具类代码。

性能对比(简单)测试(含使用示例)：

测试单机redis进行普通操作与pipeline操作：

  • 测试代码
    在这里插入图片描述

  • 测试结果
    在这里插入图片描述

测试集群redis进行普通操作与pipeline操作value：

  • 测试代码
    在这里插入图片描述

  • 测试结果
    在这里插入图片描述

测试集群redis进行普通操作与pipeline操作hash：

  • 测试代码
    在这里插入图片描述

  • 测试结果
    在这里插入图片描述

Pipeline工具类：

  • 相关(核心)依赖：

    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <exclusions>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

  • Pipeline工具类

    import com.niantou.redispipeline.author.JustryDeng;
import lombok.extern.slf4j.Slf4j;
import net.jcip.annotations.ThreadSafe;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.data.redis.connection.RedisClusterConnection;
import org.springframework.data.redis.connection.RedisCommands;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisClusterConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.lang.NonNull;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;
import redis.clients.jedis.BinaryJedisCluster;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisClusterConnectionHandler;
import redis.clients.jedis.JedisClusterInfoCache;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.Response;
import redis.clients.jedis.exceptions.JedisMovedDataException;
import redis.clients.jedis.exceptions.JedisNoReachableClusterNodeException;
import redis.clients.jedis.util.JedisClusterCRC16;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * redis pipeline 工具类RedisTemplate
 *
 * @author {@link JustryDeng}
 * @since 2020/11/13 2:41:40
 */
@Slf4j
@Component
@ThreadSafe
@SuppressWarnings("unused")
public final class RedisPipelineUtil implements ApplicationContextAware {
    
    private static RedisTemplate<?, ?> defaultRedisTemplate;

    /**
     * 获取key序列化器
     *
     * @return  key序列化器
     */
    @NonNull
    public static RedisSerializer<Object> getKeySerializer() {
        //noinspection unchecked
        return (RedisSerializer<Object>) defaultRedisTemplate.getKeySerializer();
    }

    /**
     * 获取value序列化器
     *
     * @return  value序列化器
     */
    @NonNull
    public static RedisSerializer<Object> getValueSerializer() {
        //noinspection unchecked
        return (RedisSerializer<Object>) defaultRedisTemplate.getValueSerializer();
    }
    
    /**
     * 获取hash-key序列化器
     *
     * @return  hash-key序列化器
     */
    @NonNull
    public static RedisSerializer<Object> getHashKeySerializer() {
        //noinspection unchecked
        return (RedisSerializer<Object>)defaultRedisTemplate.getHashKeySerializer();
    }
    
    /**
     * 获取hash-value序列化器
     *
     * @return  hash-value序列化器
     */
    @NonNull
    public static RedisSerializer<Object> getHashValueSerializer() {
        //noinspection unchecked
        return (RedisSerializer<Object>)defaultRedisTemplate.getHashValueSerializer();
    }
    
    /**
     * 流水线批量操作(单节点)
     * <p>
     * 注: SessionCallback是对RedisCallback的进一步封装， 不过我们都已经使用pipeline了， 那干脆直接用RedisCallback好了。
     *
     * @param biConsumer
     *            批量操作逻辑
     * @param paramList
     *            biConsumer用到的参数
     * @return  结果集
     */
    public static <R, P> List<R> pipeline4Standalone(BiConsumer<RedisCommands, P> biConsumer, final List<P> paramList) {
        //noinspection unchecked
        return (List<R>) defaultRedisTemplate.executePipelined((RedisCallback<R>) connection -> {
            for (P p : paramList) {
                biConsumer.accept(connection, p);
            }
            return null;
        }, defaultRedisTemplate.getValueSerializer());
    }

    /**
     * 流水线批量操作(单节点)
     * <p>
     * 注: SessionCallback是对RedisCallback的进一步封装， 不过我们都已经使用pipeline了， 那干脆直接用RedisCallback好了。
     *
     * @param redisTemplate
     *            操作模板
     * @param biConsumer
     *            批量操作逻辑
     * @param paramList
     *            biConsumer用到的参数集合
     * @return  结果集
     */
    public static <R, P> List<R> pipeline4Standalone(RedisTemplate<?, ?> redisTemplate, BiConsumer<RedisCommands, P> biConsumer, final List<P> paramList) {
        //noinspection unchecked
        return (List<R>) redisTemplate.executePipelined((RedisCallback<R>) connection -> {
            for (P p : paramList) {
                biConsumer.accept(connection, p);
            }
            return null;
        }, redisTemplate.getValueSerializer());
    }
    
    /**
     * 由于字符串使用的相对较多， 这里官(本)方(人)直接对字符串提供出来一个操作
     * <p>
     * @see RedisPipelineUtil#pipeline4ClusterSimpleStr(RedisTemplate, BiFunction, List)
     */
    public static <R> List<R> pipeline4ClusterSimpleStr(BiFunction<Pipeline, PipelineParamSupplier<String>, Response<R>> biFunction,
                                                        List<String> paramList)
                                                        throws JedisMovedDataException {
        return RedisPipelineUtil.pipeline4ClusterSimpleStr(defaultRedisTemplate, biFunction, paramList);
    }
    
    /**
     * @see RedisPipelineUtil#pipeline4Cluster(JedisCluster, BiFunction, List)
     */
    public static <R> List<R>  pipeline4ClusterSimpleStr(@NonNull RedisTemplate<?, ?> redisTemplate,
                                                         BiFunction<Pipeline, PipelineParamSupplier<String>,
                                                         Response<R>> biFunction, List<String> paramList)
                                                         throws JedisMovedDataException {
        RedisConnectionFactory redisConnectionFactory = redisTemplate.getConnectionFactory();
        Assert.notNull(redisConnectionFactory, "redisConnectionFactory cannot be null");
        RedisClusterConnection clusterConnection = redisConnectionFactory.getClusterConnection();
        if (!(clusterConnection instanceof JedisClusterConnection)) {
            throw new UnsupportedOperationException("cannot support RedisClusterConnection [" +  clusterConnection.getClass().getName() + "]");
        }
        JedisCluster jedisCluster = ((JedisClusterConnection) clusterConnection).getNativeConnection();
        @SuppressWarnings("unchecked") RedisSerializer<Object> keySerializer = (RedisSerializer<Object>)redisTemplate.getKeySerializer();
        return RedisPipelineUtil.pipeline4ClusterSimpleStr(jedisCluster, keySerializer, biFunction, paramList);
    }
    
    /**
     * 为保证keySerializer与jedisCluster是配套的，这里将此方法私有化，不对外提供
     * <p>
     * @see RedisPipelineUtil#pipeline4Cluster(JedisCluster, BiFunction, List)
     */
    private static <R> List<R> pipeline4ClusterSimpleStr(@NonNull JedisCluster jedisCluster, RedisSerializer<Object> keySerializer,
                                                         BiFunction<Pipeline, PipelineParamSupplier<String>, Response<R>> biFunction,
                                                         List<String> paramList)
            throws JedisMovedDataException {
        List<StringSelfSupplier> supplierParamList = paramList.stream().map(x -> new StringSelfSupplier(x, keySerializer)).collect(Collectors.toList());
        return RedisPipelineUtil.pipeline4Cluster(jedisCluster, biFunction, supplierParamList);
    }
    
    /**
     * @see RedisPipelineUtil#pipeline4Cluster(RedisTemplate, BiFunction, List)
     */
    public static <P extends PipelineParamSupplier<T>, T, R> List<R> pipeline4Cluster(BiFunction<Pipeline, PipelineParamSupplier<T>,
                                                                                      Response<R>> biFunction, List<P> paramList)
                                                                                      throws JedisMovedDataException {
        return RedisPipelineUtil.pipeline4Cluster(defaultRedisTemplate, biFunction, paramList);
    }
    
    /**
     * @see RedisPipelineUtil#pipeline4Cluster(JedisCluster, BiFunction, List)
     */
    public static <P extends PipelineParamSupplier<T>, T, R> List<R> pipeline4Cluster(@NonNull RedisTemplate<?, ?> redisTemplate,
                                                                                      BiFunction<Pipeline, PipelineParamSupplier<T>, Response<R>> biFunction,
                                                                                      List<P> paramList)
                                                                                      throws JedisMovedDataException {
        RedisConnectionFactory redisConnectionFactory = redisTemplate.getConnectionFactory();
        Assert.notNull(redisConnectionFactory, "redisConnectionFactory cannot be null");
        RedisClusterConnection clusterConnection = redisConnectionFactory.getClusterConnection();
        if (!(clusterConnection instanceof JedisClusterConnection)) {
            throw new UnsupportedOperationException("cannot support RedisClusterConnection [" +  clusterConnection.getClass().getName() + "]");
        }
        return RedisPipelineUtil.pipeline4Cluster(((JedisClusterConnection) clusterConnection).getNativeConnection(), biFunction, paramList);
    }
    
    /**
     * (使用JedisCluster，实现)流水线批量操作(集群)
     *
     * @param jedisCluster
     *            JedisCluster实例
     * 其余参数
     * @see JedisClusterPipeline#pipeline4Cluster(BiFunction, List)
     */
    public static <P extends PipelineParamSupplier<T>, T, R> List<R> pipeline4Cluster(@NonNull JedisCluster jedisCluster,
                                                                                      BiFunction<Pipeline, PipelineParamSupplier<T>,
                                                                                      Response<R>> biFunction, List<P> paramList)
                                                                                      throws JedisMovedDataException {
        JedisClusterPipeline jedisClusterPipeline = new JedisClusterPipeline(jedisCluster);
        return jedisClusterPipeline.pipeline(biFunction, paramList);
    }
    
    @Override
    @SuppressWarnings("rawtypes")
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        ObjectProvider<PipelineDefaultRedisTemplateProvider> defaultRedisTemplateProvider = applicationContext.getBeanProvider(PipelineDefaultRedisTemplateProvider.class);
        PipelineDefaultRedisTemplateProvider provider = defaultRedisTemplateProvider.getIfAvailable();
        if (provider != null) {
            RedisTemplate<?, ?> obtainedRedisTemplate = provider.obtainDefaultRedisTemplate();
            RedisPipelineUtil.defaultRedisTemplate = obtainedRedisTemplate;
            log.info(" use [{}] as the default RedisPipelineUtil's RedisTemplate", obtainedRedisTemplate);
        } else {
            // 初始化
            Map<String, RedisTemplate> beansOfType = applicationContext.getBeansOfType(RedisTemplate.class);
            Map.Entry<String, RedisTemplate> redisTemplateEntry = beansOfType.entrySet().stream()
                    .findFirst().orElseThrow(() -> new IllegalArgumentException(" cannot find any RedisTemplate"));
            //noinspection
            RedisPipelineUtil.defaultRedisTemplate = redisTemplateEntry.getValue();
            log.info(" use [{}] as the default RedisPipelineUtil's RedisTemplate", redisTemplateEntry.getKey());
        }
    }
    
    /**
     * jedis使用pipeline操作redis-cluster辅助类
     *
     * 参考并整理自
     *     <a href="https://blog.csdn.net/youaremoon/article/details/51751991?utm_medium=distribute.pc_relevant.none-task-blog-searchFromBaidu-2.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-searchFromBaidu-2.control"/>
     *     <a href="https://www.cnblogs.com/xiaodf/p/11002184.html"/>
     *     <a href="https://blog.csdn.net/xiaoliu598906167/article/details/82218525?utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2~all~first_rank_v2~rank_v25-10-82218525.nonecase&utm_term=pipeline%20redis%20%E8%BF%94%E5%9B%9E%E5%80%BC&spm=1000.2123.3001.4430"/>
     *
     * @author {@link JustryDeng}
     * @since 2020/11/27 16:29:59
     */
    static class JedisClusterPipeline {
        
        private final JedisClusterConnectionHandler connectionHandler;
        
        private final JedisClusterInfoCache infoCache;
    
        public JedisClusterPipeline(JedisCluster jedisCluster) {
            try {
                Field connectionHandlerField = BinaryJedisCluster.class.getDeclaredField("connectionHandler");
                boolean accessible = connectionHandlerField.isAccessible();
                connectionHandlerField.setAccessible(true);
                this.connectionHandler = (JedisClusterConnectionHandler) connectionHandlerField.get(jedisCluster);
                connectionHandlerField.setAccessible(accessible);
                
                Field cacheField = JedisClusterConnectionHandler.class.getDeclaredField("cache");
                accessible = cacheField.isAccessible();
                cacheField.setAccessible(true);
                this.infoCache = (JedisClusterInfoCache) cacheField.get(connectionHandler);
                cacheField.setAccessible(accessible);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    
        /**
         * (使用JedisCluster，实现)流水线批量操作(集群)
         * <p>
         * 注: 【据说】对集群redis进行pipeline, Jedis比Lettuce快。
         * <p>
         * 泛型说明
         * <ul>
         *     <li>P：操作参数， 其需要实现{@link PipelineParamSupplier<T>}, 以获得 1.redis-key  2.最终进行pipeline的操作参数</li>
         *     <li>T：最终的pipeline操作参数</li>
         *     <li>R: 为返回的数据集合泛型</li>
         * </ul>
         *
         * @param biFunction
         *            批量操作逻辑
         * @param paramList
         *            biFunction会用到的参数
         * @throws JedisMovedDataException
         *            key对应的slot槽点变化时抛出
         * @return  结果集
         */
        <P extends PipelineParamSupplier<T>, T, R> List<R> pipeline(BiFunction<Pipeline, PipelineParamSupplier<T>, Response<R>> biFunction,
                                                                           List<P> paramList) throws JedisMovedDataException {
            // 从paramList中抽取到对应的redis-key集合
            Map<byte[], P> redisKeyParamMap = paramList.stream().collect(Collectors.toMap(P::getRedisKey, Function.identity()));
            Set<byte[]> allKeys = redisKeyParamMap.keySet();
            Map<JedisPool, List<byte[]>> poolKeys = new HashMap<>(8);
            // 刷新集群信息
            connectionHandler.renewSlotCache();
            for (byte[] key : allKeys) {
                int slot = JedisClusterCRC16.getSlot(key);
                JedisPool jedisPool = getJedisPoolFromSlot(slot);
                if (poolKeys.containsKey(jedisPool)) {
                    List<byte[]> keys = poolKeys.get(jedisPool);
                    keys.add(key);
                } else {
                    List<byte[]> keys = new ArrayList<>();
                    keys.add(key);
                    poolKeys.put(jedisPool, keys);
                }
            }
            int size = allKeys.size();
            List<R> result = new ArrayList<>(size);
            List<Response<R>> responseList = new ArrayList<>(size);
            poolKeys.forEach((JedisPool jedisPool, List<byte[]> keys) -> {
                Jedis jedis = jedisPool.getResource();
                Pipeline pipeline = jedis.pipelined();
                try {
                    keys.forEach(key -> responseList.add(biFunction.apply(pipeline, redisKeyParamMap.get(key))));
                } finally {
                    try {
                        pipeline.close();
                    } catch (Exception e) {
                        log.error(e.getMessage());
                    }
                    try {
                        jedis.close();
                    } catch (Exception e) {
                        log.error(e.getMessage());
                    }
                }
            });
            responseList.forEach(response -> result.add(response.get()));
            return result;
        }
    
        /**
         * 根据槽点获取要对应使用的JedisPool
         */
        private JedisPool getJedisPoolFromSlot(int slot) {
            JedisPool connectionPool = infoCache.getSlotPool(slot);
            if (connectionPool != null) {
                // It can't guaranteed to get valid connection because of node assignment
                return connectionPool;
            } else {
                // It's abnormal situation for cluster mode, that we have just nothing for slot, try to rediscover state
                // 刷新集群信息
                connectionHandler.renewSlotCache();
                connectionPool = infoCache.getSlotPool(slot);
                if (connectionPool != null) {
                    return connectionPool;
                } else {
                    throw new JedisNoReachableClusterNodeException("No reachable node in cluster for slot " + slot);
                }
            }
        }
    }
    
    /**
     * 可指定{@link RedisPipelineUtil#defaultRedisTemplate}
     * <p>
     * 将会优先使用容器中被RedisTemplate4Pipeline标识了的RedisTemplate作为{@link RedisPipelineUtil#defaultRedisTemplate}，
     * 如果没有，则以容器中第一个RedisTemplate作为{@link RedisPipelineUtil#defaultRedisTemplate}
     *
     * @author {@link JustryDeng}
     * @since 2020/12/7 12:40:04
     */
    public interface PipelineDefaultRedisTemplateProvider {
        
        /**
         * 指定{@link RedisPipelineUtil#defaultRedisTemplate}
         *
         * @return  要设置的{@link RedisPipelineUtil#defaultRedisTemplate}
         */
        RedisTemplate<?, ?> obtainDefaultRedisTemplate();
    }
    
    /**
     * Jedis操作redis-cluster时， pipeline操作参数提供器
     *
     * @author {@link JustryDeng}
     * @since 2020/11/28 16:45:40
     */
    public interface PipelineParamSupplier<T> {
        
        /**
         * 获取(序列化后的)redis key
         * <p>
         * P.S. 在使用Pipeline操作集群时，redis key使用这个方法获取。
         * <p>
         * 注: 这里之所以要将【获取redis key】抽取为一个方法，是因为相关逻辑中有多个地方会用到。 如果这些地方在将key对象序列化为byte[]时，
         *     采用了不同的序列化方式， 那么可能存在数据槽slot定位不一致的问题， 进而(因代码不当)引起JedisMovedDataException异常。
         *     为了避免上述问题，这里将获取redis-key的操作，抽取统一。
         *
         * @return  redis key
         */
        byte[] getRedisKey();
    
        /**
         * 获取pipeline操作需要的参数
         * <p>
         *  P.S. 在使用Pipeline操作集群时，redis key使用这个方法获取。
         * @return pipeline操作参数
         */
        T getParam();
    }
    
    
    /**
     * 官(本)方(人)对常用的字符串提供PipelineParamSupplier实现
     *
     * @author {@link JustryDeng}
     * @since 2020/11/25 22:06:23
     */
    public static class StringSelfSupplier implements PipelineParamSupplier<String> {
        
        private final String str;
        
        private final RedisSerializer<Object> keySerializer;
        
        public StringSelfSupplier(String str, RedisSerializer<Object> keySerializer) {
            this.str = str;
            this.keySerializer = keySerializer;
        }
        
        @Override
        public byte[] getRedisKey() {
            return keySerializer.serialize(getParam());
        }
        
        @Override
        public String getParam() {
            return this.str;
        }
    }
}

pipeline工具类，简单编写完毕！

^_^ 如有不当之处，欢迎指正

^_^ 参考链接
         https://blog.csdn.net/youaremoon…
         https://www.cnblogs.com/xiaodf…
         https://blog.csdn.net/xiaoliu598906167…

^_^ 测试代码托管链接
         https://github.com/JustryDeng…redis-pipeline

^_^ 本文已经被收录进《程序员成长笔记》 ，笔者JustryDeng

justry_deng
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
redis cluster使用pipeline
aisu_yan的博客
12-11 847
redis cluster使用pipeline为什么cluster无法使用pipeline基于redisCluster整合pipeline设计思路代码实现 为什么cluster无法使用pipeline 主要是因为redis-cluster的hash分片。具体的redis命令，会根据key计算出一个槽位（slot）,然后根据槽位去特定的节点redis上执行操作。那么pipeline中每个单独的操作，...
Redis系列(十八)、Redis中的管道pipeline操作(Python)
王义凯 的博客
07-09 6527
Redis默认每次执行请求都会创建和断开一次连接池的操作，如果想执行多条命令的时候会在这件事情上消耗过多的时间，因此我们可以使用Redis的管道来一次性发送多条命令并返回多个结果，节约发送命令和创建连接的时间提升效率。
redispipeLine
08-22
redis pipleLine
Redis中pipeline(管道)详解
最新发布
2301_76166241的博客
07-29 1908
对于服务端来说，所需要的是能够处理一个客户端通过同一个TCP连接发来的多个命令，可以理解为，这里将多个命令切分，和处理单个命令一样，Redis就是这样处理的。管道是一种在Redis中提高命令批量执行效率的机制，通过将多个命令一次性发送到服务器并一次性接收响应，减少了网络通信的开销，提高了命令执行的效率。当使用Pipeline时，它允许多个命令的读通过一次read()操作，多个命令的应答使用一次write()操作，它允许客户端可以一次发送多条命令，而不等待上一条命令执行的结果。管道可以用于批量执行多个操作。
Java使用Pipeline对Redis批量读写（hmset&hgetall）
z69183787的专栏
08-30 5514
摘要 Java使用Pipeline对Redis批量读写（hmset&hgetall） 一般情况下，Redis Client端发出一个请求后，通常会阻塞并等待Redis服务端处理，Redis服务端处理完后请求命令后会将结果通过响应报文返回给Client。 这有点类似于HBase的Scan，通常是Client端获取每一条记录都是一次RPC调用服务端。 在Redis中，有没有类似HB
Redis工具类的封装
ycd500756的博客
07-27 1024
&amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;redis.clients&amp;lt;/groupId&amp;gt; &amp;lt;artifactId&amp;gt;jedis&amp;lt;/artifactId&amp;gt; &amp;lt;version&amp;gt;2.6.0&amp;lt;/version&amp
redis基础简介（六）- jedis使用管道（pipeline）对redis进行读写（使用hmset、hgetall测试）
热门推荐
kinglyjn的博客
01-04 1万+
一般情况下，Redis Client端发出一个请求后，通常会阻塞并等待Redis服务端处理，Redis服务端处理完后请求命令后会将结果通过响应报文返回给Client。这有点类似于HBase的Scan，通常是Client端获取每一条记录都是一次RPC调用服务端。在Redis中，有没有类似HBase Scanner Caching的东西呢，一次请求，返回多条记录呢？有，这就是Pipline。官方介绍 h
redis集群优化，JedisCluster实现Pipeline功能，进而实现批处理
BackToMe的博客
11-19 1310
前提 redis在集群模式下无法使用Pipeline进行批处理，在一定生产环境下降低了开发效率，于是手写了一个pipeline处理工具，以实现一个基础的批处理 我们知道，普通的情况下，redis client与server之间采用的是请求应答的模式，即： Client: command1 Server: response1 Client: command2 Server: response2...
redisUtils工具类的使用
04-26
RedisUtils工具类是Java开发中常见的一种封装了Redis操作的工具类，主要用于简化Redis数据库的存取操作。Redis是一个高性能的键值存储系统，广泛应用于缓存、消息队列、分布式锁等多种场景。在实际开发中，为了提高...
Redis精通系列——Pipeline（管道）
2401_84010402的博客
03-31 1281
对于很多初中级Android工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。整理的这些架构技术希望对Android开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。下面是部分资料截图，诚意满满：特别适合有开发经验的Android程序员们学习。不论遇到什么困难，都不应该成为我们放弃的理由！如果你看到了这里，觉得文章写得不错就给个赞呗？《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，
RedisCluster使用pipeline批量读取数据
大JAVA解决方案
05-25 1999
Vi_NSN 2017-12-03 21:38:40 7351 已收藏 1 展开 　因为公司的Redis是Cluster的，一共有三台主机，有个需求是同时读取三千条数据，因为是Cluster，所以没办法直接使用mget。 　目前在网上找到的方法有两种，一种是写入时处理，一种是读取时处理。 　先说一下RedisCluster针对每条数据的写入的方法。RedisCluster一共有16384个slot(槽位)，cluster每一个节点分管一部分slot。当有数据写入时，当用户put或者是get一个数据...
springboot+redis单机与集群
06-10
代码版 springboot+redis单机与集群
jedis调用redis之pipeline
03-10 2698
package com.alex.xiyoubang;import java.util.Date;import redis.clients.jedis.Jedis; import redis.clients.jedis.Pipeline;public class jedisPipeline { static Jedis jedis = new Jedis("192.168.1.171", 63
Redis JedisCluster 中使用PipeLine
caokai1992的专栏
07-08 4874
Redis、Java
redis批量处理工具pipeline
IT之一小佬的博客
01-06 3130
redis批量处理工具pipeline
Redis 批量操作之pipeline
lonely_bin的博客
08-29 1258
业务场景 最近项目中场景需要get一批key的value，因为redis的get操作(不单单是get命令)是阻塞的，如果循环取值的话，就算是内网，耗时也是巨大的。所以想到了redis的pipeline命令。 pipeline简介 非pipeline：client一个请求，redis server一个响应，期间client阻塞 Pipeline：redis的管道命令，允许client将多个请求依次发...
Redis精通系列——Pipeline，少儿编程java教程
m0_64384302的博客
12-07 300
Redis是一种基于客户端-服务端模型以及请求/响应的TCP服务。一次Redis客户端发起的请求，经过服务端的响应后，大致会经历如下的步骤： 客户端发起一个（查询/插入）请求，并监听socket返回，通常情况都是阻塞模式等待Redis服务器的响应 服务端处理命令，并且返回处理结果给 《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》 【docs.qq.com/doc/DSmxTbFJ1cmN1R2dB】 完整内容开源分享 客户端 客户端接收到服务的返回结果
分布式锁之Redisson
qq_36808015的博客
12-01 178
基于Redis、异步、无锁和Netty的高性能框架 官方网站:https://github.com/redisson/redisson 1、引入jar包 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.14.0</version> </dependency&g..
Redis集群api和集群状态下如何使用pipeline
lihongtai的专栏
12-17 1127
0.准备工作 pom文件 &lt;dependency&gt; &lt;groupId&gt;redis.clients&lt;/groupId&gt; &lt;artifactId&gt;jedis&lt;/artifactId&gt; &lt;version&gt;2.9.0&lt;/version&g
CentOS7下Redis单机与集群部署教程
主要内容涵盖了单机安装Redis、设置Redis主从以及构建Redis分片集群。 ### Redis单点部署 Redis单点部署是基础的安装方式，适用于简单场景或测试环境。在CentOS7上部署Redis单点主要步骤如下： 1. **安装依赖**：...
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值