AI专业者开发社区 1 号成员
  •  0 回帖  •  0 浏览  •  4 个月前
   

java中Jedis对redis内数据的批量获取- hscan,Pipeline的使用- 常用工具类-RedisUtil

指出问题

在使用 redis 的时候，配合 jedis 使用，但是发现 jedis 的 keys* 或者 mget 都会造成 redis 阻塞，所以使用了 redis 的解决方案 Pipeline（管道）的方式进行对 redis 内数据的获取。封装了以下工具类。需要自取。或者提供好的方法可以留言，我可以写进来。

初始化配置

先在 application.yml 配置 redis 基本信息

spring:
  redis:
    host: 127.0.0.1
    port: 6379
    password:
    database: 0
    timeout: 5000

创建 jedis 连接池

创建 RedisConfig.java

@Configuration
@Slf4j
public class RedisConfig {
    @Autowired
    private RedisProperties redisProperties; // 从配置文件获取 redis 连接配置

<span class="hljs-keyword">private</span> JedisPool jedisPool;

<span class="hljs-meta">@Autowired</span>
<span class="hljs-keyword">private</span> JedisPoolConfig jedisPoolConfig;

<span class="hljs-meta">@Bean</span>
<span class="hljs-meta">@Scope("prototype")</span>
<span class="hljs-comment">/**
 * 多例模式返回redis客户端，但是在依赖注入时，建议不要使用
 * 因为jedis客户端是阻塞式IO的，而且线程不安全，
 * 所以在操作数据库的时候不要使用单例，建议从连接池获取
 */</span>
<span class="hljs-keyword">public</span> redis.clients.jedis.Jedis <span class="hljs-title function_">jedis</span><span class="hljs-params">()</span>{
    <span class="hljs-keyword">if</span> (jedisPool!=<span class="hljs-literal">null</span>){
        <span class="hljs-keyword">return</span> jedisPool.getResource();
    }<span class="hljs-keyword">else</span> {
        <span class="hljs-keyword">return</span> jedisPool().getResource();
    }



//        return jedisPool.getResource();
}


<span class="hljs-meta">@Bean</span>
<span class="hljs-comment">/**
 * 单例模式返回redis连接池
 * 依赖注入时，建议注入jedisPool，获取连接池，然后调用getResource方法获取jedis客户端
 * 使用完后，调用jedis.close()方法归还连接，节约资源
 */</span>
<span class="hljs-keyword">public</span> JedisPool <span class="hljs-title function_">jedisPool</span><span class="hljs-params">()</span>{
    <span class="hljs-keyword">synchronized</span> (<span class="hljs-built_in">this</span>){
        <span class="hljs-keyword">if</span>(jedisPool==<span class="hljs-literal">null</span>){
            <span class="hljs-keyword">synchronized</span> (<span class="hljs-built_in">this</span>){
                
                <span class="hljs-keyword">if</span> (StringUtils.isEmpty(redisProperties.getPassword())){
                    <span class="hljs-comment">//无密码</span>
                    jedisPool = <span class="hljs-keyword">new</span> <span class="hljs-title class_">JedisPool</span>(jedisPoolConfig,redisProperties.getHost(),redisProperties.getPort(),(<span class="hljs-type">int</span>)redisProperties.getTimeout().toMillis());
                }<span class="hljs-keyword">else</span> {<span class="hljs-comment">//有密码</span>
                    jedisPool = <span class="hljs-keyword">new</span> <span class="hljs-title class_">JedisPool</span>(jedisPoolConfig,redisProperties.getHost(),redisProperties.getPort(),(<span class="hljs-type">int</span>)redisProperties.getTimeout().toMillis(),redisProperties.getPassword());
                }
                     
            }
        }
    }
    <span class="hljs-keyword">return</span> jedisPool;
}



<span class="hljs-meta">@Bean</span>
<span class="hljs-keyword">public</span> JedisPoolConfig <span class="hljs-title function_">jedisPoolConfig</span><span class="hljs-params">()</span>{
    <span class="hljs-comment">// Jedis连接池配置</span>
    <span class="hljs-type">JedisPoolConfig</span> <span class="hljs-variable">jedisPoolConfig</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">JedisPoolConfig</span>();
    jedisPoolConfig.setMaxTotal(redisProperties.getLettuce().getPool().getMaxActive());
    <span class="hljs-comment">// 最大空闲连接数, 默认8个</span>



//        jedisPoolConfig.setMaxIdle(50);
jedisPoolConfig.setMaxIdle(redisProperties.getLettuce().getPool().getMaxIdle());
// 最大连接数, 默认 8 个
//        jedisPoolConfig.setMaxTotal(300);
// 最小空闲连接数, 默认 0
jedisPoolConfig.setMinIdle(redisProperties.getLettuce().getPool().getMinIdle());
//        jedisPoolConfig.setMinIdle(20);
// 获取连接时的最大等待毫秒数 (如果设置为阻塞时 BlockWhenExhausted), 如果超时就抛异常, 小于零: 阻塞不确定的时间,  默认 -1
jedisPoolConfig.setMaxWaitMillis(redisProperties.getLettuce().getPool().getMaxWait().toMillis()); // 设置 10 秒


//        jedisPoolConfig.setMaxWaitMillis(3000); // 设置 2 秒
// 对拿到的 connection 进行 validateObject 校验


    jedisPoolConfig.setTestOnBorrow(<span class="hljs-literal">true</span>);
    <span class="hljs-keyword">return</span> jedisPoolConfig;
}



}

