Spring Data Redis 单节点和集群配置和RedisTemplate用法

￡神魔★判官ぃ 2022-06-01 05:06 398阅读 0赞

#

Spring Data Redis 单节点和集群配置和RedisTemplate用法

标签（空格分隔）： Spring-Data

使用SpringData更加方便我们对关系型数据库和非关系型数据库更好的操作，封装了通用的代码，使得操作更加快捷简单。

一、Spring Data Redis的配置

  1. 引入相关jar包，注意依赖和冲突问题。
  2. maven 引入pom.xml：
  6.    1
  7.    2
  8.    3
  10. <dependency>
  11.       <groupId>junit</groupId>
  12.       <artifactId>junit</artifactId>
  13.       <version>4.12</version>
  14.     </dependency>
  16.     <!--spring-data-redis相关，会自动引入相关jar-->
  17.     <dependency>
  18.       <groupId>org.springframework.data</groupId>
  19.       <artifactId>spring-data-redis</artifactId>
  20.       <version>1.7.4.RELEASE</version>
  21.     </dependency>
  23.     <!--spring测试相关-->
  24.     <dependency>
  25.       <groupId>org.springframework</groupId>
  26.       <artifactId>spring-test</artifactId>
  27.       <version>4.2.8.RELEASE</version>
  28.     </dependency>
  30.     <!--redis相关-->
  31.     <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
  32.     <dependency>
  33.       <groupId>redis.clients</groupId>
  34.       <artifactId>jedis</artifactId>
  35.       <version>2.9.0</version>
  36.     </dependency>
  37.   </dependencies>
  40.    1
  41.    2
  42.    3
  43.    4
  44.    5
  45.    6
  46.    7
  47.    8
  48.    9
  49.    10
  50.    11
  51.    12
  52.    13
  53.    14
  54.    15
  55.    16
  56.    17
  57.    18
  58.    19
  59.    20
  60.    21
  61.    22
  62.    23
  63.    24
  64.    25
  65.    26
  66.    27
  67.    28

手动添加jar包 相关jar下载地址

这里写图片描述

配置文件

  1. 可以使用引入外部文件的方式也可以通过在xml文件中配置的方式
  5.    1
  6.    2

单节点配置方式

properties文件

  1. #JedisPoolConfig的参数
  2. #最大连接数
  3. redis.pool.maxTotal=30
  4. #最大空闲时间
  5. redis.pool.maxIdle=10
  6. #每次最大连接数
  7. redis.pool.numTestsPerEvictionRun=1024
  8. #释放扫描的扫描间隔
  9. redis.pool.timeBetweenEvictionRunsMillis=30000
  10. #连接的最小空闲时间
  11. redis.pool.minEvictableIdleTimeMillis=1800000
  12. #连接控歘按时间多久后释放，当空闲时间>该值且空闲连接>最大空闲连接数时直接释放
  13. redis.pool.softMinEvictableIdleTimeMillis=10000
  14. #获得链接时的最大等待毫秒数，小于0：阻塞不确定时间，默认-1
  15. redis.pool.maxWaitMillis=1500
  16. #在获得链接的时候检查有效性，默认false
  17. redis.pool.testOnBorrow=true
  18. #在空闲时检查有效性，默认false
  19. redis.pool.testWhileIdle=true
  20. #连接耗尽时是否阻塞，false报异常，true阻塞超时,默认true
  21. redis.pool.blockWhenExhausted=false
  23. #JedisConnectionFactory的参数
  24. #主机地址，默认：localhost
  25. redis.hostName=192.168.200.128
  26. #主机端口，默认：6379
  27. redis.port=6379
  28. #超时时间，默认：2000
  29. redis.timeout=3000
  30. #密码
  31. #redis.password
  32. #是否使用连接池，默认true
  33. redis.usePool=true
  34. #使用数据库的索引，0-15之间的数字，默认：0
  35. redis.dbIndex=0
  36. #是否使用数据类型的转换，默认：true
  37. #redis.convertPipelineAndTxResults
  38. #哨兵配置
  39. #redis.sentinelConfig
  40. #集群配置
  41. #redis.clusterConfig
  44.    1
  45.    2
  46.    3
  47.    4
  48.    5
  49.    6
  50.    7
  51.    8
  52.    9
  53.    10
  54.    11
  55.    12
  56.    13
  57.    14
  58.    15
  59.    16
  60.    17
  61.    18
  62.    19
  63.    20
  64.    21
  65.    22
  66.    23
  67.    24
  68.    25
  69.    26
  70.    27
  71.    28
  72.    29
  73.    30
  74.    31
  75.    32
  76.    33
  77.    34
  78.    35
  79.    36
  80.    37
  81.    38
  82.    39
  83.    40
  84.    41

