NoSQL之Redis（五）--- Redis测试以及其与spring的集成

2021-12-19 00:20:26

概述


        本文是紧接着上文安装好单机版的redis和rediscluster的之后需要去验证是否安装成功，以及如何和Spring集成到一起。

 

        Jedis


        Jedis是是Redis官方推荐的Java客户端开发包，用于处理redis服务上的缓存数据。笔者用的是Jedis-2.7.2.jar

 

        Redis安装测试


        接着这上文，我们先简单的写一个测试类，测试一下单机版的redis是否已经可用

[java] view plain copy  print?NoSQL之Redis（五）--- Redis测试以及其与spring的集成NoSQL之Redis（五）--- Redis测试以及其与spring的集成
  1. @Test  
  2.     public void testJedisSingle() {  
  3.         // 创建一个jedis的对象。  
  4.         Jedisjedis= newJedis("192.168.21.225", 6379);  
  5.         // 调用jedis对象的方法，方法名称和redis的命令一致。  
  6.         jedis.set("key1", "jedis test");  
  7.         Stringstring= jedis.get("key1");  
  8.         System.out.println(string);  
  9.         // 关闭jedis。每次用完之后都应该关闭jedis  
  10.         jedis.close();  
  11.     }  


        测试结果入下：

NoSQL之Redis（五）--- Redis测试以及其与spring的集成

        在实际的运用过程中，我们基本上不会这样每连接一次redis就去创建一个Jedis对象，而是会在程序加载的时候直接创建一个连接池。测试方法如下

  

[java] view plain copy  print?NoSQL之Redis（五）--- Redis测试以及其与spring的集成NoSQL之Redis（五）--- Redis测试以及其与spring的集成
  1. /** 
  2.    * 使用连接池 
  3.    */  
  4.   @Test  
  5.   public void testJedisPool() {  
  6.       // 创建jedis连接池  
  7.       JedisPoolpool= newJedisPool("192.168.21.225", 6379);  
  8.       // 从连接池中获得Jedis对象  
  9.       Jedisjedis= pool.getResource();  
  10.       Stringstring= jedis.get("key1");  
  11.       System.out.println(string);  
  12.       // 关闭jedis对象  
  13.       jedis.close();  
  14.       pool.close();  
  15.   }  

        运行结果入下：

NoSQL之Redis（五）--- Redis测试以及其与spring的集成

        测试完单机版之后，我们接下来看看如何使用Jedis操作redis集群（本文使用的是伪集群）

[java] view plain copy  print?NoSQL之Redis（五）--- Redis测试以及其与spring的集成NoSQL之Redis（五）--- Redis测试以及其与spring的集成
  1. @Test  
  2.     public void testJedisCluster() {  
  3.         HashSet<HostAndPort>nodes= newHashSet<>();  
  4.         nodes.add(new HostAndPort("192.168.21.225",7001));  
  5.         nodes.add(new HostAndPort("192.168.21.225",7002));  
  6.         nodes.add(new HostAndPort("192.168.21.225",7003));  
  7.         nodes.add(new HostAndPort("192.168.21.225",7004));  
  8.         nodes.add(new HostAndPort("192.168.21.225",7005));  
  9.         nodes.add(new HostAndPort("192.168.21.225",7006));  
  10.    
  11.         JedisClustercluster= newJedisCluster(nodes);  
  12.    
  13.         cluster.set("key1", "1000");  
  14.         Stringstring= cluster.get("key1");  
  15.         System.out.println(string);  
  16.    
  17.         cluster.close();  
  18.     }  


        测试结果入下：

NoSQL之Redis（五）--- Redis测试以及其与spring的集成

        通过上面的测试一方面我们知道了如何简单的去操作redis，另一方面也验证在之前介绍的redis的按照是没有问题的。

 

        与Spring的集成

        下面我们看看在spring的配置文件中如何配置redis的参数和Jedis相关的东西。


        连接池配置


        首先我们看看redis连接池的配置

