蜀山_竹君子
蜀山_竹君子

分布式场景Redis客户端最优解决方案-lettuce + Redisson

Redis 官方推荐的 Java 客户端有Jedis、lettuce 和 Redisson。三种客户端各有优缺点，在我们业务实现中选择合适的客户端，有助于提高Redis的使用性能。要选择合适的客户端我们应该大概清楚Redis客户端的通讯方式和各种客户端的优缺点。

Redis概述

Redis支持多种语言客户端，支持的客户端可以从官网查看，这里列举一系列常见的客户端：

  • C语言
  • C++
  • C#
  • Java
  • Python
  • Node.js
  • PHP

Redis采用单线程方式处理多个客户端连接，作为程序开发者应该了解 Redis 服务端和客户端的通信协议，以及主流编程语言的 Redis 客户端使用方法，同时还需要了解客户端管理的相应 API 以及开发运维中可能遇到的问题。

Redis客户端通讯协议

Redis制定RESP(Redis Serializable Protocol, RESP)协议，实现客户端和服务端的正常交互，这种协议简单高效，既能够被机器解析，又容易被人类识别。
RESP可以序列号不同数据类型数据（整型、字符串、数组以及特殊类型Error）。需要执行的Redis命令会封装成类似字符串数组的请求通过客户端发送到服务端。Redis会基于制定的命令类型选择对应的数据类型进行回复。

RESP发送命令格式

在RESP中，发送数据的类型取决于数据报文的首个字节：

  • 单行字符串：单行字符串的第一个字节为+ ，最后两个字节是\r\n，其他字节是字符串内容+OK\r\nError；
  • 错误消息：错误消息的第一个字节为-，最后两个字节是\r\n，其他字节是异常消息的文本内容-ERR\r\nInteger；
  • 整型数字：整型数字的第一个字节是:，最后两个字节是\r\n，其他字节是数字的文本内容:100\r\nBulk；
  • 定长字符串：定长字符串的String定长字符串第一个字节是美元符号 ，紧接着的字节是内容字符串长度\r\n，最后两个字节是\r\n，其他字节是字符串内容$4\r\ndoge\r\n；
  • RESP数组：RESP数组的第一个字节是，紧接着的字节是元素个数\r\n，最后两个字节是\r\n，其他字节是各个元素的内容，每个元素可以是任意一种数据类型2\r\n:100\r\n$4\r\ndoge\r\n。

发送的命令格式如下，CRLF代表"\r\n":

Copy*<参数数量> CRLF
$<参数1的字节数量> CRLF
<参数1> CRLF
...
$<参数N的字节数量> CRLF
<参数N> CRLF

以set hello world这个命令为例，发送的内容就是这样的：

Copy*3
$3
SET
$5
hello
$5
world

第一行*3表示有3个参数，5表示下一个参数有5个字节，接下来是参数，$5表示下一个参数有5个字节，接下来是参数。
所以set hello world最终发送给redis服务器的命令是：

Copy*3\r\n$3\r\nSET\r\n$5\r\nhello\r\n$5\r\nworld\r\n

RESP响应内容

CopyRedis的返回结果类型分为以下五种：
正确回复：在RESP中第一个字节为"+"
错误回复：在RESP中第一个字节为"-"
整数回复：在RESP中第一个字节为":"
字符串回复：在RESP中第一个字节为"$"
多条字符串回复：在RESP中第一个字节为"*"

(+) 表示一个正确的状态信息，具体信息是当前行+后面的字符。
(-) 表示一个错误信息，具体信息是当前行－后面的字符。
(* ) 表示消息体总共有多少行，不包括当前行,*后面是具体的行数。
(美元符合) 表示下一行数据长度，不包括换行符长度\r\n，$后面则是对应的长度的数据。
(:) 表示返回一个数值，：后面是相应的数字节符。


分布式场景Redis客户端最优解决方案-lettuce + Redisson_第1张图片

Java客户端

Jedis

传统老牌Java客户端，一直在更新，对redis命令有比较全面的支持。

优点

  • 支持全面的Redis命令，具有全面的API。

缺点

  • 阻塞式I/O，其方法都是同步调用，程序流需要等到 sockets 处理完 I/O 才能执行，不支持异步；
  • Jedis 客户端实例不是线程安全的，所以需要通过连接池来使用 Jedis。

lettuce

lettuce是可扩展的线程安全的客户端，支持异步模式。如果避免阻塞和事务操作，如BLPOP和MULTI/EXEC，多个线程就可以共享一个连接。lettuce 底层基于 Netty，支持高级的 Redis 特性，比如哨兵，集群，管道，自动重新连接和Redis数据模型。

优点：

  • 支持同步异步通信模式；
  • Lettuce 的 API 是线程安全的，如果不是执行阻塞和事务操作，如BLPOP和MULTI/EXEC，多个线程就可以共享一个连接。
  • SpringBoot 2.x默认Redis客户端，对Lettuce 提供完美支持

Redisson

Redisson 是一个在 Redis 的基础上实现的 Java 驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的 Java 常用对象，还提供了许多分布式服务。其中包括( BitSet, Set, Multimap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, AtomicLong, CountDownLatch, Publish / Subscribe, Bloom filter, Remote service, Spring cache, Executor service, Live Object service, Scheduler service) Redisson 提供了使用Redis 的最简单和最便捷的方法。Redisson 的宗旨是促进使用者对Redis的关注分离（Separation of Concern），从而让使用者能够将精力更集中地放在处理业务逻辑上。
优点：

  • 使用者对 Redis 的关注分离，可以类比 Spring 框架，这些框架搭建了应用程序的基础框架和功能，提升开发效率，让开发者有更多的时间来关注业务逻辑；
  • 提供很多分布式相关操作服务，例如，分布式锁，分布式集合，可通过Redis支持延迟队列等。
    缺点：
  • Redisson 对字符串的操作支持比较差。

Redis Java客户端技术选型

文章基于SpringBoot 2.x进行选型

  • 仅使用Redis进行字符串的数据进行缓存处理，可以使用默认的lettuce。
  • 需要使用Redis做分布式事务，可以选择lettuce + Redisson。
  • 需要缓存分布式集合数据并对集合进行频繁读写操作，可以选择lettuce + Redisson。
  • 使用Redis 做消息队列，可以选择lettuce + Redisson。

SpringBoot 集成lettuce + Redisson

在大多数分布式互联网应用中，redis经常用来处理复杂业务而不是单纯的字符串存储，比如使用Redis集合、分布式锁、队列等，因此集成lettuce + Redisson，按照不同业务而使用不同组件是比较优秀的方案。

集成lettuce

  • 引入依赖
       
        
            org.springframework.session
            spring-session-data-redis

SpringBoot 2.X默认使用lettuce ，因此提供了比较好的支持，RedisAutoConfiguration完成了对JedisConnectionFactory和LettuceConnectionFactory 的自动配置。同时RedisProperties封装了redis配置。

  • 添加配置
    application.yml
spring:
    redis:
        host: 192.168.128.20 #单机配置
        port: 6379 #单机配置
        #cluster:
          #nodes: xxxurl  集群配置
        # Redis默认情况下有16个分片，配置具体使用的分片，默认为0
        database: 0
        lettuce:
          pool:
            # 连接池最大连接数 默认8 ，负数表示没有限制
            max-active: 8
            # 连接池最大阻塞等待时间（使用负值表示没有限制） 默认-1
            max-wait: -1
            # 连接池中的最大空闲连接 默认8
            max-idle: 8
            # 连接池中的最小空闲连接 默认0
            min-idle: 0