xml配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  5.     <!--引入配置文件-->
  6.     <bean id="placeholderConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  7.         <property name="order" value="1"/>
  8.         <property name="ignoreUnresolvablePlaceholders" value="true"/>
  9.         <property name="locations">
  10.             <list>
  11.                 <value>classpath:redis.properties</value>
  12.             </list>
  13.         </property>
  14.     </bean>
  16.     <!--配置 jedis pool-->
  17.     <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
  18.         <!-- 最大连接数 -->
  19.         <property name="maxTotal" value="${redis.pool.maxTotal}"/>
  20.         <!-- 最大空闲时间 -->
  21.         <property name="maxIdle" value="${redis.pool.maxIdle}"/>
  22.         <!-- 每次最大连接数 -->
  23.         <property name="numTestsPerEvictionRun" value="${redis.pool.numTestsPerEvictionRun}"/>
  24.         <!-- 释放扫描的扫描间隔 -->
  25.         <property name="timeBetweenEvictionRunsMillis" value="${redis.pool.timeBetweenEvictionRunsMillis}"/>
  26.         <!-- 连接的最小空闲时间 -->
  27.         <property name="minEvictableIdleTimeMillis" value="${redis.pool.minEvictableIdleTimeMillis}"/>
  28.         <!-- 连接控歘按时间多久后释放，当空闲时间>该值且空闲连接>最大空闲连接数时直接释放 -->
  29.         <property name="softMinEvictableIdleTimeMillis" value="${redis.pool.softMinEvictableIdleTimeMillis}"/>
  30.         <!-- 获得链接时的最大等待毫秒数，小于0：阻塞不确定时间，默认-1 -->
  31.         <property name="maxWaitMillis" value="${redis.pool.maxWaitMillis}"/>
  32.         <!-- 在获得链接的时候检查有效性，默认false -->
  33.         <property name="testOnBorrow" value="${redis.pool.testOnBorrow}"/>
  34.         <!-- 在空闲时检查有效性，默认false -->
  35.         <property name="testWhileIdle" value="${redis.pool.testWhileIdle}"/>
  36.         <!-- 连接耗尽时是否阻塞，false报异常，true阻塞超时 默认：true-->
  37.         <property name="blockWhenExhausted" value="${redis.pool.blockWhenExhausted}"/>
  38.     </bean>
  40.     <!--spring data redis -->
  41.     <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
  42.         <property name="hostName" value="${redis.hostName}"/>
  43.         <property name="port" value="${redis.port}"/>
  44.         <property name="timeout" value="${redis.timeout}"/>
  45.         <property name="database" value="${redis.dbIndex}"/>
  46.         <property name="usePool" value="${redis.usePool}"/>
  47.         <!--可以通过构造注入或者Set注入两种方式-->
  48.         <property name="poolConfig" ref="jedisPoolConfig"/>
  49.     </bean>
  51.     <!--redisTemplate-->
  52.     <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
  53.         <property name="connectionFactory" ref="jedisConnectionFactory"/>
  54.     </bean>
  56. </beans>
  59.    1
  60.    2
  61.    3
  62.    4
  63.    5
  64.    6
  65.    7
  66.    8
  67.    9
  68.    10
  69.    11
  70.    12
  71.    13
  72.    14
  73.    15
  74.    16
  75.    17
  76.    18
  77.    19
  78.    20
  79.    21
  80.    22
  81.    23
  82.    24
  83.    25
  84.    26
  85.    27
  86.    28
  87.    29
  88.    30
  89.    31
  90.    32
  91.    33
  92.    34
  93.    35
  94.    36
  95.    37
  96.    38
  97.    39
  98.    40
  99.    41
  100.    42
  101.    43
  102.    44
  103.    45
  104.    46
  105.    47
  106.    48
  107.    49
  108.    50
  109.    51
  110.    52
  111.    53
  112.    54
  113.    55
  114.    56
  115.    57
  116.    58