[html] view plain copy  print?NoSQL之Redis（五）--- Redis测试以及其与spring的集成NoSQL之Redis（五）--- Redis测试以及其与spring的集成
  1. <!-- 连接池配置 -->  
  2.     <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">  
  3.         <!-- 最大连接数 -->  
  4.         <property name="maxTotal" value="30" />  
  5.         <!-- 最大空闲连接数 -->  
  6.         <property name="maxIdle" value="10" />  
  7.         <!-- 每次释放连接的最大数目 -->  
  8.         <property name="numTestsPerEvictionRun" value="1024" />  
  9.         <!-- 释放连接的扫描间隔（毫秒） -->  
  10.         <property name="timeBetweenEvictionRunsMillis" value="30000" />  
  11.         <!-- 连接最小空闲时间 -->  
  12.         <property name="minEvictableIdleTimeMillis" value="1800000" />  
  13.         <!-- 连接空闲多久后释放, 当空闲时间>该值 且 空闲连接>最大空闲连接数 时直接释放 -->  
  14.         <property name="softMinEvictableIdleTimeMillis" value="10000" />  
  15.         <!-- 获取连接时的最大等待毫秒数,小于零:阻塞不确定的时间,默认-1 -->  
  16.         <property name="maxWaitMillis" value="1500" />  
  17.         <!-- 在获取连接的时候检查有效性, 默认false -->  
  18.         <property name="testOnBorrow" value="true" />  
  19.         <!-- 在空闲时检查有效性, 默认false -->  
  20.         <property name="testWhileIdle" value="true" />  
  21.         <!-- 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true -->  
  22.         <property name="blockWhenExhausted" value="false" />  
  23.     </bean>  

        单机配置

[html] view plain copy  print?NoSQL之Redis（五）--- Redis测试以及其与spring的集成NoSQL之Redis（五）--- Redis测试以及其与spring的集成
  1. <bean id="redisClient" class="redis.clients.jedis.JedisPool">  
  2.         <constructor-arg name="host" value="192.168.21.225"></constructor-arg>  
  3.         <constructor-arg name="port" value="6379"></constructor-arg>  
  4.         <constructor-arg name="poolConfig" ref="jedisPoolConfig"></constructor-arg>  
  5.         <bean id="jedisClient" class="com.taotao.rest.dao.impl.JedisClientSingle" />  
  6.     </bean>  


        集群配置

[html] view plain copy  print?NoSQL之Redis（五）--- Redis测试以及其与spring的集成NoSQL之Redis（五）--- Redis测试以及其与spring的集成
  1. <bean id="redisClient" class="redis.clients.jedis.JedisCluster">  
  2.         <constructor-arg name="nodes">  
  3.             <set>  
  4.                 <bean class="redis.clients.jedis.HostAndPort">  
  5.                     <constructor-arg name="host" value="192.168.21.225"></constructor-arg>  
  6.                     <constructor-arg name="port" value="7001"></constructor-arg>  
  7.                 </bean>  
  8.                 <bean class="redis.clients.jedis.HostAndPort">  
  9.                     <constructor-arg name="host" value="192.168.21.225"></constructor-arg>  
  10.                     <constructor-arg name="port" value="7002"></constructor-arg>  
  11.                 </bean>  
  12.                 <bean class="redis.clients.jedis.HostAndPort">  
  13.                     <constructor-arg name="host" value="192.168.21.225"></constructor-arg>  
  14.                     <constructor-arg name="port" value="7003"></constructor-arg>  
  15.                 </bean>  
  16.                 <bean class="redis.clients.jedis.HostAndPort">  
  17.                     <constructor-arg name="host" value="192.168.21.225"></constructor-arg>  
  18.                     <constructor-arg name="port" value="7004"></constructor-arg>  
  19.                 </bean>  
  20.                 <bean class="redis.clients.jedis.HostAndPort">  
  21.                     <constructor-arg name="host" value="192.168.21.225"></constructor-arg>  
  22.                     <constructor-arg name="port" value="7005"></constructor-arg>  
  23.                 </bean>  
  24.                 <bean class="redis.clients.jedis.HostAndPort">  
  25.                     <constructor-arg name="host" value="192.168.21.225"></constructor-arg>  
  26.                     <constructor-arg name="port" value="7006"></constructor-arg>  
  27.                 </bean>  
  28.             </set>  
  29.         </constructor-arg>  
  30.         <constructor-arg name="poolConfig" ref="jedisPoolConfig"></constructor-arg>  
  31.     </bean>  
  32.     <bean id="jedisClientCluster"class="com.taotao.rest.dao.impl.JedisClientCluster"></bean>  

        工具类


        为了方便笔者直接调用Jedis去操作redis，所以笔者写了一个JedisClient工具类，如下