jedis 工具类



@Component
@Slf4j
public class RedisUtil {
@Autowired
private JedisPool jedisPool;


<span class="hljs-comment">/**
 * findValueByKeyOfPipeline和 findValueByKeyOfPipelineMget 的区别在于 前者根据阈值获取多次 后者是直接一次性获取
 */</span>


<span class="hljs-comment">/**
 * 根据(不完整)key值通过Pipeline的方式获取值
 * 先通过scan获取全部的key,再通过Pipeline获取全部的值
 * 根据countVPT 这个 阈值来控制 获取多次
 * (通过建立一个管道一次提交)
 * <span class="hljs-doctag">@param</span> redisKey
 * <span class="hljs-doctag">@Auther</span> erpangshou
 * <span class="hljs-doctag">@Date</span>:2021/6/17 10:36
 **/</span>
<span class="hljs-keyword">public</span> List&lt;String&gt; <span class="hljs-title function_">findValueByKeyOfPipeline</span><span class="hljs-params">(String redisKey)</span> {
    <span class="hljs-type">Jedis</span> <span class="hljs-variable">jedis</span> <span class="hljs-operator">=</span> <span class="hljs-literal">null</span>;
    List&lt;String&gt; values = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;&gt;();
    ArrayList&lt;Response&lt;List&lt;String&gt;&gt;&gt; responses = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;&gt;();
    <span class="hljs-type">int</span> countVPT=ConstantCom.BATCH_SIZE;
    <span class="hljs-keyword">try</span> {
        jedis = jedisPool.getResource();
        <span class="hljs-comment">//从redis获取值刷新航迹信息</span>
        List&lt;String&gt; allKeys = findAllKeys(redisKey);
        <span class="hljs-keyword">if</span> (Objects.isNull(allKeys) || allKeys.isEmpty()) {
            <span class="hljs-keyword">return</span> values;
        }
        <span class="hljs-type">Pipeline</span> <span class="hljs-variable">pipelined</span> <span class="hljs-operator">=</span> jedis.pipelined();
        ArrayList&lt;String&gt; strings = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;&gt;();
        <span class="hljs-keyword">for</span> (String key : allKeys) {
            strings.add(key);
            <span class="hljs-keyword">if</span> (strings.size()==countVPT){
                ArrayList&lt;String&gt; subList = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;&gt;(strings);
                String[] keys = subList.toArray(<span class="hljs-keyword">new</span> <span class="hljs-title class_">String</span>[subList.size()]);
                Response&lt;List&lt;String&gt;&gt; mget = pipelined.mget(keys);
                responses.add(mget);
                strings=<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;&gt;();
            }
        }
        <span class="hljs-comment">//最后的数据</span>
        String[] keys = strings.toArray(<span class="hljs-keyword">new</span> <span class="hljs-title class_">String</span>[strings.size()]);
        Response&lt;List&lt;String&gt;&gt; mget = pipelined.mget(keys);
        responses.add(mget);
        pipelined.sync();
        <span class="hljs-keyword">for</span> (Response&lt;List&lt;String&gt;&gt; respons : responses) {
            values.addAll(respons.get());
        }

    } <span class="hljs-keyword">catch</span> (Exception e) {
        e.printStackTrace();
        log.error(<span class="hljs-string">"redis查询异常："</span> + e.getMessage());
    } <span class="hljs-keyword">finally</span> {
        <span class="hljs-keyword">if</span> (jedis != <span class="hljs-literal">null</span>) {
            jedis.close();
        }
    }
    <span class="hljs-keyword">return</span> values;
}

<span class="hljs-comment">/**
 * 根据(不完整)key值通过Pipeline的方式获取值
 * 先通过scan获取全部的key,再通过Pipeline获取全部的值
 * (通过Pipeline.mget直接获取)
 * <span class="hljs-doctag">@param</span> redisKey
 * <span class="hljs-doctag">@Auther</span> erpangshou
 * <span class="hljs-doctag">@Date</span>:2021/6/17 10:36
 **/</span>
<span class="hljs-keyword">public</span> List&lt;String&gt; <span class="hljs-title function_">findValueByKeyOfPipelineMget</span><span class="hljs-params">(String redisKey)</span> {
    <span class="hljs-type">Jedis</span> <span class="hljs-variable">jedis</span> <span class="hljs-operator">=</span> <span class="hljs-literal">null</span>;
    List&lt;String&gt; values = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;&gt;();
    ArrayList&lt;Response&lt;List&lt;String&gt;&gt;&gt; responses = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;&gt;();
    <span class="hljs-keyword">try</span> {
        jedis = jedisPool.getResource();
        <span class="hljs-comment">//从redis获取值刷新航迹信息</span>
        List&lt;String&gt; allKeys = findAllKeys(redisKey);
        <span class="hljs-keyword">if</span> (Objects.isNull(allKeys) || allKeys.isEmpty()) {
            <span class="hljs-keyword">return</span> values;
        }



//            allKeys=allKeys.subList(0,5000);
String[] keys = allKeys.toArray(new String[allKeys.size()]);
Pipeline pipelined = jedis.pipelined();
Response<List<String>> mget = pipelined.mget(keys);
pipelined.sync();
values=mget.get();
} catch (Exception e) {
log.error("redis 查询异常：" + e.getMessage());
} finally {
if (jedis != null) {
jedis.close();
}
}
return values;
}


<span class="hljs-comment">/**
 * jedis的met 
 * <span class="hljs-doctag">@param</span> redisKey
 * <span class="hljs-doctag">@Auther</span> erpangshou
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> List&lt;String&gt; <span class="hljs-title function_">mget</span><span class="hljs-params">(String redisKey)</span> {
    <span class="hljs-type">Jedis</span> <span class="hljs-variable">jedis</span> <span class="hljs-operator">=</span> <span class="hljs-literal">null</span>;
    List&lt;String&gt; values = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;&gt;();
    <span class="hljs-keyword">try</span> {
        jedis = jedisPool.getResource();
        <span class="hljs-comment">//从redis获取值刷新航迹信息</span>
        List&lt;String&gt; allKeys = findAllKeys(redisKey);
        <span class="hljs-keyword">if</span> (Objects.isNull(allKeys) || allKeys.isEmpty()) {
            <span class="hljs-keyword">return</span> values;
        }
        String[] keys = allKeys.toArray(<span class="hljs-keyword">new</span> <span class="hljs-title class_">String</span>[allKeys.size()]);
        List&lt;String&gt; mget1 = jedis.mget(keys);
        values=mget1;

    } <span class="hljs-keyword">catch</span> (Exception e) {
        log.error(<span class="hljs-string">"redis查询异常："</span> + e.getMessage());
    } <span class="hljs-keyword">finally</span> {
        <span class="hljs-keyword">if</span> (jedis != <span class="hljs-literal">null</span>) {
            jedis.close();
        }
    }
    <span class="hljs-keyword">return</span> values;
}

<span class="hljs-comment">/**
 * 根据(不完整)key值通过Pipeline的方式获取值   --使用传入jedis的方式
 * 先通过scan获取全部的key,再通过Pipeline获取全部的值
 *
 * <span class="hljs-doctag">@param</span> redisKey
 * <span class="hljs-doctag">@Auther</span> erpangshou
 * <span class="hljs-doctag">@Date</span>:2021/6/17 10:36
 **/</span>
<span class="hljs-keyword">public</span> List&lt;String&gt; <span class="hljs-title function_">findValueByKeyOfPipeline</span><span class="hljs-params">(String redisKey, Jedis jedis)</span> {
    List&lt;String&gt; values = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;&gt;();
    <span class="hljs-keyword">try</span> {
        <span class="hljs-comment">//从redis获取值刷新航迹信息</span>
        List&lt;String&gt; allKeys = findAllKeys(redisKey);
        <span class="hljs-keyword">if</span> (allKeys == <span class="hljs-literal">null</span> || allKeys.isEmpty()) {
            <span class="hljs-keyword">return</span> values;
        }
        <span class="hljs-comment">//此处采用Pipeline，以提升性能</span>
        <span class="hljs-type">Pipeline</span> <span class="hljs-variable">pipelined</span> <span class="hljs-operator">=</span> jedis.pipelined();
        Response&lt;List&lt;String&gt;&gt; mget = pipelined.mget(allKeys.toArray(<span class="hljs-keyword">new</span> <span class="hljs-title class_">String</span>[allKeys.size()]));
        pipelined.sync();
        values = mget.get();
    } <span class="hljs-keyword">catch</span> (Exception e) {
        log.error(<span class="hljs-string">"redis查询异常："</span> + e.getMessage());
    }
    <span class="hljs-keyword">return</span> values;
}

<span class="hljs-comment">/**
 * 根据多个完整(精确)key值通过Pipeline的方式获取值
 * 使用完整的key通过Pipeline获取全部的值
 *
 * <span class="hljs-doctag">@param</span> allKeys
 * <span class="hljs-doctag">@Auther</span> erpangshou
 * <span class="hljs-doctag">@Date</span> 2021/6/17  10:33
 */</span>
<span class="hljs-keyword">public</span> List&lt;String&gt; <span class="hljs-title function_">findAllkeysByKeysOfPipeline</span><span class="hljs-params">(String[] allKeys)</span> {
    <span class="hljs-type">Jedis</span> <span class="hljs-variable">jedis</span> <span class="hljs-operator">=</span> <span class="hljs-literal">null</span>;
    List&lt;String&gt; values = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;&gt;();
    <span class="hljs-type">int</span> countVPT=ConstantCom.BATCH_SIZE;

    <span class="hljs-keyword">try</span> {
        jedis = jedisPool.getResource();
        ArrayList&lt;Response&lt;List&lt;String&gt;&gt;&gt; responses = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;&gt;();
        <span class="hljs-comment">//从redis获取值刷新航迹信息</span>
        <span class="hljs-keyword">if</span> (Objects.isNull(allKeys) || allKeys.length == <span class="hljs-number">0</span>) {
            <span class="hljs-keyword">return</span> values;
        }
        <span class="hljs-comment">//此处采用Pipeline，以提升性能</span>
        <span class="hljs-type">Pipeline</span> <span class="hljs-variable">pipelined</span> <span class="hljs-operator">=</span> jedis.pipelined();
        ArrayList&lt;String&gt; strings = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;&gt;();
        <span class="hljs-keyword">for</span> (String key : allKeys) {
            strings.add(key);
            <span class="hljs-keyword">if</span> (strings.size()==countVPT){
                ArrayList&lt;String&gt; subList = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;&gt;(strings);
                String[] keys = subList.toArray(<span class="hljs-keyword">new</span> <span class="hljs-title class_">String</span>[subList.size()]);
                Response&lt;List&lt;String&gt;&gt; mget = pipelined.mget(keys);
                responses.add(mget);
                strings=<span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;&gt;();
            }
        }
        <span class="hljs-comment">//最后的数据</span>
        String[] keys = strings.toArray(<span class="hljs-keyword">new</span> <span class="hljs-title class_">String</span>[strings.size()]);
        Response&lt;List&lt;String&gt;&gt; mget = pipelined.mget(keys);
        responses.add(mget);
        pipelined.sync();

        <span class="hljs-keyword">for</span> (Response&lt;List&lt;String&gt;&gt; respons : responses) {
            values.addAll(respons.get());
        }

    } <span class="hljs-keyword">catch</span> (Exception e) {
        log.error(<span class="hljs-string">"redis查询异常："</span> + e.getMessage());
    } <span class="hljs-keyword">finally</span> {
        <span class="hljs-keyword">if</span> (jedis != <span class="hljs-literal">null</span>) {
            jedis.close();
        }
    }
    <span class="hljs-keyword">return</span> values;
}



<span class="hljs-comment">/**
 * 根据多个完整(精确)key值通过Pipeline的方式获取值  --使用传入jedis的方式
 * 使用完整的key通过Pipeline获取全部的值
 *
 * <span class="hljs-doctag">@param</span> redisKeys
 * <span class="hljs-doctag">@Auther</span> erpangshou
 * <span class="hljs-doctag">@Date</span> 2021/6/17  10:33
 */</span>
<span class="hljs-keyword">public</span> List&lt;String&gt; <span class="hljs-title function_">findAllkeysByKeysOfPipeline</span><span class="hljs-params">(String[] redisKeys, Jedis jedis)</span> {
    List&lt;String&gt; values = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;&gt;();
    <span class="hljs-keyword">try</span> {
        <span class="hljs-comment">//从redis获取值刷新航迹信息</span>
        <span class="hljs-keyword">if</span> (redisKeys == <span class="hljs-literal">null</span> || redisKeys.length == <span class="hljs-number">0</span>) {
            <span class="hljs-keyword">return</span> values;
        }
        <span class="hljs-comment">//此处采用Pipeline，以提升性能</span>
        <span class="hljs-type">Pipeline</span> <span class="hljs-variable">pipelined</span> <span class="hljs-operator">=</span> jedis.pipelined();
        Response&lt;List&lt;String&gt;&gt; mget = pipelined.mget(redisKeys);
        pipelined.sync();
        values = mget.get();
    } <span class="hljs-keyword">catch</span> (Exception e) {
        log.error(<span class="hljs-string">"redis查询异常："</span> + e.getMessage());
    }
    <span class="hljs-keyword">return</span> values;
}

<span class="hljs-comment">/**
 * 根据keys 获取value
 *
 * <span class="hljs-doctag">@param</span> pattern
 * <span class="hljs-doctag">@Auther</span> erpangshou
 */</span>
<span class="hljs-keyword">public</span> List&lt;String&gt; <span class="hljs-title function_">findValueByKey</span><span class="hljs-params">(String pattern)</span> {
    List&lt;String&gt; values = <span class="hljs-literal">null</span>;
    List&lt;String&gt; keys = findAllKeys(pattern);
    <span class="hljs-keyword">if</span> (keys != <span class="hljs-literal">null</span> &amp;&amp; keys.size() &gt; <span class="hljs-number">0</span>) {
        String[] strings = keys.toArray(<span class="hljs-keyword">new</span> <span class="hljs-title class_">String</span>[keys.size()]);
        values = findAllkeysByKeysOfPipeline(strings);
    }
    <span class="hljs-keyword">return</span> values;
}

<span class="hljs-comment">/**
 * 根据keys 获取value  --使用传入jedis的方式
 *
 * <span class="hljs-doctag">@param</span> pattern
 * <span class="hljs-doctag">@Auther</span> erpangshou
 */</span>
<span class="hljs-keyword">public</span> List&lt;String&gt; <span class="hljs-title function_">findValueByKey</span><span class="hljs-params">(String pattern, Jedis jedis)</span> {
    List&lt;String&gt; values = <span class="hljs-literal">null</span>;
    List&lt;String&gt; keys = findAllKeys(pattern);
    <span class="hljs-keyword">if</span> (keys != <span class="hljs-literal">null</span> &amp;&amp; keys.size() &gt; <span class="hljs-number">0</span>) {
        String[] strings = keys.toArray(<span class="hljs-keyword">new</span> <span class="hljs-title class_">String</span>[keys.size()]);
        values = findAllkeysByKeysOfPipeline(strings, jedis);
    }
    <span class="hljs-keyword">return</span> values;
}

<span class="hljs-comment">/**
 * 根据keys 获取value 已map形式返回
 *
 * <span class="hljs-doctag">@param</span> pattern
 * <span class="hljs-doctag">@Auther</span> erpangshou
 */</span>
<span class="hljs-keyword">public</span> List&lt;Map&gt; <span class="hljs-title function_">findValuetoMapByKey</span><span class="hljs-params">(String pattern, Jedis jedis)</span> {
    List&lt;String&gt; values = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;&gt;();
    ArrayList&lt;Map&gt; mapList = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;&gt;();
    <span class="hljs-keyword">try</span> {
        List&lt;String&gt; keys = findAllKeys(pattern);
        <span class="hljs-keyword">if</span> (keys != <span class="hljs-literal">null</span> &amp;&amp; keys.size() &gt; <span class="hljs-number">0</span>) {
            String[] strings = keys.toArray(<span class="hljs-keyword">new</span> <span class="hljs-title class_">String</span>[keys.size()]);
            values = findAllkeysByKeysOfPipeline(strings);
        }

        <span class="hljs-keyword">if</span> (ObjectUtil.isNotEmpty(values)) {
            <span class="hljs-keyword">for</span> (String value : values) {
                Map&lt;String, Object&gt; map = ((JSONObject) JSONObject.parse(value)).toJavaObject(Map.class);
                mapList.add(map);
            }
        }

    } <span class="hljs-keyword">catch</span> (Exception e) {
        jedis.close();
        e.printStackTrace();
    }
    <span class="hljs-keyword">return</span> mapList;
}

<span class="hljs-comment">/**
 * 因为Redis是单线程jedis.keys()方法会导致数据库阻塞，
 * 可能导致Redis其它业务无法操作，所有采用迭代模式(scan)获取数据
 * 并且keys()方法的时间复杂度为O(n)，scan()时间复杂度为O(1)
 */</span>
<span class="hljs-keyword">public</span> List&lt;String&gt; <span class="hljs-title function_">findAllKeys</span><span class="hljs-params">(String pattern)</span> {
    <span class="hljs-type">Jedis</span> <span class="hljs-variable">jedis</span> <span class="hljs-operator">=</span> <span class="hljs-literal">null</span>;
    List&lt;String&gt; total = <span class="hljs-literal">null</span>;
    <span class="hljs-keyword">try</span> {
        jedis = jedisPool.getResource();
        <span class="hljs-type">String</span> <span class="hljs-variable">cursor</span> <span class="hljs-operator">=</span> String.valueOf(<span class="hljs-number">0</span>);
        total = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;&gt;();
        <span class="hljs-type">ScanParams</span> <span class="hljs-variable">params</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">ScanParams</span>();
        params.match(pattern);
        <span class="hljs-keyword">do</span> {
            params.count(ConstantCom.BATCH_SIZE);
            ScanResult&lt;String&gt; result = jedis.scan(cursor, params);
            cursor = result.getStringCursor();
            total.addAll(result.getResult());
        } <span class="hljs-keyword">while</span> (Integer.valueOf(cursor) &gt; <span class="hljs-number">0</span>);
    } <span class="hljs-keyword">catch</span> (NumberFormatException e) {
        e.printStackTrace();
        log.error(<span class="hljs-string">"批量获取redis的key失败"</span>);
    } <span class="hljs-keyword">finally</span> {
        <span class="hljs-keyword">if</span> (ObjectUtil.isNotEmpty(jedis)) {
            jedis.close();
        }
    }
    <span class="hljs-keyword">return</span> total;
}

<span class="hljs-comment">/**
 * 获取全都的key --使用传入jedis的方式
 * 因为Redis是单线程jedis.keys()方法会导致数据库阻塞，
 * 可能导致Redis其它业务无法操作，所有采用迭代模式(scan)获取数据
 * 并且keys()方法的时间复杂度为O(n)，scan()时间复杂度为O(1)
 */</span>
<span class="hljs-keyword">public</span> List&lt;String&gt; <span class="hljs-title function_">findAllKeys</span><span class="hljs-params">(String pattern, Jedis jedis)</span> {
    List&lt;String&gt; total = <span class="hljs-literal">null</span>;
    <span class="hljs-keyword">try</span> {
        <span class="hljs-type">String</span> <span class="hljs-variable">cursor</span> <span class="hljs-operator">=</span> String.valueOf(<span class="hljs-number">0</span>);
        total = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;&gt;();
        <span class="hljs-type">ScanParams</span> <span class="hljs-variable">params</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">ScanParams</span>();
        params.match(pattern);
        <span class="hljs-keyword">do</span> {
            params.count(ConstantCom.BATCH_SIZE);
            ScanResult&lt;String&gt; result = jedis.scan(cursor, params);
            cursor = result.getStringCursor();
            total.addAll(result.getResult());
        } <span class="hljs-keyword">while</span> (Integer.valueOf(cursor) &gt; <span class="hljs-number">0</span>);
    } <span class="hljs-keyword">catch</span> (NumberFormatException e) {
        e.printStackTrace();
        log.error(<span class="hljs-string">"批量获取redis的key失败"</span>);
    }
    <span class="hljs-keyword">return</span> total;
}

<span class="hljs-comment">/**
 * 取代jedis.keys(*)
 *
 * <span class="hljs-doctag">@param</span> pattern
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> Set&lt;String&gt; <span class="hljs-title function_">findAllKeysToSet</span><span class="hljs-params">(String pattern)</span> {
    <span class="hljs-type">Jedis</span> <span class="hljs-variable">jedis</span> <span class="hljs-operator">=</span> <span class="hljs-literal">null</span>;
    Set&lt;String&gt; total = <span class="hljs-literal">null</span>;
    <span class="hljs-keyword">try</span> {
        jedis = jedisPool.getResource();
        <span class="hljs-type">String</span> <span class="hljs-variable">cursor</span> <span class="hljs-operator">=</span> String.valueOf(<span class="hljs-number">0</span>);
        total = <span class="hljs-keyword">new</span> <span class="hljs-title class_">HashSet</span>&lt;String&gt;() {
        };
        <span class="hljs-type">ScanParams</span> <span class="hljs-variable">params</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">ScanParams</span>();
        params.match(pattern);
        <span class="hljs-keyword">do</span> {
            params.count(ConstantCom.BATCH_SIZE);
            ScanResult&lt;String&gt; result = jedis.scan(cursor, params);
            cursor = result.getStringCursor();
            total.addAll(result.getResult());
        } <span class="hljs-keyword">while</span> (Integer.valueOf(cursor) &gt; <span class="hljs-number">0</span>);
    } <span class="hljs-keyword">catch</span> (NumberFormatException e) {
        e.printStackTrace();
        log.error(<span class="hljs-string">"批量获取redis的key失败"</span>);

    } <span class="hljs-keyword">finally</span> {
        <span class="hljs-keyword">if</span> (ObjectUtil.isNotEmpty(jedis)) {
            jedis.close();
        }
    }
    <span class="hljs-keyword">return</span> total;
}

<span class="hljs-comment">/**
 * 取代jedis.keys(*)  --使用传入jedis的方式
 * <span class="hljs-doctag">@param</span> pattern
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> Set&lt;String&gt; <span class="hljs-title function_">findAllKeysToSet</span><span class="hljs-params">(String pattern, Jedis jedis)</span> {
    Set&lt;String&gt; total = <span class="hljs-literal">null</span>;
    <span class="hljs-keyword">try</span> {
        <span class="hljs-type">String</span> <span class="hljs-variable">cursor</span> <span class="hljs-operator">=</span> String.valueOf(<span class="hljs-number">0</span>);
        total = <span class="hljs-keyword">new</span> <span class="hljs-title class_">HashSet</span>&lt;String&gt;();
        <span class="hljs-type">ScanParams</span> <span class="hljs-variable">params</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">ScanParams</span>();
        params.match(pattern);
        <span class="hljs-keyword">do</span> {
            params.count(ConstantCom.BATCH_SIZE);
            ScanResult&lt;String&gt; result = jedis.scan(cursor, params);
            cursor = result.getStringCursor();
            total.addAll(result.getResult());
        } <span class="hljs-keyword">while</span> (Integer.valueOf(cursor) &gt; <span class="hljs-number">0</span>);
    } <span class="hljs-keyword">catch</span> (NumberFormatException e) {
        e.printStackTrace();
        log.error(<span class="hljs-string">"批量获取redis的key失败"</span>);

    }
    <span class="hljs-keyword">return</span> total;
}

<span class="hljs-comment">/**
 * 实时数据取出，封装成指定的对象集合
 *
 * <span class="hljs-doctag">@param</span> list        redis取出的value集合
 * <span class="hljs-doctag">@param</span> entityClass 需要封装的对象类型
 * <span class="hljs-doctag">@param</span> &lt;T&gt;
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> &lt;T&gt; List&lt;T&gt; <span class="hljs-title function_">valueToClass</span><span class="hljs-params">(List&lt;String&gt; list, Class&lt;T&gt; entityClass)</span> {
    List&lt;T&gt; result = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;&gt;();
    <span class="hljs-keyword">for</span> (String value : list) {
        Map&lt;String, Object&gt; map = ((JSONObject) JSONObject.parse(value)).toJavaObject(Map.class);
        Set&lt;String&gt; keySet = map.keySet();
        <span class="hljs-comment">// 将所有key转换为小写</span>
        Map&lt;String, Object&gt; map1 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">HashMap</span>&lt;&gt;();
        <span class="hljs-keyword">for</span> (String set : keySet) {
            map1.put(set.toLowerCase(), map.get(set));
        }
        <span class="hljs-type">T</span> <span class="hljs-variable">instance</span> <span class="hljs-operator">=</span> <span class="hljs-literal">null</span>;
        <span class="hljs-keyword">try</span> {
            instance = entityClass.newInstance();
            BeanUtils.populate(instance, map1);
        } <span class="hljs-keyword">catch</span> (InstantiationException e) {
            e.printStackTrace();
        } <span class="hljs-keyword">catch</span> (IllegalAccessException e) {
            e.printStackTrace();
        } <span class="hljs-keyword">catch</span> (InvocationTargetException e) {
            e.printStackTrace();
        }
        result.add(instance);
    }
    <span class="hljs-keyword">return</span> result;

}

<span class="hljs-keyword">public</span> List&lt;Map&lt;String, Object&gt;&gt; <span class="hljs-title function_">valueToMap</span><span class="hljs-params">(List&lt;String&gt; list)</span> {
    List&lt;Map&lt;String, Object&gt;&gt; result = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;&gt;();
    <span class="hljs-keyword">for</span> (String value : list) {
        <span class="hljs-keyword">if</span> (org.apache.commons.lang3.StringUtils.isNotBlank(value)) {
            Map&lt;String, Object&gt; map = ((JSONObject) JSONObject.parse(value)).toJavaObject(Map.class);
            result.add(map);
        }
    }
    <span class="hljs-keyword">return</span> result;
}

<span class="hljs-comment">/**
 * <span class="hljs-doctag">@description</span> redis常用方法封装get
 * <span class="hljs-doctag">@author</span> erpangshou
 * <span class="hljs-doctag">@date</span> 2021/6/11
 **/</span>
<span class="hljs-keyword">public</span> String <span class="hljs-title function_">get</span><span class="hljs-params">(String key)</span> {
    <span class="hljs-type">Jedis</span> <span class="hljs-variable">jedis</span> <span class="hljs-operator">=</span> <span class="hljs-literal">null</span>;
    <span class="hljs-keyword">try</span> {
        jedis = jedisPool.getResource();
        <span class="hljs-keyword">return</span> jedis.get(key);
    } <span class="hljs-keyword">catch</span> (Exception e) {
        e.printStackTrace();
    } <span class="hljs-keyword">finally</span> {
        <span class="hljs-keyword">if</span> (!Objects.isNull(jedis)) {
            jedis.close();
        }
    }
    <span class="hljs-keyword">return</span> <span class="hljs-literal">null</span>;
}

<span class="hljs-comment">/**
 * <span class="hljs-doctag">@description</span> redis常用方法封装set
 * <span class="hljs-doctag">@author</span> erpangshou
 * <span class="hljs-doctag">@date</span> 2021/6/11
 **/</span>
<span class="hljs-keyword">public</span> String <span class="hljs-title function_">set</span><span class="hljs-params">(String key, String value)</span> {
    <span class="hljs-type">Jedis</span> <span class="hljs-variable">jedis</span> <span class="hljs-operator">=</span> <span class="hljs-literal">null</span>;
    <span class="hljs-keyword">try</span> {
        jedis = jedisPool.getResource();
        <span class="hljs-keyword">return</span> jedis.set(key, value);
    } <span class="hljs-keyword">catch</span> (Exception e) {
        e.printStackTrace();
    } <span class="hljs-keyword">finally</span> {
        <span class="hljs-keyword">if</span> (!Objects.isNull(jedis)) {
            jedis.close();
        }
    }
    <span class="hljs-keyword">return</span> <span class="hljs-literal">null</span>;
}


<span class="hljs-keyword">public</span> String <span class="hljs-title function_">hget</span><span class="hljs-params">(String key, String field)</span> {
    <span class="hljs-type">Jedis</span> <span class="hljs-variable">jedis</span> <span class="hljs-operator">=</span> <span class="hljs-literal">null</span>;
    <span class="hljs-keyword">try</span> {
        jedis = jedisPool.getResource();
        <span class="hljs-keyword">return</span> jedis.hget(key, field);
    } <span class="hljs-keyword">catch</span> (Exception e) {
        e.printStackTrace();
    } <span class="hljs-keyword">finally</span> {
        <span class="hljs-keyword">if</span> (!Objects.isNull(jedis)) {
            jedis.close();
        }
    }
    <span class="hljs-keyword">return</span> <span class="hljs-literal">null</span>;
}

<span class="hljs-comment">/**
 * 获取redis的hash值
 * 用scan方式模仿hgetAll
 * <span class="hljs-doctag">@param</span> pattern key
 * <span class="hljs-doctag">@Auther</span> erpangshou
 * <span class="hljs-doctag">@return</span>
 */</span>

<span class="hljs-keyword">public</span> Map&lt;String, String&gt; <span class="hljs-title function_">hScan</span><span class="hljs-params">(String pattern)</span> {
    <span class="hljs-type">long</span> <span class="hljs-variable">startTime</span> <span class="hljs-operator">=</span> System.currentTimeMillis();
    <span class="hljs-type">Jedis</span> <span class="hljs-variable">jedis</span> <span class="hljs-operator">=</span> <span class="hljs-literal">null</span>;

    Map&lt;String, String&gt; result = <span class="hljs-keyword">new</span> <span class="hljs-title class_">HashMap</span>&lt;&gt;();
    List&lt;Map.Entry&lt;String, String&gt;&gt; results = <span class="hljs-keyword">new</span> <span class="hljs-title class_">ArrayList</span>&lt;Map.Entry&lt;String, String&gt;&gt;();
    <span class="hljs-keyword">try</span> {
        jedis = jedisPool.getResource();
        <span class="hljs-type">String</span> <span class="hljs-variable">cursor</span> <span class="hljs-operator">=</span> String.valueOf(<span class="hljs-number">0</span>);
        <span class="hljs-type">ScanParams</span> <span class="hljs-variable">params</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">ScanParams</span>();
        params.count(ConstantCom.BATCH_SIZE);

        <span class="hljs-keyword">do</span> {
            ScanResult&lt;Map.Entry&lt;String, String&gt;&gt; scanResult = jedis.hscan(pattern, cursor, params);
            cursor = scanResult.getStringCursor();
            scanResult.getResult().stream().forEach(entry-&gt;result.put(entry.getKey(),entry.getValue()));
        } <span class="hljs-keyword">while</span> (Integer.valueOf(cursor) &gt; <span class="hljs-number">0</span>);
    } <span class="hljs-keyword">catch</span> (NumberFormatException e) {
        e.printStackTrace();
        log.error(<span class="hljs-string">"批量获取redis的key失败"</span>);
    } <span class="hljs-keyword">finally</span> {
        <span class="hljs-keyword">if</span> (ObjectUtil.isNotEmpty(jedis)) {
            jedis.close();
        }
    }
    System.out.println(<span class="hljs-string">"hscansize:"</span>+result.size());
    System.out.println(<span class="hljs-string">"hscantime:"</span>+(System.currentTimeMillis()-startTime));
    <span class="hljs-keyword">return</span> result;
}



}