集群配置方式
properties文件

  1. #JedisPoolConfig的参数
  2. #最大连接数
  3. redis.pool.maxTotal=30
  4. #最大空闲时间
  5. redis.pool.maxIdle=10
  6. #每次最大连接数
  7. redis.pool.numTestsPerEvictionRun=1024
  8. #释放扫描的扫描间隔
  9. redis.pool.timeBetweenEvictionRunsMillis=30000
  10. #连接的最小空闲时间
  11. redis.pool.minEvictableIdleTimeMillis=1800000
  12. #连接控歘按时间多久后释放，当空闲时间>该值且空闲连接>最大空闲连接数时直接释放
  13. redis.pool.softMinEvictableIdleTimeMillis=10000
  14. #获得链接时的最大等待毫秒数，小于0：阻塞不确定时间，默认-1
  15. redis.pool.maxWaitMillis=1500
  16. #在获得链接的时候检查有效性，默认false
  17. redis.pool.testOnBorrow=true
  18. #在空闲时检查有效性，默认false
  19. redis.pool.testWhileIdle=true
  20. #连接耗尽时是否阻塞，false报异常，true阻塞超时,默认true
  21. redis.pool.blockWhenExhausted=false
  22. #RedisClusterConfiguration配置
  23. redis.maxRedirects=5
  24. #主机和端口号
  25. redis.host1=192.168.200.128
  26. redis.port1=7000
  27. redis.host2=192.168.200.128
  28. redis.port2=7001
  29. redis.host3=192.168.200.128
  30. redis.port3=7002
  31. redis.host4=192.168.200.128
  32. redis.port4=7003
  33. redis.host5=192.168.200.128
  34. redis.port5=7004
  35. redis.host6=192.168.200.128
  36. redis.port6=7005
  39.    1
  40.    2
  41.    3
  42.    4
  43.    5
  44.    6
  45.    7
  46.    8
  47.    9
  48.    10
  49.    11
  50.    12
  51.    13
  52.    14
  53.    15
  54.    16
  55.    17
  56.    18
  57.    19
  58.    20
  59.    21
  60.    22
  61.    23
  62.    24
  63.    25
  64.    26
  65.    27
  66.    28
  67.    29
  68.    30
  69.    31
  70.    32
  71.    33
  72.    34
  73.    35
  74.    36