[java] view plain copy  print?NoSQL之Redis（五）--- Redis测试以及其与spring的集成NoSQL之Redis（五）--- Redis测试以及其与spring的集成
  1. public interfaceJedisClient {  
  2.    
  3.     Stringget(String key);  
  4.    
  5.     Stringset(String key,String value);  
  6.    
  7.     Stringhget(String hkey,String key);  
  8.    
  9.     long hset(String hkey, String key, String value);  
  10.    
  11.     long incr(String key);  
  12.    
  13.     long expire(String key, int second);  
  14.    
  15.     long ttl(String key);  
  16.    
  17.     long del(String key);  
  18.    
  19.     long hdel(String hkey, String key);  
  20. }  

 

        由于对单机和集群的redis操作时不一样的，所以实现工具类的时候单机和集群的实现方式是不一样的。


        单机实现

[java] view plain copy  print?NoSQL之Redis（五）--- Redis测试以及其与spring的集成NoSQL之Redis（五）--- Redis测试以及其与spring的集成
  1. public classJedisClientSingle implements JedisClient{  
  2.      
  3.     @Autowired  
  4.     private JedisPool jedisPool;  
  5.      
  6.     @Override  
  7.     public String get(String key) {  
  8.         Jedisjedis= jedisPool.getResource();  
  9.         Stringstring= jedis.get(key);  
  10.         jedis.close();  
  11.         return string;  
  12.     }  
  13.    
  14.     @Override  
  15.     public String set(String key, String value) {  
  16.         Jedisjedis= jedisPool.getResource();  
  17.         Stringstring= jedis.set(key, value);  
  18.         jedis.close();  
  19.         return string;  
  20.     }  
  21.    
  22.     @Override  
  23.     public String hget(String hkey, String key) {  
  24.         Jedisjedis= jedisPool.getResource();  
  25.         Stringstring= jedis.hget(hkey, key);  
  26.         jedis.close();  
  27.         return string;  
  28.     }  
  29.    
  30.     @Override  
  31.     public long hset(String hkey, String key, String value) {  
  32.         Jedisjedis= jedisPool.getResource();  
  33.         Longresult= jedis.hset(hkey, key, value);  
  34.         jedis.close();  
  35.         return result;  
  36.     }  
  37.    
  38.     @Override  
  39.     public long incr(String key) {  
  40.         Jedisjedis= jedisPool.getResource();  
  41.         Longresult= jedis.incr(key);  
  42.         jedis.close();  
  43.         return result;  
  44.     }  
  45.    
  46.     @Override  
  47.     public long expire(String key, int second) {  
  48.         Jedisjedis= jedisPool.getResource();  
  49.         Longresult= jedis.expire(key, second);  
  50.         jedis.close();  
  51.         return result;  
  52.     }  
  53.    
  54.     @Override  
  55.     public long ttl(String key) {  
  56.         Jedisjedis= jedisPool.getResource();  
  57.         Longresult= jedis.ttl(key);  
  58.         jedis.close();  
  59.         return result;  
  60.     }  
  61.    
  62.     @Override  
  63.     public long del(String key) {  
  64.         Jedis jedis = jedisPool.getResource();  
  65.         Longresult= jedis.del(key);  
  66.         jedis.close();  
  67.         return result;  
  68.     }  
  69.    
  70.     @Override  
  71.     public long hdel(String hkey, String key) {  
  72.         Jedisjedis= jedisPool.getResource();  
  73.         Longresult= jedis.hdel(hkey, key);  
  74.         jedis.close();  
  75.         return result;  
  76.     }  
  77. }  


        集群实现