集成Redission

  • 引入依赖

      
        org.redisson
        redisson
        ${redisson.version}
  • 添加配置
    redisson.yml
    redission:
      pool:
            # 连接池最大连接数 默认8 ，负数表示没有限制
            max-active: 8
            # 连接池最大阻塞等待时间（使用负值表示没有限制） 默认-1
            max-wait: -1
            # 连接池中的最大空闲连接 默认8
            max-idle: 8
            # 连接池中的最小空闲连接 默认0
            min-idle: 0
            connTimeout: 10000
            timeout: 3000
            soTimeout: 3000
            size: 32
       #集群配置
        cluster:
          #集群扫描间隔时间 单位毫秒
          scanInterval: 1000
          # 只在从服务节点里读取
          readMode: "SLAVE"
           slaveSubscriptionConnectionPoolSize: 50
            # 从节点最小空闲连接数
            slaveConnectionMinimumIdleSize: 32
            # 从节点连接池大小
            slaveConnectionPoolSize: 64
            # 主节点最小空闲连接数
            masterConnectionMinimumIdleSize: 32
            # 主节点连接池大小
            masterConnectionPoolSize: 64
            # 命令失败重试次数
            retryAttempts: 3
             # 命令重试发送时间间隔
              retryInterval: 1500
              # failedAttempts
              failedAttempts: 3

配置客户端

@EnableConfigurationProperties({RedissionProperties.class, RedisProperties.class})
public class RedisConfig {

  @Value("${spring.profiles.active}")
  private String env;

  @Value("${global-conf.active-profiles.prod}")
  private String activeProd;

  @Autowired
  private RedisProperties redisProperties;

  @Autowired
  private RedissionProperties redissionProperties;

  /**
   * springboot2.x 使用LettuceConnectionFactory 代替 RedisConnectionFactory
   * 在application.yml配置基本信息后,springboot2.x  RedisAutoConfiguration能够自动装配 LettuceConnectionFactory 和
   * RedisConnectionFactory 及其 RedisTemplate 单机模式和集群模式配置都自动注入，因为在定义Lettuce客户端时无需显示指定模式
   *
   * @param redisConnectionFactory
   * @return
   */
  @Bean
  public RedisTemplate redisTemplate(
      LettuceConnectionFactory redisConnectionFactory) {

    RedisTemplate redisTemplate = new RedisTemplate<>();
    redisTemplate.setConnectionFactory(redisConnectionFactory);
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    redisTemplate.setValueSerializer(redisSerializer());
    redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    redisTemplate.setHashValueSerializer(redisSerializer());
    return redisTemplate;
  }

  @Bean
  @ConditionalOnProperty(name = "spring.redis.model", havingValue = "single")
  public RedissonClient getSingleRedisson() {
    Config config = new Config();

    String node = redisProperties.getHost();
    //用"rediss://"来启用SSL连接
    node = node.startsWith("redis://") ? node : "redis://" + node;
    SingleServerConfig serverConfig = config.useSingleServer();
    serverConfig.setAddress(node)
        .setConnectionPoolSize(redissionProperties.getPool().getSize())
        .setTimeout(redissionProperties.getPool().getTimeout())
        .setConnectionMinimumIdleSize(redissionProperties.getPool().getMinIdle());
    if (StringUtils.isNotBlank(redisProperties.getPassword())) {
      serverConfig.setPassword(redisProperties.getPassword());
    }

    return Redisson.create(config);
  }

  @Bean
  @ConditionalOnProperty(name = "spring.redis.model", havingValue = "cluster")
  public RedissonClient getClusterRedisson() {
    Config config = new Config();

    //用"rediss://"来启用SSL连接
    List newNodes = redisProperties.getCluster().getNodes()
        .stream()
        .map(node -> node.startsWith("redis://") ? node : "redis://" + node)
        .collect(
            Collectors.toList());

    ClusterServersConfig serverConfig = config.useClusterServers()
        .addNodeAddress(newNodes.toArray(new String[0]))
        .setScanInterval(
            redissionProperties.getCluster().getScanInterval())
        .setIdleConnectionTimeout(
            redissionProperties.getPool().getSoTimeout())
        .setConnectTimeout(
            redissionProperties.getPool().getConnTimeout())
        .setRetryAttempts(
            redissionProperties.getCluster().getRetryAttempts())
        .setRetryInterval(
            redissionProperties.getCluster().getRetryInterval())
        .setMasterConnectionPoolSize(redissionProperties.getCluster()
            .getMasterConnectionPoolSize())
        .setSlaveConnectionPoolSize(redissionProperties.getCluster()
            .getSlaveConnectionPoolSize())
        .setTimeout(redissionProperties.getPool().getTimeout());
    if (StringUtils.isNotBlank(redisProperties.getPassword())) {
      serverConfig.setPassword(redisProperties.getPassword());
    }
    return Redisson.create(config);
  }


  @Bean
  public RedisSerializer redisSerializer() {
    //创建JSON序列化器
    Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer<>(
        Object.class);
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    //必须设置，否则无法将JSON转化为对象，会转化成Map类型
    objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
        ObjectMapper.DefaultTyping.NON_FINAL);
    serializer.setObjectMapper(objectMapper);
    return serializer;
  }

  @Bean
  public RedisCacheManager redisCacheManager(LettuceConnectionFactory redisConnectionFactory) {
    RedisCacheWriter redisCacheWriter = RedisCacheWriter
        .nonLockingRedisCacheWriter(redisConnectionFactory);
    //设置Redis缓存有效期为1天
    RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
        .serializeValuesWith(
            RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer())).entryTtl(
            Duration.ofDays(1));
    return new RedisCacheManager(redisCacheWriter, redisCacheConfiguration);
  }
}
 
 
自定义Redis工具类
 
 
通常情况key一般是String类型，而value可能不一样，一般有两种：String和Object。
 如果k-v都是String，我们直接使用StringRedisTemplate
 
 
     
  
  • SimpleStringRedisUtil
    •  
 
 
 
@Component
public class SimpleStringRedisUtil {

  @Autowired
  private StringRedisTemplate redisTemplate;

  /**
   * 删除key
   *
   * @param key
   */
  public void delete(String key) {
    redisTemplate.delete(key);
  }

  /**
   * 序列化key
   *
   * @param key
   * @return
   */
  public byte[] dump(String key) {
    return redisTemplate.dump(key);
  }

  /**
   * 是否存在key
   *
   * @param key
   * @return
   */
  public Boolean exists(String key) {
    return redisTemplate.hasKey(key);
  }

  /**
   * 设置指定 key 的值
   *
   * @param key
   * @param value
   */
  public void set(String key, String value) {
    redisTemplate.opsForValue().set(key, value);
  }

  /**
   * 写入redis缓存（设置expire存活时间）
   * @param key
   * @param value
   * @param expire
   * @return
   */
  public void set(final String key, String value, Long expire){
      ValueOperations operations = redisTemplate.opsForValue();
      operations.set(key, value);
      redisTemplate.expire(key, expire, TimeUnit.SECONDS);
  }

  /**
   * 获取指定 key 的值
   *
   * @param key
   * @return
   */
  public String get(String key) {
    return redisTemplate.opsForValue().get(key);
  }
}

 
 
如果k-是String,v-是Object，比如Json对象、可序列化对象以及固定不变的集合等，那就需要需要RedisTemplate接口
 
 
     
  
  • SimpleObjectRedisUtil
    •  
 
 
 
@Component
public class SimpleObjectRedisUtil {

  @Autowired
  private RedisTemplate redisTemplate;


  public Set keys(String keys){
    try {
      return redisTemplate.keys(keys);
    }catch (Exception e){
      e.printStackTrace();
      return null;
    }
  }