xml配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  5.     <!--引入配置文件-->
  6.     <bean id="placeholderConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  7.         <property name="order" value="1"/>
  8.         <property name="ignoreUnresolvablePlaceholders" value="true"/>
  9.         <property name="locations">
  10.             <list>
  11.                 <value>classpath:redis-cluster.properties</value>
  12.             </list>
  13.         </property>
  14.     </bean>
  16.     <!--配置 jedis pool-->
  17.     <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
  18.         <!-- 最大连接数 -->
  19.         <property name="maxTotal" value="${redis.pool.maxTotal}"/>
  20.         <!-- 最大空闲时间 -->
  21.         <property name="maxIdle" value="${redis.pool.maxIdle}"/>
  22.         <!-- 每次最大连接数 -->
  23.         <property name="numTestsPerEvictionRun" value="${redis.pool.numTestsPerEvictionRun}"/>
  24.         <!-- 释放扫描的扫描间隔 -->
  25.         <property name="timeBetweenEvictionRunsMillis" value="${redis.pool.timeBetweenEvictionRunsMillis}"/>
  26.         <!-- 连接的最小空闲时间 -->
  27.         <property name="minEvictableIdleTimeMillis" value="${redis.pool.minEvictableIdleTimeMillis}"/>
  28.         <!-- 连接控歘按时间多久后释放，当空闲时间>该值且空闲连接>最大空闲连接数时直接释放 -->
  29.         <property name="softMinEvictableIdleTimeMillis" value="${redis.pool.softMinEvictableIdleTimeMillis}"/>
  30.         <!-- 获得链接时的最大等待毫秒数，小于0：阻塞不确定时间，默认-1 -->
  31.         <property name="maxWaitMillis" value="${redis.pool.maxWaitMillis}"/>
  32.         <!-- 在获得链接的时候检查有效性，默认false -->
  33.         <property name="testOnBorrow" value="${redis.pool.testOnBorrow}"/>
  34.         <!-- 在空闲时检查有效性，默认false -->
  35.         <property name="testWhileIdle" value="${redis.pool.testWhileIdle}"/>
  36.         <!-- 连接耗尽时是否阻塞，false报异常，true阻塞超时 默认：true-->
  37.         <property name="blockWhenExhausted" value="${redis.pool.blockWhenExhausted}"/>
  38.     </bean>
  41.     <!--配置RedisClusterConfiguration-->
  42.     <bean id="redisClusterConfiguration" class="org.springframework.data.redis.connection.RedisClusterConfiguration">
  43.         <property name="maxRedirects" value="${redis.maxRedirects}"></property>
  44.         <property name="clusterNodes">
  45.             <set>
  46.                 <bean class="org.springframework.data.redis.connection.RedisNode">
  47.                     <constructor-arg name="host" value="${redis.host1}"/>
  48.                     <constructor-arg name="port" value="${redis.port1}"/>
  49.                 </bean>
  50.                 <bean class="org.springframework.data.redis.connection.RedisNode">
  51.                     <constructor-arg name="host" value="${redis.host2}"/>
  52.                     <constructor-arg name="port" value="${redis.port2}"/>
  53.                 </bean>
  54.                 <bean class="org.springframework.data.redis.connection.RedisNode">
  55.                     <constructor-arg name="host" value="${redis.host3}"/>
  56.                     <constructor-arg name="port" value="${redis.port3}"/>
  57.                 </bean>
  58.                 <bean class="org.springframework.data.redis.connection.RedisNode">
  59.                     <constructor-arg name="host" value="${redis.host4}"/>
  60.                     <constructor-arg name="port" value="${redis.port4}"/>
  61.                 </bean>
  62.                 <bean class="org.springframework.data.redis.connection.RedisNode">
  63.                     <constructor-arg name="host" value="${redis.host5}"/>
  64.                     <constructor-arg name="port" value="${redis.port5}"/>
  65.                 </bean>
  66.                 <bean class="org.springframework.data.redis.connection.RedisNode">
  67.                     <constructor-arg name="host" value="${redis.host6}"/>
  68.                     <constructor-arg name="port" value="${redis.port6}"/>
  69.                 </bean>
  70.             </set>
  71.         </property>
  72.     </bean>
  74.     <!--配置JedisConnectionFactory-->
  75.     <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
  76.         <constructor-arg name="poolConfig" ref="jedisPoolConfig"/>
  77.         <constructor-arg name="clusterConfig" ref="redisClusterConfiguration"/>
  78.     </bean>
  80.     <!--redisTemplate-->
  81.     <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
  82.         <property name="connectionFactory" ref="jedisConnectionFactory"/>
  83.     </bean>
  85. </beans>
  88.    1
  89.    2
  90.    3
  91.    4
  92.    5
  93.    6
  94.    7
  95.    8
  96.    9
  97.    10
  98.    11
  99.    12
  100.    13
  101.    14
  102.    15
  103.    16
  104.    17
  105.    18
  106.    19
  107.    20
  108.    21
  109.    22
  110.    23
  111.    24
  112.    25
  113.    26
  114.    27
  115.    28
  116.    29
  117.    30
  118.    31
  119.    32
  120.    33
  121.    34
  122.    35
  123.    36
  124.    37
  125.    38
  126.    39
  127.    40
  128.    41
  129.    42
  130.    43
  131.    44
  132.    45
  133.    46
  134.    47
  135.    48
  136.    49
  137.    50
  138.    51
  139.    52
  140.    53
  141.    54
  142.    55
  143.    56
  144.    57
  145.    58
  146.    59
  147.    60
  148.    61
  149.    62
  150.    63
  151.    64
  152.    65
  153.    66
  154.    67
  155.    68
  156.    69
  157.    70
  158.    71
  159.    72
  160.    73
  161.    74
  162.    75
  163.    76
  164.    77
  165.    78
  166.    79
  167.    80
  168.    81
  169.    82
  170.    83
  171.    84
  172.    85
  173.    86
  174.    87

