关于JedisCluster不支持Pipeline操作的解决方案

版权声明：本文为博主原创文章，遵循 CC 4.0 by-sa 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EndTheme_Xin/article/details/84623063
一、背景
业务需要，把redis单结点改为集群，在对代码进行测试的时候发现了，原本使用jedis的批量操作pipeline，到了集群的时候不可用了。报了org.springframework.data.redis.connection.jedis.JedisClusterConnection的错误。

即pipeline是不支持在集群模式下使用的。

于是乎，只能技能PipelineBase接口，重写这个方法了。

二、代码

JedisCluster.java(获取jedis集群实体类)
 

@Bean
    public JedisCluster getJedisCluster() {
        String[] serverArray = clusterNodes.split(",");//获取服务器数组
        Set<HostAndPort> nodes = new HashSet<>();
 
        for (String ipPort : serverArray) {
            String[] ipPortPair = ipPort.split(":");
            nodes.add(new HostAndPort(ipPortPair[0].trim(), Integer.valueOf(ipPortPair[1].trim())));
        }
 
        return new JedisCluster(nodes, poolConfig());
    }

JedisClusterPipeline.java(重写的pipeline类)

package com.hqjy.msg.util;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.*;
import redis.clients.jedis.exceptions.JedisMovedDataException;
import redis.clients.jedis.exceptions.JedisRedirectionException;
import redis.clients.util.JedisClusterCRC16;
import redis.clients.util.SafeEncoder;
 
import java.io.Closeable;
import java.lang.reflect.Field;
import java.util.*;
 
/**
 * @program: message
 * @description: JedisClusterPipeLine
 * @author: Irving Wei
 * @create: 2018-11-27 10:22
 **/
 
public class JedisClusterPipeline extends PipelineBase implements Closeable {
 
    private static final Logger LOGGER = LoggerFactory.getLogger(JedisClusterPipeline.class);
 
    // 部分字段没有对应的获取方法，只能采用反射来做
    // 你也可以去继承JedisCluster和JedisSlotBasedConnectionHandler来提供访问接口
    private static final Field FIELD_CONNECTION_HANDLER;
    private static final Field FIELD_CACHE;
    static {
        FIELD_CONNECTION_HANDLER = getField(BinaryJedisCluster.class, "connectionHandler");
        FIELD_CACHE = getField(JedisClusterConnectionHandler.class, "cache");
    }
 
    private JedisSlotBasedConnectionHandler connectionHandler;
    private JedisClusterInfoCache clusterInfoCache;
    private Queue<Client> clients = new LinkedList<Client>();   // 根据顺序存储每个命令对应的Client
    private Map<JedisPool, Jedis> jedisMap = new HashMap<>();   // 用于缓存连接
    private boolean hasDataInBuf = false;   // 是否有数据在缓存区
 
    /**
     * 根据jedisCluster实例生成对应的JedisClusterPipeline
     * @param
     * @return
     */
    public static JedisClusterPipeline pipelined(JedisCluster jedisCluster) {
        JedisClusterPipeline pipeline = new JedisClusterPipeline();
        pipeline.setJedisCluster(jedisCluster);
        return pipeline;
    }
 
    public JedisClusterPipeline() {
    }
 
    public void setJedisCluster(JedisCluster jedis) {
        connectionHandler = getValue(jedis, FIELD_CONNECTION_HANDLER);
        clusterInfoCache = getValue(connectionHandler, FIELD_CACHE);
    }
 
    /**
     * 刷新集群信息，当集群信息发生变更时调用
     * @param
     * @return
     */
    public void refreshCluster() {
        connectionHandler.renewSlotCache();
    }
 
    /**
     * 同步读取所有数据. 与syncAndReturnAll()相比，sync()只是没有对数据做反序列化
     */
    public void sync() {
        innerSync(null);
    }
 
    /**
     * 同步读取所有数据 并按命令顺序返回一个列表
     *
     * @return 按照命令的顺序返回所有的数据
     */
    public List<Object> syncAndReturnAll() {
        List<Object> responseList = new ArrayList<Object>();
 
        innerSync(responseList);
 
        return responseList;
    }
 