[java] view plain copy  print?NoSQL之Redis（五）--- Redis测试以及其与spring的集成NoSQL之Redis（五）--- Redis测试以及其与spring的集成
  1. public classJedisClientCluster implements JedisClient {  
  2.    
  3.     @Autowired  
  4.     private JedisCluster jedisCluster;  
  5.      
  6.     @Override  
  7.     public String get(String key) {  
  8.         return jedisCluster.get(key);  
  9.     }  
  10.    
  11.     @Override  
  12.     public String set(String key, String value) {  
  13.         return jedisCluster.set(key, value);  
  14.     }  
  15.    
  16.     @Override  
  17.     public String hget(String hkey, String key) {  
  18.         return jedisCluster.hget(hkey, key);  
  19.     }  
  20.    
  21.     @Override  
  22.     public long hset(String hkey, String key, String value) {  
  23.         return jedisCluster.hset(hkey, key, value);  
  24.     }  
  25.    
  26.     @Override  
  27.     public long incr(String key) {  
  28.         return jedisCluster.incr(key);  
  29.     }  
  30.    
  31.     @Override  
  32.     public long expire(String key, int second) {  
  33.         return jedisCluster.expire(key, second);  
  34.     }  
  35.    
  36.     @Override  
  37.     public long ttl(String key) {  
  38.         return jedisCluster.ttl(key);  
  39.     }  
  40.    
  41.     @Override  
  42.     public long del(String key) {  
  43.         return jedisCluster.del(key);  
  44.     }  
  45.    
  46.     @Override  
  47.     public long hdel(String hkey, String key) {  
  48.         return jedisCluster.hdel(hkey, key);  
  49.     }  
  50. }  

        测试

        下面是测试配置以及工具类的方法


        单机测试

[java] view plain copy  print?NoSQL之Redis（五）--- Redis测试以及其与spring的集成NoSQL之Redis（五）--- Redis测试以及其与spring的集成
  1. @Test  
  2.     public void testSpringJedisSingle(){  
  3.         ApplicationContextapplicationContext = newClassPathXmlApplicationContext(  
  4.                 "classpath:spring/applicationContext-*.xml");  
  5.         JedisPoolpool= (JedisPool) applicationContext.getBean("redisClient");  
  6.         Jedisjedis= pool.getResource();  
  7.         Stringstring= jedis.get("key1");  
  8.         System.out.println(string);  
  9.         jedis.close();  
  10.         pool.close();  
  11.     }  


        集群测试

[html] view plain copy  print?NoSQL之Redis（五）--- Redis测试以及其与spring的集成NoSQL之Redis（五）--- Redis测试以及其与spring的集成
  1. @Test  
  2.     public voidtestSpringJedisCluster() {  
  3.         ApplicationContextapplicationContext = newClassPathXmlApplicationContext(  
  4.                 "classpath:spring/applicationContext-*.xml");  
  5.         JedisClusterjedisCluster= (JedisCluster) applicationContext  
  6.                 .getBean("redisClient");  
  7.         Stringstring= jedisCluster.get("key1");  
  8.         System.out.println(string);  
  9.         jedisCluster.close();  
  10.     }  

        总结


        至此，本文的的写作目的——测试集群，以及redis配置与Spring集成就达到了。其实在笔者在写本文的时候，一方面是对之前项目中redis运用的优化，另一方面在实际的其实本文在实现JedisClient的时候，所有的方法中在笔者的项目中是添加有日志的。至于为什么添加日志本文就不介绍了。

上一篇：C# WINFORM通过委托和事件窗体间（跨窗体）传值(自定义事件参数)--实例详解


下一篇：网站域名建站历史用什么查询工具？