  /**
   * 指定缓存失效时间
   * @param key 键
   * @param time 时间(秒)
   * @return
   */
  public boolean expire(String key, long time) {
    try {
      if (time > 0) {
        redisTemplate.expire(key, time, TimeUnit.SECONDS);
      }
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }

  /**
   * 指定缓存失效时间
   * @param key 键
   * @param time 时间
   * @param time timeUnit
   * @return
   */
  public boolean expire(String key, long time, TimeUnit timeUnit) {
    try {
      if (time > 0) {
        redisTemplate.expire(key, time, timeUnit);
      }
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }

  /**
   * 根据key 获取过期时间
   * @param key 键 不能为null
   * @return 时间(秒) 返回0代表为永久有效
   */
  public long getExpire(String key) {
    return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  }

  /**
   * 根据key 获取过期时间
   * @param key 键 不能为null
   * @param timeUnit
   * @return 时间(秒) 返回0代表为永久有效
   */
  public long getExpire(String key, TimeUnit timeUnit) {
    return redisTemplate.getExpire(key, timeUnit);
  }

  /**
   * 判断key是否存在
   * @param key 键
   * @return true 存在 false不存在
   */
  public boolean hasKey(String key) {
    try {
      return redisTemplate.hasKey(key);
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 删除缓存
   * @param key 可以传一个值 或多个
   */
  @SuppressWarnings("unchecked")
  public void del(String... key) {
    if (key != null && key.length > 0) {
      if (key.length == 1) {
        redisTemplate.delete(key[0]);
      } else {
        redisTemplate.delete(CollectionUtils.arrayToList(key));
      }
    }
  }
  /**
   * 普通缓存获取
   * @param key 键
   * @return 值
   */
  public Object get(String key) {
    return key == null ? null : redisTemplate.opsForValue().get(key);
  }
  /**
   * 普通缓存放入
   * @param key 键
   * @param value 值
   * @return true成功 false失败
   */
  public boolean set(String key, Object value) {
    try {
      redisTemplate.opsForValue().set(key, value);
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  

  /**
   * 普通缓存放入并设置时间
   * @param key 键
   * @param value 值
   * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
   * @return true成功 false 失败
   */
  public boolean set(String key, Object value, long time) {
    try {
      if (time > 0) {
        redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
      } else {
        set(key, value);
      }
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }

  /**
   * 普通缓存放入并设置时间
   * @param key 键
   * @param value 值
   * @param time 时间 time要大于0 如果time小于等于0 将设置无限期
   * @param timeUnit
   * @return true成功 false 失败
   */
  public boolean set(String key, Object value, long time, TimeUnit timeUnit) {
    try {
      if (time > 0) {
        redisTemplate.opsForValue().set(key, value, time, timeUnit);
      } else {
        set(key, value);
      }
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  

  /**
   * 递增
   * @param key 键
   * @param delta 要增加几(大于0)
   * @return
   */
  public long incr(String key, long delta) {
    if (delta < 0) {
      throw new RuntimeException("递增因子必须大于0");
    }
    return redisTemplate.opsForValue().increment(key, delta);
  }
  /**
   * 递减
   * @param key 键
   * @param delta 要减少几(小于0)
   * @return
   */
  public long decr(String key, long delta) {
    if (delta < 0) {
      throw new RuntimeException("递减因子必须大于0");
    }
    return redisTemplate.opsForValue().increment(key, -delta);
  }
  /**
   * HashGet
   * @param key 键 不能为null
   * @param item 项 不能为null
   * @return 值
   */
  public Object hget(String key, String item) {
    return redisTemplate.opsForHash().get(key, item);
  }
  /**
   * 获取hashKey对应的所有键值
   * @param key 键
   * @return 对应的多个键值
   */
  public Map hmget(String key) {
    return redisTemplate.opsForHash().entries(key);
  }
  
  /**
   * HashSet
   * @param key 键
   * @param map 对应多个键值
   * @return true 成功 false 失败
   */
  public boolean hmset(String key, Map map) {
    try {
      redisTemplate.opsForHash().putAll(key, map);
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * HashSet 并设置时间
   * @param key 键
   * @param map 对应多个键值
   * @param time 时间(秒)
   * @return true成功 false失败
   */
  public boolean hmset(String key, Map map, long time) {
    try {
      redisTemplate.opsForHash().putAll(key, map);
      if (time > 0) {
        expire(key, time);
      }
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 向一张hash表中放入数据,如果不存在将创建
   * @param key 键
   * @param item 项
   * @param value 值
   * @return true 成功 false失败
   */
  public boolean hset(String key, String item, Object value) {
    try {
      redisTemplate.opsForHash().put(key, item, value);
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 向一张hash表中放入数据,如果不存在将创建
   * @param key 键
   * @param item 项
   * @param value 值
   * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
   * @return true 成功 false失败
   */
  public boolean hset(String key, String item, Object value, long time) {
    try {
      redisTemplate.opsForHash().put(key, item, value);
      if (time > 0) {
        expire(key, time);
      }
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 删除hash表中的值
   * @param key 键 不能为null
   * @param item 项 可以使多个 不能为null
   */
  public void hdel(String key, Object... item) {
    redisTemplate.opsForHash().delete(key, item);
  }
  /**
   * 判断hash表中是否有该项的值
   * @param key 键 不能为null
   * @param item 项 不能为null
   * @return true 存在 false不存在
   */
  public boolean hHasKey(String key, String item) {
    return redisTemplate.opsForHash().hasKey(key, item);
  }
  /**
   * hash递增 如果不存在,就会创建一个 并把新增后的值返回
   * @param key 键
   * @param item 项
   * @param by 要增加几(大于0)
   * @return
   */
  public double hincr(String key, String item, double by) {
    return redisTemplate.opsForHash().increment(key, item, by);
  }
  /**
   * hash递减
   * @param key 键
   * @param item 项
   * @param by 要减少记(小于0)
   * @return
   */
  public double hdecr(String key, String item, double by) {
    return redisTemplate.opsForHash().increment(key, item, -by);
  }

  // ===============================Set=================================
  /**
   * 根据key获取Set中的所有值
   * @param key 键
   * @return
   */
  public Set sGet(String key) {
    try {
      return redisTemplate.opsForSet().members(key);
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
  }
  /**
   * 根据value从一个set中查询,是否存在
   * @param key 键
   * @param value 值
   * @return true 存在 false不存在
   */
  public boolean sHasKey(String key, Object value) {
    try {
      return redisTemplate.opsForSet().isMember(key, value);
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 将数据放入set缓存
   * @param key 键
   * @param values 值 可以是多个
   * @return 成功个数
   */
  public long sSet(String key, Object... values) {
    try {
      return redisTemplate.opsForSet().add(key, values);
    } catch (Exception e) {
      e.printStackTrace();
      return 0;
    }
  }
  /**
   * 将set数据放入缓存
   * @param key 键
   * @param time 时间(秒)
   * @param values 值 可以是多个
   * @return 成功个数
   */
  public long sSetAndTime(String key, long time, Object... values) {
    try {
      Long count = redisTemplate.opsForSet().add(key, values);
      if (time > 0)
        expire(key, time);
      return count;
    } catch (Exception e) {
      e.printStackTrace();
      return 0;
    }
  }
  /**
   * 获取set缓存的长度
   * @param key 键
   * @return
   */
  public long sGetSetSize(String key) {
    try {
      return redisTemplate.opsForSet().size(key);
    } catch (Exception e) {
      e.printStackTrace();
      return 0;
    }
  }
  /**
   * 移除值为value的
   * @param key 键
   * @param values 值 可以是多个
   * @return 移除的个数
   */
  public long setRemove(String key, Object... values) {
    try {
      Long count = redisTemplate.opsForSet().remove(key, values);
      return count;
    } catch (Exception e) {
      e.printStackTrace();
      return 0;
    }
  }
  // ===============================list=================================
  /**
   * 获取list缓存的内容
   * @param key 键
   * @param start 开始
   * @param end 结束 0 到 -1代表所有值
   * @return
   */
  public List lGet(String key, long start, long end) {
    try {
      return redisTemplate.opsForList().range(key, start, end);
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
  }
  /**
   * 获取list缓存的长度
   * @param key 键
   * @return
   */
  public long lGetListSize(String key) {
    try {
      return redisTemplate.opsForList().size(key);
    } catch (Exception e) {
      e.printStackTrace();
      return 0;
    }
  }
  /**
   * 通过索引 获取list中的值
   * @param key 键
   * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
   * @return
   */
  public Object lGetIndex(String key, long index) {
    try {
      return redisTemplate.opsForList().index(key, index);
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
  }
  /**
   * 将list放入缓存
   * @param key 键
   * @param value 值
   * @return
   */
  public  boolean lSet(String key, T value) {
    try {
      redisTemplate.opsForList().rightPush(key, value);
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 将list放入缓存
   * @param key 键
   * @param value 值
   * @param time 时间(秒)
   * @return
   */
  public  boolean lSet(String key, T value, long time) {
    try {
      redisTemplate.opsForList().rightPush(key, value);
      if (time > 0)
        expire(key, time);
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 将list放入缓存
   * @param key 键
   * @param value 值
   * @return
   */
  public  boolean lSet(String key, List value) {
    try {
      redisTemplate.opsForList().rightPushAll(key, value);
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 将list放入缓存
   *
   * @param key 键
   * @param value 值
   * @param time 时间(秒)
   * @return
   */
  public  boolean lSet(String key, List value, long time) {
    try {
      redisTemplate.opsForList().rightPushAll(key, value);
      if (time > 0)
        expire(key, time);
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 根据索引修改list中的某条数据
   * @param key 键
   * @param index 索引
   * @param value 值
   * @return
   */
  public  boolean lUpdateIndex(String key, long index, T value) {
    try {
      redisTemplate.opsForList().set(key, index, value);
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }
  }
  /**
   * 移除N个值为value
   * @param key 键
   * @param count 移除多少个
   * @param value 值
   * @return 移除的个数
   */
  public  long lRemove(String key, long count, T value) {
    try {
      Long remove = redisTemplate.opsForList().remove(key, count, value);
      return remove;
    } catch (Exception e) {
      e.printStackTrace();
      return 0;
    }
  }

  /**------------------zSet相关操作--------------------------------*/

  /**
   * 添加元素,有序集合是按照元素的score值由小到大排列
   *
   * @param key
   * @param value
   * @param score
   * @return
   */
  public Boolean zAdd(String key, String value, double score) {
    return redisTemplate.opsForZSet().add(key, value, score);
  }

  /**
   *
   * @param key
   * @param values
   * @return
   */
  public Long zAdd(String key, Set> values) {
    return redisTemplate.opsForZSet().add(key, values);
  }

  /**
   *
   * @param key
   * @param values
   * @return
   */
  public Long zRemove(String key, Object... values) {
    return redisTemplate.opsForZSet().remove(key, values);
  }

  /**
   * 增加元素的score值，并返回增加后的值
   *
   * @param key
   * @param value
   * @param delta
   * @return
   */
  public Double zIncrementScore(String key, String value, double delta) {
    return redisTemplate.opsForZSet().incrementScore(key, value, delta);
  }

  /**
   * 返回元素在集合的排名,有序集合是按照元素的score值由小到大排列
   *
   * @param key
   * @param value
   * @return 0表示第一位
   */
  public Long zRank(String key, Object value) {
    return redisTemplate.opsForZSet().rank(key, value);
  }

  /**
   * 返回元素在集合的排名,按元素的score值由大到小排列
   *
   * @param key
   * @param value
   * @return
   */
  public Long zReverseRank(String key, Object value) {
    return redisTemplate.opsForZSet().reverseRank(key, value);
  }

  /**
   * 获取集合的元素, 从小到大排序
   *
   * @param key
   * @param start
   *            开始位置
   * @param end
   *            结束位置, -1查询所有
   * @return
   */
  public Set zRange(String key, long start, long end) {
    return redisTemplate.opsForZSet().range(key, start, end);
  }

  /**
   * 获取集合元素, 并且把score值也获取
   *
   * @param key
   * @param start
   * @param end
   * @return
   */
  public Set> zRangeWithScores(String key, long start,
      long end) {
    return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
  }

  /**
   * 根据Score值查询集合元素
   *
   * @param key
   * @param min
   *            最小值
   * @param max
   *            最大值
   * @return
   */
  public Set zRangeByScore(String key, double min, double max) {
    return redisTemplate.opsForZSet().rangeByScore(key, min, max);
  }

  /**
   * 根据Score值查询集合元素, 从小到大排序
   *
   * @param key
   * @param min
   *            最小值
   * @param max
   *            最大值
   * @return
   */
  public Set> zRangeByScoreWithScores(String key,
      double min, double max) {
    return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max);
  }

  /**
   *
   * @param key
   * @param min
   * @param max
   * @param start
   * @param end
   * @return
   */
  public Set> zRangeByScoreWithScores(String key,
      double min, double max, long start, long end) {
    return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max,
        start, end);
  }

  /**
   * 获取集合的元素, 从大到小排序
   *
   * @param key
   * @param start
   * @param end
   * @return
   */
  public Set zReverseRange(String key, long start, long end) {
    return redisTemplate.opsForZSet().reverseRange(key, start, end);
  }

  /**
   * 获取集合的元素, 从大到小排序, 并返回score值
   *
   * @param key
   * @param start
   * @param end
   * @return
   */
  public Set> zReverseRangeWithScores(String key,
      long start, long end) {
    return redisTemplate.opsForZSet().reverseRangeWithScores(key, start,
        end);
  }

  /**
   * 根据Score值查询集合元素, 从大到小排序
   *
   * @param key
   * @param min
   * @param max
   * @return
   */
  public Set zReverseRangeByScore(String key, double min,
      double max) {
    return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max);
  }

  /**
   * 根据Score值查询集合元素, 从大到小排序
   *
   * @param key
   * @param min
   * @param max
   * @return
   */
  public Set> zReverseRangeByScoreWithScores(
      String key, double min, double max) {
    return redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key,
        min, max);
  }

  /**
   *
   * @param key
   * @param min
   * @param max
   * @param start
   * @param end
   * @return
   */
  public Set zReverseRangeByScore(String key, double min,
      double max, long start, long end) {
    return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max,
        start, end);
  }

  /**
   * 根据score值获取集合元素数量
   *
   * @param key
   * @param min
   * @param max
   * @return
   */
  public Long zCount(String key, double min, double max) {
    return redisTemplate.opsForZSet().count(key, min, max);
  }

  /**
   * 获取集合大小
   *
   * @param key
   * @return
   */
  public Long zSize(String key) {
    return redisTemplate.opsForZSet().size(key);
  }

  /**
   * 获取集合大小
   *
   * @param key
   * @return
   */
  public Long zZCard(String key) {
    return redisTemplate.opsForZSet().zCard(key);
  }

  /**
   * 获取集合中value元素的score值
   *
   * @param key
   * @param value
   * @return
   */
  public Double zScore(String key, Object value) {
    return redisTemplate.opsForZSet().score(key, value);
  }

  /**
   * 移除指定索引位置的成员
   *
   * @param key
   * @param start
   * @param end
   * @return
   */
  public Long zRemoveRange(String key, long start, long end) {
    return redisTemplate.opsForZSet().removeRange(key, start, end);
  }

  /**
   * 根据指定的score值的范围来移除成员
   *
   * @param key
   * @param min
   * @param max
   * @return
   */
  public Long zRemoveRangeByScore(String key, double min, double max) {
    return redisTemplate.opsForZSet().removeRangeByScore(key, min, max);
  }

  /**
   * 获取key和otherKey的并集并存储在destKey中
   *
   * @param key
   * @param otherKey
   * @param destKey
   * @return
   */
  public Long zUnionAndStore(String key, String otherKey, String destKey) {
    return redisTemplate.opsForZSet().unionAndStore(key, otherKey, destKey);
  }

  /**
   *
   * @param key
   * @param otherKeys
   * @param destKey
   * @return
   */
  public Long zUnionAndStore(String key, Collection otherKeys,
      String destKey) {
    return redisTemplate.opsForZSet()
        .unionAndStore(key, otherKeys, destKey);
  }

  /**
   * 交集
   *
   * @param key
   * @param otherKey
   * @param destKey
   * @return
   */
  public Long zIntersectAndStore(String key, String otherKey,
      String destKey) {
    return redisTemplate.opsForZSet().intersectAndStore(key, otherKey,
        destKey);
  }

  /**
   * 交集
   *
   * @param key
   * @param otherKeys
   * @param destKey
   * @return
   */
  public Long zIntersectAndStore(String key, Collection otherKeys,
      String destKey) {
    return redisTemplate.opsForZSet().intersectAndStore(key, otherKeys, destKey);
  }

  /**
   *
   * @param key
   * @param options
   * @return
   */
  public Cursor> zScan(String key, ScanOptions options) {
    return redisTemplate.opsForZSet().scan(key, options);
  }

}
 
 
对于锁、分布式集合操作、队列等分布式对象或服务，使用Redisson
 RedissonClient对锁、集合、队列等分布式操作进行了封装，开发者只需要简单的调用其接口进行操作：
 
 
     
  
  • 使用Redisson实现Redis分布式锁
     Redisson RLock实现了java.util.concurrent.locks.Lock接口，开发者可以显示调用Lock接口进行相关锁操作
    •  
 
 
 
//根据key获取分布式锁对象-普通可重入锁
    RLock lock = redissonClient.getLock("redisKey");
    //根据key获取分布式锁对象-公平可重入锁
    RLock fairLock = redissonClient.getFairLock("redisKey");

    //可重入锁
    //不指定时间，当加锁成功后会创建一个锁监听看门狗的监听器，
    // Redisson实例被关闭前，不断的延长锁的有效期。
    // 默认情况下，看门狗的检查锁的超时时间是30秒钟
    //fairLock.lock();
    lock.lock();
    try {
     //...
    } finally {
      //fairLock.unlock();
      lock.unlock();  //需要显示释放锁
    }

    //2. 显示指定加锁时间
    // 加锁以后10秒钟自动解锁
    // 无需调用unlock方法手动解锁
    //fairLock.lock(10, TimeUnit.SECONDS);
    lock.lock(10, TimeUnit.SECONDS);
    try {
      //...
    } finally {
      //fairLock.unlock();
      lock.unlock();  //需要显示释放锁
    }

    //3. 尝试获取锁
    // 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
    boolean res = false;
    try {
      //res = fairLock.tryLock(100, 10, TimeUnit.SECONDS);
      res = lock.tryLock(100, 10, TimeUnit.SECONDS);
      if (res) {
        
      }
    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      if (res) {
        //fairLock.unlock();
        lock.unlock();  //需要显示释放锁
      }
      
    }

 
 
     
  
  • 使用Redisson实现集合操作
    •  
 
 
 

@Autowired
private RedissonClient redissonClient;

//List操作
//RList Java对象在实现了java.util.List，同时确保了插入顺序
RList nameList = client.getList("redisKey");    
nameList.clear();   
nameList.add("bingo");  
nameList.add("yanglbme");   
nameList.add("https://github.com/redisson");    
nameList.remove(-1);    
boolean contains = nameList.contains("redisson");       
nameList.forEach(System.out::println);  

//Hash表
//RMap对象实现了`java.util.concurrent.ConcurrentMap`接口和`java.util.Map`接/口。与HashMap不同的是，RMap保持了元素的插入顺序。
RMap map = redisson.getMap("redisKey");
SomeObject prevObject = map.put("redisson1", new SomeObject());
SomeObject currentObject = map.putIfAbsent("redisson2", new SomeObject());
SomeObject obj = map.remove("redisson1");
map.fastPut("redisson1", new SomeObject());
map.fastRemove("redisson2");
//锁定map内元素
RLock keyLock = map.getLock("mapKey");
keyLock.lock();
try {
   SomeObjectv = map.get("mapKey");
   // 其他业务逻辑
} finally {
   keyLock.unlock();
}
//读写锁
RReadWriteLock rwLock = map.getReadWriteLock("mapKey");
rwLock.readLock().lock();
try {
   MyValue v = map.get("mapKey");
   // 其他业务逻辑
} finally {
   keyLock.readLock().unlock();
}       

 
 
     
  
  • 使用Redisson实现延迟队列
    •  
 
 
 
//延迟队列工具类
@Component
@Slf4j
public class RedisDelayedQueue {

  @Autowired
  RedissonClient redissonClient;

  /**
   * 任务回调监听
   *
   * @param
   */
  public abstract static class TaskEventListener {

      /**
       * 执行方法
       *
       * @param t
       */
      public abstract void invoke(T t);
  }



  /**
   * 添加队列
   *
   * @param t        DTO传输类
   * @param delay    时间数量
   * @param timeUnit 时间单位
   */
  public void addQueue(T t, long delay, TimeUnit timeUnit) {
    RBlockingQueue blockingFairQueue = redissonClient.getBlockingQueue(t.getClass().getName());
    RDelayedQueue delayedQueue = redissonClient.getDelayedQueue(blockingFairQueue);
    delayedQueue.offer(t, delay, timeUnit);
    delayedQueue.destroy();
  }

  /**
   * 获取队列
   *
   * @param zClass            DTO泛型
   * @param taskEventListener 任务回调监听
   * @return
   */
  public void getQueue(Class zClass, TaskEventListener taskEventListener) {
    RBlockingQueue blockingFairQueue = redissonClient.getBlockingQueue(zClass.getName());
    ((Runnable) () -> {
      while (true) {
        try {
          T t = (T) blockingFairQueue.take();
          taskEventListener.invoke(t);
        } catch (InterruptedException e) {
          log.error("获取队列异常，原因:{}", e);
        }
      }
    }).run();
  }
}
//添加延迟队列监听
@Component
@Slf4j
public class NotifySubscribeListener implements CommandLineRunner {

  @Autowired
  private RedisDelayedQueue redisDelayedQueue;

  @Autowired
  private EmsEventQueueHelper emsEventQueueHelper;

  @Override
  public void run(String... args) throws Exception {

    //监听延迟队列
    RedisDelayedQueue.TaskEventListener taskEventListener = new RedisDelayedQueue.TaskEventListener() {

      @Override
      public void invoke(Object o) {
        EmsEventInfo info = (EmsEventInfo) o;
        log.info("延迟队列执行任务:{}", info.toString());
        emsEventQueueHelper.publishEvent(info);
      }

    };
    redisDelayedQueue.getQueue(EmsEventInfo.class, taskEventListener);
  }
}

//队列入列
//省略......
    @Autowired
    private RedisDelayedQueue redisDelayedQueue;
//省略......
//入列
redisDelayedQueue.addQueue(info, emsTmpProperties.getNotifyTime(), TimeUnit.MINUTES);

 
 
更多用法参考Redisson官网https://github.com/redisson/redisson
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(分布式场景Redis客户端最优解决方案-lettuce + Redisson)

        

            

                
    
                    
  • 消息中间件有哪些常见类型
                        xmh-sxh-1314
java
                        
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
    
                    
    • 
                    
  • 高级编程--XML+socket练习题
                        masa010
java开发语言
                        
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
    
                    
    • 
                    
  • 三大师传
                        beca酱

                        
    巴尔扎克的作品被誉为“法国社会的一面镜子”。文学大师维克多·雨果对巴尔扎克的评价是：“在最伟大的人物中间，巴尔扎克是名列前茅者；在最优秀的人物中间，巴尔扎克是佼佼者之一。”一个原本寂寂无名的小人物，从地中海的某个海岛上，只身一人来到巴黎，没有朋友，也没有名望。作为一个一文不名的外乡人，凭着赤手空拳赢得了巴黎，征服了整个法兰西，并且赢得了世界。这个人就是十九世纪法国伟大的军事家、政治家，法兰西第一帝
    
                    
    • 
                    
  • 关于提高复杂业务逻辑代码可读性的思考
                        编程经验分享
开发经验java数据库开发语言
                        
    目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
    
                    
    • 
                    
  • 使用Apify加载Twitter消息以进行微调的完整指南
                        nseejrukjhad
twittereasyui前端python
                        
    #使用Apify加载Twitter消息以进行微调的完整指南##引言在自然语言处理领域，微调模型以适应特定任务是提升模型性能的常见方法。本文将介绍如何使用Apify从Twitter导出聊天信息，以便进一步进行微调。##主要内容###使用Apify导出推文首先，我们需要从Twitter导出推文。Apify可以帮助我们做到这一点。通过Apify的强大功能，我们可以批量抓取和导出数据，适用于各类应用场景。
    
                    
    • 
                    
  • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具
                        nseejrukjhad
数据库python
                        
    深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
    
                    
    • 
                    
  • GitHub上克隆项目
                        bigbig猩猩
github
                        
    从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
    
                    
    • 
                    
  • CX8903：Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片
                        诚芯微科技
社交电子
                        
    CX8903：电动Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片推荐。电动助力自行车EBIKE凭借其环保、健康、低噪、和便捷等特点，成为了越来越受欢迎的骑行便利交通工具。提供电动Ebike自行车仪表电源方案开发、E-BIKE电动助力自行车仪表供电电源解决方案。CX8903采用100V高压制造工艺（芯片最高耐压可到100V以上），SOP-8L贴片封装，CX8903内置100V/90mΩ
    
                    
    • 
                    
  • CX8836：小体积大功率升降压方案推荐（附Demo设计指南）
                        诚芯微科技
社交电子
                        
    CX8836是一颗同步四开关单向升降压控制器，在4.5V-40V宽输入电压范围内稳定工作，持续负载电流10A，能够在输入高于或低于输出电压时稳定调节输出电压，可适用于USBPD快充、车载充电器、HUB、汽车启停系统、工业PC电源等多种升降压应用场合，为大功率TYPE-CPD车载充电器提供最优解决方案。提供CX8836Demo测试、CX8836样品申请及CX8836方案开发技术支持。CX8836同升
    
                    
    • 
                    
  • 01-Git初识
                        Meereen
Gitgit
                        
    01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
    
                    
    • 
                    
  • Redis系列：Geo 类型赋能亿级地图位置计算
                        Ly768768
redisbootstrap数据库
                        
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
    
                    
    • 
                    
  • OPENAIGC开发者大赛企业组AI黑马奖 | AIGC数智传媒解决方案
                        RPA中国
人工智能AIGC传媒
                        
    在第二届拯救者杯OPENAIGC开发者大赛中，涌现出一批技术突出、创意卓越的作品。为了让这些优秀项目被更多人看到，我们特意开设了优秀作品报道专栏，旨在展示其独特之处和开发者的精彩故事。无论您是技术专家还是爱好者，希望能带给您不一样的知识和启发。让我们一起探索AIGC的无限可能，见证科技与创意的完美融合！创未来AI应用赛-企业组AI黑马奖作品名称：AIGC数智传媒解决方案参赛团队：深圳市三象智能技术
    
                    
    • 
                    
  • Xinference如何注册自定义模型
                        玩人工智能的辣条哥
人工智能AI大模型Xinference
                        
    环境：Xinference问题描述：Xinference如何注册自定义模型解决方案：1.写个model_config.json，内容如下{"version":1,"context_length":2048,"model_name":"custom-llama-3","model_lang":["en","ch"],"model_ability":["generate","chat"],"model
    
                    
    • 
                    
  • ES聚合分析原理与代码实例讲解
                        光剑书架上的书
大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据AIGCAGILLMJavaPython架构设计Agent程序员实现财富自由
                        
    ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
    
                    
    • 
                    
  • 提高教师信息素养，提高道德与法治课教学效益
                        长白159宋彦红

                        
    提高教师信息素养，提高道德与法治课教学效益随着经济和社会的发展，信息技术已经运用到课堂教学中，为课堂教学展示了一个崭新的天地。的确，信息技术形象、生动、直观性强，能够将课本中的一些抽想的概念直接展示在学生面前，从而调动学生的眼、耳、脑，让他们兴奋起来，变被动学习为主动学习，充分发挥教师的教育引导作用，创造一个可以使学生积极参与的场景。在制作、使用信息技术的实践过程中，本文拟就教师提升信息素养的必要
    
                    
    • 
                    
  • 网络编程基础
                        记得开心一点啊
网络
                        
    目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
    
                    
    • 
                    
  • 母亲节如何做小红书营销
                        美橙传媒

                        
    小红书的一举一动引起了外界的高度关注。通过爆款笔记和流行话题，我们可以看到“干货”类型的内容在小红书中偏向实用的生活经验共享和生活指南非常受欢迎。根据运营社的分析，这种现象是由小红书用户心智和内容社区背后机制共同决定的。首先，小红书将使用“强搜索”逻辑为用户提供特定的“搜索场景”。在“我必须这样生活”中，大量使用了满足小红书站用户喜好和需求的内容。内容社区自制的高质量内容也吸引了寻找营销新途径的品
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • Kafka是如何保证数据的安全性、可靠性和分区的
                        喜欢猪猪
kafka分布式
                        
    Kafka作为一个高性能、可扩展的分布式流处理平台，通过多种机制来确保数据的安全性、可靠性和分区的有效管理。以下是关于Kafka如何保证数据安全性、可靠性和分区的详细解析：一、数据安全性SSL/TLS加密：Kafka支持SSL/TLS协议，通过配置SSL证书和密钥来加密数据传输，确保数据在传输过程中不会被窃取或篡改。这一机制有效防止了中间人攻击，保护了数据的安全性。SASL认证：Kafka支持多种
    
                    
    • 
                    
  • 到现在才发现自己有病
                        骑着大脑去南极

                        
    原来人们真的喜欢对某一概念设限的，为什么这么说的，如果说工作，你可能在脑子浮现出的工作的大概印象就是被动的干着不喜欢的活，被动拿着那些微薄的工资的场景。但是也不排除可能把工作想成成长的样子的人，只是这种物种很少吧。就比如像病这个概念，大部分可能仅仅就把他局限在身体上出现的异常不舒服状况称之为病，直到近代才把病拓展到精神层面。。。最近才发现原来在精神层面上是有病的，原来曾经认为自己是一个无比健康的小
    
                    
    • 
                    
  • MongoDB知识概括
                        GeorgeLin98
持久层mongodb
                        
    MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
    
                    
    • 
                    
  • Python算法L5：贪心算法
                        小熊同学哦
Python算法算法python贪心算法
                        
    Python贪心算法简介目录Python贪心算法简介贪心算法的基本步骤贪心算法的适用场景经典贪心算法问题1.**零钱兑换问题**2.**区间调度问题**3.**背包问题**贪心算法的优缺点优点：缺点：结语贪心算法（GreedyAlgorithm）是一种在每一步选择中都采取当前最优或最优解的算法。它的核心思想是，在保证每一步局部最优的情况下，希望通过贪心选择达到全局最优解。虽然贪心算法并不总能得到全
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • [Unity]在场景中随机生成不同位置且不重叠的物体
                        Bartender_Jill
Graphics图形学笔记unity游戏引擎动画
                        
    1.前言最近任务需要用到Unity在场景中随机生成物体，且这些物体不能重叠，简单记录一下。参考资料:Howtoensurethatspawnedtargetsdonotoverlap?2.结果与代码结果如下所示：代码如下所示：usingSystem.Collections.Generic;usingUnityEngine;namespaceAssets.Scripts{publicclassNew
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 深入浅出 -- 系统架构之负载均衡Nginx的性能优化
                        xiaoli8748_软件开发
系统架构系统架构负载均衡nginx
                        
    一、Nginx性能优化到这里文章的篇幅较长了，最后再来聊一下关于Nginx的性能优化，主要就简单说说收益最高的几个优化项，在这块就不再展开叙述了，毕竟影响性能都有多方面原因导致的，比如网络、服务器硬件、操作系统、后端服务、程序自身、数据库服务等，对于性能调优比较感兴趣的可以参考之前《JVM性能调优》中的调优思想。优化一：打开长连接配置通常Nginx作为代理服务，负责分发客户端的请求，那么建议开启H
    
                    
    • 
                    
  • 经纬恒润二面&三七互娱一面&元象二面
                        Redstone Monstrosity
面试前端
                        
    1.请尽可能详细地说明，进程和线程的区别，分别有哪些应用场景？进程间如何通信？线程间如何通信？你的回答中不要写出示例代码。进程和线程是操作系统中的两个基本概念，它们在计算机系统中扮演着不同的角色，并且在不同的应用场景中发挥作用。进程和线程的区别定义：进程：进程是操作系统进行资源分配和调度的基本单位。每个进程都有独立的内存空间和系统资源。线程：线程是进程内的一个执行单元，是操作系统进行调度的最小单位
    
                    
    • 
                    
  • 补充元象二面
                        Redstone Monstrosity
前端面试
                        
    1.请尽可能详细地说明，防抖和节流的区别，应用场景？你的回答中不要写出示例代码。防抖（Debounce）和节流（Throttle）是两种常用的前端性能优化技术，它们的主要区别在于如何处理高频事件的触发。以下是防抖和节流的区别和应用场景的详细说明：防抖和节流的定义防抖：在一段时间内，多次执行变为只执行最后一次。防抖的原理是，当事件被触发后，设置一个延迟定时器。如果在这个延迟时间内事件再次被触发，则重
    
                    
    • 
                    
  • 2022-05-22光印随思60学习要与现实打通
                        无名之米8

                        
    20220522光印随思60学习要与现实打通今天在匆忙中完成了新网师课程的第七次预习作业。每次完成预习作业的过程都是一次艰难的学习，先要学习相关的文本和文件，了解作业需要的理论知识，之后需要把理论知识运用于实际工作和生活中。这也是学习的真正价值所在。在很多时候，会有这样的感觉，读了很多书为什么没有啥长进？现在回想应该就是，当只有阅读和感受，没有把阅读心得转化为文字，没有把阅读的知识运用到实际的场景
    
                    
    • 
                    
  • 《 C++ 修炼全景指南：四 》揭秘 C++ List 容器背后的实现原理，带你构建自己的双向链表
                        Lenyiin
技术指南C++修炼全景指南c++list链表stl
                        
    本篇博客，我们将详细讲解如何从头实现一个功能齐全且强大的C++List容器，并深入到各个细节。这篇博客将包括每一步的代码实现、解释以及扩展功能的探讨，目标是让初学者也能轻松理解。一、简介1.1、背景介绍在C++中，std::list是一个基于双向链表的容器，允许高效的插入和删除操作，适用于频繁插入和删除操作的场景。与动态数组不同，list允许常数时间内的插入和删除操作，支持双向遍历。这篇文章将详细
    
                    
    • 
                                
  • iOS http封装
                                    374016526
ios服务器交互http网络请求
                                    
    程序开发避免不了与服务器的交互，这里打包了一个自己写的http交互库。希望可以帮到大家。 
  
内置一个basehttp，当我们创建自己的service可以继承实现。 
  
KuroAppBaseHttp *baseHttp = [[KuroAppBaseHttp alloc] init]; 
[baseHttp setDelegate:self]; 
[baseHttp 
    
                                
    • 
                                
  • lolcat ：一个在 Linux 终端中输出彩虹特效的命令行工具
                                    brotherlamp
linuxlinux教程linux视频linux自学linux资料
                                    
      
那些相信 Linux 命令行是单调无聊且没有任何乐趣的人们，你们错了，这里有一些有关 Linux 的文章，它们展示着 Linux 是如何的有趣和“淘气” 。 
在本文中，我将讨论一个名为“lolcat”的小工具 – 它可以在终端中生成彩虹般的颜色。 
何为 lolcat ? 
Lolcat 是一个针对 Linux，BSD 和 OSX 平台的工具，它类似于 cat 命令，并为 cat
    
                                
    • 
                                
  • MongoDB索引管理（1）——[九]
                                    eksliang
mongodbMongoDB管理索引
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2178427 一、概述 
      数据库的索引与书籍的索引类似，有了索引就不需要翻转整本书。数据库的索引跟这个原理一样，首先在索引中找，在索引中找到条目以后，就可以直接跳转到目标文档的位置，从而使查询速度提高几个数据量级。 
      不使用索引的查询称
    
                                
    • 
                                
  • Informatica参数及变量
                                    18289753290
Informatica参数变量
                                    
    下面是本人通俗的理解，如有不对之处，希望指正 info参数的设置：在info中用到的参数都在server的专门的配置文件中（最好以parma）结尾 下面的GLOBAl就是全局的，$开头的是系统级变量，$$开头的变量是自定义变量。如果是在session中或者mapping中用到的变量就是局部变量，那就把global换成对应的session或者mapping名字。 
 
 
[GLOBAL] $Par
    
                                
    • 
                                
  • python 解析unicode字符串为utf8编码字符串
                                    酷的飞上天空
unicode
                                    
    php返回的json字符串如果包含中文，则会被转换成\uxx格式的unicode编码字符串返回。 
在浏览器中能正常识别这种编码，但是后台程序却不能识别，直接输出显示的是\uxx的字符，并未进行转码。 
  
转换方式如下 
  
  
>>> import json
>>> q = '{"text":"\u4
    
                                
    • 
                                
  • Hibernate的总结
                                    永夜-极光
Hibernate
                                    
    1.hibernate的作用,简化对数据库的编码,使开发人员不必再与复杂的sql语句打交道 
  
做项目大部分都需要用JAVA来链接数据库，比如你要做一个会员注册的 页面，那么 获取到用户填写的 基本信后，你要把这些基本信息存入数据库对应的表中，不用hibernate还有mybatis之类的框架，都不用的话就得用JDBC，也就是JAVA自己的，用这个东西你要写很多的代码，比如保存注册信
    
                                
    • 
                                
  • SyntaxError: Non-UTF-8 code starting with '\xc4'
                                    随便小屋
python
                                    
    刚开始看一下Python语言，传说听强大的，但我感觉还是没Java强吧！ 
写Hello World的时候就遇到一个问题，在Eclipse中写的，代码如下 
'''
Created on 2014年10月27日

@author: Logic
'''
print("Hello World!"); 
 运行结果 
SyntaxError: Non-UTF-8 
    
                                
    • 
                                
  • 学会敬酒礼仪 不做酒席菜鸟
                                    aijuans
菜鸟
                                    
    俗话说，酒是越喝越厚，但在酒桌上也有很多学问讲究，以下总结了一些酒桌上的你不得不注意的小细节。 
 细节一：领导相互喝完才轮到自己敬酒。敬酒一定要站起来，双手举杯。  
 细节二：可以多人敬一人，决不可一人敬多人，除非你是领导。  
 细节三：自己敬别人，如果不碰杯，自己喝多少可视乎情况而定，比如对方酒量，对方喝酒态度，切不可比对方喝得少，要知道是自己敬人。  
 细节四：自己敬别人，如果碰杯，一
    
                                
    • 
                                
  • 《创新者的基因》读书笔记
                                    aoyouzi
读书笔记《创新者的基因》
                                    
    创新者的基因 
  
创新者的“基因”，即最具创意的企业家具备的五种“发现技能”：联想，观察，实验，发问，建立人脉。 
  
第一部分破坏性创新，从你开始 
第一章破坏性创新者的基因 
如何获得启示： 
发现以下的因素起到了催化剂的作用：(1) -个挑战现状的问题；(2)对某项技术、某个公司或顾客的观察；(3) -次尝试新鲜事物的经验或实验；(4)与某人进行了一次交谈，为他点醒
    
                                
    • 
                                
  • 表单验证技术
                                    百合不是茶
JavaScriptDOM对象String对象事件
                                    
    js最主要的功能就是验证表单,下面是我对表单验证的一些理解,贴出来与大家交流交流  ,数显我们要知道表单验证需要的技术点, String对象,事件,函数 
  
一:String对象;通常是对字符串的操作; 
  
1,String的属性; 
  
    字符串.length;表示该字符串的长度;
   var str= "java"
    
                                
    • 
                                
  • web.xml配置详解之context-param
                                    bijian1013
javaservletweb.xmlcontext-param
                                    
    一.格式定义： 
<context-param>  
	<param-name>contextConfigLocation</param-name>  
	<param-value>contextConfigLocationValue></param-value>  
</context-param> 
作用：该元
    
                                
    • 
                                
  • Web系统常见编码漏洞（开发工程师知晓）
                                    Bill_chen
sqlPHPWebfckeditor脚本
                                    
    1.头号大敌：SQL Injection 
原因：程序中对用户输入检查不严格，用户可以提交一段数据库查询代码，根据程序返回的结果， 
获得某些他想得知的数据，这就是所谓的SQL Injection，即SQL注入。 
本质: 
对于输入检查不充分，导致SQL语句将用户提交的非法数据当作语句的一部分来执行。 
示例： 
String query = "SELECT id FROM users
    
                                
    • 
                                
  • 【MongoDB学习笔记六】MongoDB修改器
                                    bit1129
mongodb
                                    
    本文首先介绍下MongoDB的基本的增删改查操作，然后，详细介绍MongoDB提供的修改器，以完成各种各样的文档更新操作    MongoDB的主要操作 
 
 show dbs 显示当前用户能看到哪些数据库 
 use foobar 将数据库切换到foobar 
 show collections 显示当前数据库有哪些集合 
 db.people.update，update不带参数，可
    
                                
    • 
                                
  • 提高职业素养，做好人生规划
                                    白糖_
人生
                                    
      
培训讲师是成都著名的企业培训讲师，他在讲课中提出的一些观点很新颖，在此我收录了一些分享一下。注：讲师的观点不代表本人的观点，这些东西大家自己揣摩。 
  
1、什么是职业规划：职业规划并不完全代表你到什么阶段要当什么官要拿多少钱，这些都只是梦想。职业规划是清楚的认识自己现在缺什么，这个阶段该学习什么，下个阶段缺什么，又应该怎么去规划学习，这样才算是规划。 
  
    
                                
    • 
                                
  • 国外的网站你都到哪边看？
                                    bozch
技术网站国外
                                    
    学习软件开发技术，如果没有什么英文基础，最好还是看国内的一些技术网站，例如：开源OSchina，csdn，iteye,51cto等等。 
个人感觉如果英语基础能力不错的话，可以浏览国外的网站来进行软件技术基础的学习，例如java开发中常用的到的网站有apache.org 里面有apache的很多Projects,springframework.org是spring相关的项目网站,还有几个感觉不错的
    
                                
    • 
                                
  • 编程之美-光影切割问题
                                    bylijinnan
编程之美
                                    
    
package a;

public class DisorderCount {

	/**《编程之美》“光影切割问题”
	 * 主要是两个问题：
	 * 1.数学公式（设定没有三条以上的直线交于同一点）：
	 * 两条直线最多一个交点，将平面分成了4个区域；
	 * 三条直线最多三个交点，将平面分成了7个区域；
	 * 可以推出：N条直线 M个交点，区域数为N+M+1。

    
                                
    • 
                                
  • 关于Web跨站执行脚本概念
                                    chenbowen00
Web安全跨站执行脚本
                                    
    跨站脚本攻击(XSS)是web应用程序中最危险和最常见的安全漏洞之一。安全研究人员发现这个漏洞在最受欢迎的网站,包括谷歌、Facebook、亚马逊、PayPal,和许多其他网站。如果你看看bug赏金计划,大多数报告的问题属于 XSS。为了防止跨站脚本攻击,浏览器也有自己的过滤器,但安全研究人员总是想方设法绕过这些过滤器。这个漏洞是通常用于执行cookie窃取、恶意软件传播,会话劫持,恶意重定向。在
    
                                
    • 
                                
  • [开源项目与投资]投资开源项目之前需要统计该项目已有的用户数
                                    comsci
开源项目
                                    
     
 
 
        现在国内和国外,特别是美国那边,突然出现很多开源项目,但是这些项目的用户有多少,有多少忠诚的粉丝,对于投资者来讲,完全是一个未知数,那么要投资开源项目,我们投资者必须准确无误的知道该项目的全部情况,包括项目发起人的情况,项目的维持时间..项目的技术水平,项目的参与者的势力,项目投入产出的效益.....
    
                                
    • 
                                
  • oracle alert log file（告警日志文件）
                                    daizj
oracle告警日志文件alert log file
                                    
    The alert log is a chronological log of messages and errors, and includes the following items: 
 
All internal errors (ORA-00600), block corruption errors (ORA-01578), and deadlock errors (ORA-00060) 
    
                                
    • 
                                
  • 关于 CAS SSO 文章声明
                                    denger
SSO
                                    
    由于几年前写了几篇 CAS 系列的文章，之后陆续有人参照文章去实现，可都遇到了各种问题，同时经常或多或少的收到不少人的求助。现在这时特此说明几点： 
 
1.  那些文章发表于好几年前了，CAS 已经更新几个很多版本了，由于近年已经没有做该领域方面的事情，所有文章也没有持续更新。 
 
2. 文章只是提供思路，尽管 CAS 版本已经发生变化，但原理和流程仍然一致。最重要的是明白原理，然后
    
                                
    • 
                                
  • 初二上学期难记单词
                                    dcj3sjt126com
englishword
                                    
    lesson 课 
traffic 交通 
matter 要紧；事物 
happy 快乐的，幸福的 
second 第二的 
idea 主意；想法；意见 
mean 意味着 
important 重要的，重大的 
never 从来，决不 
afraid 害怕 的 
fifth 第五的 
hometown 故乡，家乡 
discuss 讨论；议论 
east 东方的 
agree 同意；赞成 
bo
    
                                
    • 
                                
  • uicollectionview 纯代码布局, 添加头部视图
                                    dcj3sjt126com
Collection
                                    
    #import <UIKit/UIKit.h>

@interface myHeadView : UICollectionReusableView
{
    UILabel   *TitleLable;
}
-(void)setTextTitle;
@end
 
#import "myHeadView.h"

@implementation m
    
                                
    • 
                                
  • N 位随机数字串的 JAVA 生成实现
                                    FX夜归人
javaMath随机数Random
                                    
    /**
 * 功能描述 随机数工具类<br />
 * @author FengXueYeGuiRen
 * 创建时间 2014-7-25<br />
 */
public class RandomUtil {
    //  随机数生成器
    private static java.util.Random random = new java.util.R
    
                                
    • 
                                
  • Ehcache（09）——缓存Web页面
                                    234390216
ehcache页面缓存
                                    
    页面缓存 
目录 
1       SimplePageCachingFilter 
1.1      calculateKey 
1.2      可配置的初始化参数 
1.2.1     cach
    
                                
    • 
                                
  • spring中少用的注解@primary解析
                                    jackyrong
primary
                                    
    这次看下spring中少见的注解@primary注解，例子 
 
 

@Component
public class MetalSinger implements Singer{

    @Override
    public String sing(String lyrics) {
        return "I am singing with DIO voice
    
                                
    • 
                                
  • Java几款性能分析工具的对比
                                    lbwahoo
java
                                    
    Java几款性能分析工具的对比 
摘自：http://my.oschina.net/liux/blog/51800 
  
在给客户的应用程序维护的过程中，我注意到在高负载下的一些性能问题。理论上，增加对应用程序的负载会使性能等比率的下降。然而，我认为性能下降的比率远远高于负载的增加。我也发现，性能可以通过改变应用程序的逻辑来提升，甚至达到极限。为了更详细的了解这一点，我们需要做一些性能
    
                                
    • 
                                
  • JVM参数配置大全
                                    nickys
jvm应用服务器
                                    
    JVM参数配置大全 
 
/usr/local/jdk/bin/java -Dresin.home=/usr/local/resin -server -Xms1800M -Xmx1800M -Xmn300M -Xss512K -XX:PermSize=300M -XX:MaxPermSize=300M -XX:SurvivorRatio=8 -XX:MaxTenuringThreshold=5 -
    
                                
    • 
                                
  • 搭建 CentOS 6 服务器(14) - squid、Varnish
                                    rensanning
varnish
                                    
    （一）squid 
 
安装 
 
# yum install httpd-tools -y
# htpasswd -c -b /etc/squid/passwords squiduser 123456
# yum install squid -y 
 
设置 
 
# cp /etc/squid/squid.conf /etc/squid/squid.conf.bak
# vi /etc/
    
                                
    • 
                                
  • Spring缓存注解@Cache使用
                                    tom_seed
spring
                                    
    参考资料 
http://www.ibm.com/developerworks/cn/opensource/os-cn-spring-cache/ 
http://swiftlet.net/archives/774 
  
缓存注解有以下三个： 
@Cacheable      @CacheEvict     @CachePut
    
                                
    • 
                                
  • dom4j解析XML时出现"java.lang.noclassdeffounderror: org/jaxen/jaxenexception"错误
                                    xp9802

                                    
    java.lang.NoClassDefFoundError: org/jaxen/JaxenExc 
关键字: java.lang.noclassdeffounderror: org/jaxen/jaxenexception 
使用dom4j解析XML时，要快速获取某个节点的数据，使用XPath是个不错的方法，dom4j的快速手册里也建议使用这种方式 
执行时却抛出以下异常： 
Exceptio
    
                                
    •