二、RedisTemplate的用法

  1. Operations

    1. opsForXXX和boundXXXOps的区别？
    2. XXX为Value的类型，前者获取一个operator，但是没有指定操作的对象（key），可以在一个连接（事务）内操作多个key以及对应的value；后者获取了一个指定的对象（key）的operator，在一个连接（事务）内只能操作这个对应的key。
    3.     关于计数API（increment）中有个小问题需要注意，通过increment计数后，通过get方式获取计数值的时候可能会抛出EOF异常（和本地的jdk以及redis的编译版本有关），可以考虑使用boundValueOps(key).get(0,-1)获得计数值。
  1.          1
  2.          2
  3.          3
  4.          4

  1. ValueOperations和BoundValueOperations

    1. ValueOperations operations = redisTemplate.opsForValue();
    2.         String key = "XXX";
    3.         BoundValueOperations boundValueOperations = redisTemplate.boundValueOps(key);
  1.          1
  2.          2
  3.          3
  5.     类：ValueOperations可以理解为：Map<Object,Object>
  6.     方法：set(key,value)保存
  7.           get(key)获取
  8.     类：BoundValueOperations可以理解为，预先设置好了Key，可以对此key进行其他操作，如设置value，修改value，获得value等
  12.          1
  13.          2
  14.          3
  15.          4
  16.          5
  18. 简单示例：
  20.     ValueOperations operations = redisTemplate.opsForValue();
  21.     String key = "name";
  22.     //存入key-value
  23.     operations.set("name","zhangsan");
  24.     //根据key取出Value
  25.     Object name = operations.get("name");
  26.     System.out.println("name:"+name);
  27.     //追加
  28.     operations.append("name","is man");
  29.     //获得并修改
  30.     operations.getAndSet("name","zhangsan-1");
  31.     Object name1 = operations.get("name");
  32.     System.out.println("修改后："+name1);
  34.     String key = "name-1";
  35.     BoundValueOperations boundValueOperations = redisTemplate.boundValueOps(key);
  36.     //和ValueOperations类似
  39.          1
  40.          2
  41.          3
  42.          4
  43.          5
  44.          6
  45.          7
  46.          8
  47.          9
  48.          10
  49.          11
  50.          12
  51.          13
  52.          14
  53.          15
  54.          16
  55.          17

  1. ListOperations 和 BoundListOperations

    1. ListOperations listOperations = redisTemplate.opsForList();
    2.     String key = "springData";
    3.     BoundListOperations boundListOperations = redisTemplate.boundListOps(key);
  1.          1
  2.          2
  3.          3
  5.     类：ListOperations可以理解为：List<Object>
  6.     BoundListOperations可以理解为，预先设置好了Key，可以对此key进行其他操作，如设置value，修改value，获得value等
  10.          1
  11.          2
  12.          3
  14. 简单示例：
  16.     ListOperations listOperations = redisTemplate.opsForList();
  18.     //push键值对
  19.     listOperations.leftPush(key,"aaa");
  20.     listOperations.leftPush(key,"bbb");
  22.     listOperations.index(1,1000);
  24.     //pop值
  25.     Object leftPop = listOperations.leftPop(key);
  26.     System.out.println(leftPop);
  27.     listOperations.set(key,100,"测试数据");
  29.     //ListOperations可以设置泛型
  30.     ListOperations<String,Integer> listOperations1 = redisTemplate.opsForList();
  32.     String key = "springData";
  33.     BoundListOperations boundListOperations = redisTemplate.boundListOps(key);
  34.     //和ListOperations类似
  37.          1
  38.          2
  39.          3
  40.          4
  41.          5
  42.          6
  43.          7
  44.          8
  45.          9
  46.          10
  47.          11
  48.          12
  49.          13
  50.          14
  51.          15
  52.          16
  53.          17
  54.          18
  55.          19

  1. SetOperations 和 BoundSetOperations

    1. SetOperations setOperations = redisTemplate.opsForSet();
    2.     String key = "springData";
    3.     BoundSetOperations boundSetOperations = redisTemplate.boundSetOps(key);
  1.          1
  2.          2
  3.          3
  5.     类：SetOperations可以理解为：Set<Object>
  6.     BoundSetOperations可以理解为，预先设置好了Key，可以对此key进行其他操作，如设置value，修改value，获得value等
  10.          1
  11.          2
  12.          3
  14. 简单示例和解释：
  16.     /** * Set集合,类似于 * * Map<Object, Set<Object>> map = new HashMap<Object, Set<Object>>(); * Set<Object> set = new HashSet<Object>(); */
  17.     @Test
  18.     public void test04(){
  19.         SetOperations setOperations = redisTemplate.opsForSet();
  21.         /** * 添加，类似于 * * Map<Object, Set<Object>> map = new HashMap<Object, Set<Object>>(); * Set<Object> set = new HashSet<Object>(); * map.put(key,set); * Set<Object> set = map.get(key); * set.add(value); */
  22.         setOperations.add("springData","redis");
  23.         //获取
  24.         Set springData = setOperations.members("springData");
  26.         //获取两个key的value(Set)交集
  27.         setOperations.intersect("springData","SpringData1");
  29.         //获取两个key的value(Set)补集
  30.         setOperations.difference("springData","SpringData1");
  32.         //获取两个key的value(Set)并集
  33.         setOperations.union("springData","SpringData1");
  35.         String key = "springData";
  36.         BoundSetOperations boundSetOperations = redisTemplate.boundSetOps(key);
  37.         //和SetOperations操作类似
  38.     }
  41.          1
  42.          2
  43.          3
  44.          4
  45.          5
  46.          6
  47.          7
  48.          8
  49.          9
  50.          10
  51.          11
  52.          12
  53.          13
  54.          14
  55.          15
  56.          16
  57.          17
  58.          18
  59.          19
  60.          20
  61.          21
  62.          22
  63.          23
  64.          24
  65.          25
  66.          26
  67.          27
  68.          28
  69.          29
  70.          30
  71.          31
  72.          32
  73.          33
  74.          34
  75.          35
  76.          36

  1. ZSetOperations 和 BoundZSetOperations

    1. ZSetOperations zSetOperations = redisTemplate.opsForZSet();
    2.     String key = "springData";
    3.     BoundZSetOperations boundZSetOperations = redisTemplate.boundZSetOps(key);
  1.          1
  2.          2
  3.          3
  5.     类：SetOperations可以理解为：Set<Object>
  6.             BoundSetOperations可以理解为，预先设置好了Key，可以对此key进行其他操作，如设置value，修改value，获得value等
  10.          1
  11.          2
  12.          3

  1. HashOperations 和 BoundHashOperations

    1. HashOperations hashOperations = redisTemplate.opsForHash();
    2.     String key = "springData";
    3.     BoundHashOperations boundHashOperations = redisTemplate.boundHashOps(key);
  1.          1
  2.          2
  3.          3
  5. 说明：APi中的方法很多，大家可以自行测试。源码下载 【[源码下载连接][Link 1]】

发表评论

表情：
评论列表 （有 0 条评论，398人围观）

还没有评论，来说两句吧...

相关阅读