    private void innerSync(List<Object> formatted) {
        HashSet<Client> clientSet = new HashSet<Client>();
 
        try {
            for (Client client : clients) {
                // 在sync()调用时其实是不需要解析结果数据的，但是如果不调用get方法，发生了JedisMovedDataException这样的错误应用是不知道的，因此需要调用get()来触发错误。
                // 其实如果Response的data属性可以直接获取，可以省掉解析数据的时间，然而它并没有提供对应方法，要获取data属性就得用反射，不想再反射了，所以就这样了
                Object data = generateResponse(client.getOne()).get();
                if (null != formatted) {
                    formatted.add(data);
                }
 
                // size相同说明所有的client都已经添加，就不用再调用add方法了
                if (clientSet.size() != jedisMap.size()) {
                    clientSet.add(client);
                }
            }
        } catch (JedisRedirectionException jre) {
            if (jre instanceof JedisMovedDataException) {
                // if MOVED redirection occurred, rebuilds cluster's slot cache,
                // recommended by Redis cluster specification
                refreshCluster();
            }
 
            throw jre;
        } finally {
            if (clientSet.size() != jedisMap.size()) {
                // 所有还没有执行过的client要保证执行(flush)，防止放回连接池后后面的命令被污染
                for (Jedis jedis : jedisMap.values()) {
                    if (clientSet.contains(jedis.getClient())) {
                        continue;
                    }
 
                    flushCachedData(jedis);
                }
            }
 
            hasDataInBuf = false;
            close();
        }
    }
 
    @Override
    public void close() {
        clean();
 
        clients.clear();
 
        for (Jedis jedis : jedisMap.values()) {
            if (hasDataInBuf) {
                flushCachedData(jedis);
            }
 
            jedis.close();
        }
 
        jedisMap.clear();
 
        hasDataInBuf = false;
    }
 
    private void flushCachedData(Jedis jedis) {
        try {
            jedis.getClient().getAll();
        } catch (RuntimeException ex) {
        }
    }
 
    @Override
    protected Client getClient(String key) {
        byte[] bKey = SafeEncoder.encode(key);
 
        return getClient(bKey);
    }
 
    @Override
    protected Client getClient(byte[] key) {
        Jedis jedis = getJedis(JedisClusterCRC16.getSlot(key));
 
        Client client = jedis.getClient();
        clients.add(client);
 
        return client;
    }
 
    private Jedis getJedis(int slot) {
        JedisPool pool = clusterInfoCache.getSlotPool(slot);
 
        // 根据pool从缓存中获取Jedis
        Jedis jedis = jedisMap.get(pool);
        if (null == jedis) {
            jedis = pool.getResource();
            jedisMap.put(pool, jedis);
        }
 
        hasDataInBuf = true;
        return jedis;
    }
 
    private static Field getField(Class<?> cls, String fieldName) {
        try {
            Field field = cls.getDeclaredField(fieldName);
            field.setAccessible(true);
 
            return field;
        } catch (NoSuchFieldException | SecurityException e) {
            throw new RuntimeException("cannot find or access field '" + fieldName + "' from " + cls.getName(), e);
        }
    }
 
    @SuppressWarnings({"unchecked" })
    private static <T> T getValue(Object obj, Field field) {
        try {
            return (T)field.get(obj);
        } catch (IllegalArgumentException | IllegalAccessException e) {
            LOGGER.error("get value fail", e);
 
            throw new RuntimeException(e);
        }
    }
 
}

XXXService.java(使用)

@Autowired
    private JedisCluster jc;
 
@RedisIdxConnection
    public synchronized void pipeline(String key, List list) {
        // 如果要操作的list没有值，则直接返回
        if (!(list.size() > 0)) {
            return;
        }
        JedisClusterPipeline jcp = JedisClusterPipeline.pipelined(jc);
        jcp.refreshCluster();
        List<Object> batchResult = null;
        try {
            for (int i = 0; i < list.size(); i++) {
                // for循环的内容根据自己的业务进行修改，核心就是用jcp加到数组再一起同步到redis实现批量操作
                Map map = (Map) list.get(i);
                String msg = (String) map.get("value");
                long time = (long) map.get("score");
                String zkey = (String) map.get(Constant.REDIS_KEY);
                jcp.zadd(zkey, time, msg);
            }
            jcp.sync();
            batchResult = jcp.syncAndReturnAll();
        } finally {
            jcp.close();
        }