IDEA连接Redis

1、创建一个Maven项目

2、在src下的pom.xml文件里，添加相关包引用

 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>

     <groupId>com.otwb</groupId>
     <artifactId>redisLink</artifactId>
     <version>1.0-SNAPSHOT</version>

     <dependencies>
         <!--用于单元测试的包-->
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <version>4.12</version>
         </dependency>
         <!--mysql数据库的jdbc驱动包：用于连接mysql数据库-->
         <dependency>
             <groupId>mysql</groupId>
             <artifactId>mysql-connector-java</artifactId>
             <version>8.0.18</version>
         </dependency>
         <!--redis数据库的连接驱动包-->
         <dependency>
             <groupId>redis.clients</groupId>
             <artifactId>jedis</artifactId>
             <version>2.9.0</version>
         </dependency>
         <!--数据库工具包：用于操作数据库-->
         <dependency>
             <groupId>commons-dbutils</groupId>
             <artifactId>commons-dbutils</artifactId>
             <version>1.5</version>
         </dependency>
         <!--对象池驱动包：用于存放我们需要池化的对象，如创建redis数据库连接池-->
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-pool2</artifactId>
             <version>2.5.0</version>
         </dependency>
         <!--c3p0数据库连接池包-->
         <dependency>
             <groupId>c3p0</groupId>
             <artifactId>c3p0</artifactId>
             <version>0.9.1.2</version>
         </dependency>
     </dependencies>

 </project>

3、创建redis连接池工具包

 package utils;

 import redis.clients.jedis.Jedis;
 import redis.clients.jedis.JedisPool;
 import redis.clients.jedis.JedisPoolConfig;

 public class RedisUtils {
     //服务器IP地址
     private static String ADDR = "43.109.234.69";
     //端口
     private static int PORT = 6379;
     //连接超时的时间　　
     private static int TIMEOUT = 10000;
     //密码
     private static String AUTH = "123";
     //数据库模式是16个数据库（0~15），这里设置第一个为默认数据库
     public static final int DEFAULT_DATABASE = 0;
     //连接实例的最大连接数
     private static int MAX_ACTIVE = 1024;
     //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
     private static int MAX_IDLE = 200;
     //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException
     private static int MAX_WAIT = 10000;
     //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
     private static boolean TEST_ON_BORROW = true;
     //创建一个redis数据库连接池
     private static JedisPool jedisPool = null;

     //初始化Redis连接池（静态代码块）
     static {
         try {
             //新建连接池的配置参数
             JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
             //指定连接实例的最大连接数
             jedisPoolConfig.setMaxTotal(MAX_ACTIVE);
             //指定一个pool最多有多少个状态为idle(空闲的)的jedis实例
             jedisPoolConfig.setMaxIdle(MAX_IDLE);
             //指定等待可用连接的最大时间，单位毫秒
             jedisPoolConfig.setMaxWaitMillis(MAX_WAIT);
             //在borrow一个jedis实例时，是否提前进行validate操作
             jedisPoolConfig.setTestOnBorrow(TEST_ON_BORROW);
             //初始化Redis连接池
             jedisPool = new JedisPool(jedisPoolConfig, ADDR, PORT, TIMEOUT,AUTH,DEFAULT_DATABASE);
             //jedisPool = new JedisPool(jedisPoolConfig, ADDR, PORT);
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

     //获取Jedis实例
     public synchronized static Jedis getJedis() {
         try {
             if (jedisPool != null) {
                 Jedis jedis = jedisPool.getResource();
                 System.out.println("redis--服务正在运行: "+jedis.ping());
                 return jedis;
             } else {
                 return null;
             }
         } catch (Exception e) {
             e.printStackTrace();
             return null;
         }
     }

     //释放资源
     public static void returnResource(final Jedis jedis) {
         if(jedis != null) {
             jedisPool.returnResource(jedis);
         }
     }
 }

4、在src——main——java下添加RedisLinkTest类，测试连接操作Redis数据库

 import org.junit.Test;
 import redis.clients.jedis.Jedis;
 import utils.RedisUtils;

 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;

 public class RedisLinkTest {
     //@Test表示这个方法是单元测试的方法
     //连接并添加String类型数据
     @Test
     public void fun1() {
         //直接连接redis数据库
         Jedis jedis = new Jedis("43.109.234.69",6379);
         //设置连接密码
         jedis.auth("123");
         //添加String类型数据
         jedis.set("field1","i am field1");
         //输出添加的数据（根据键，输出对应的值）
         System.out.println(jedis.get("field1"));
         //删除String类型数据（根据键删除）
         jedis.del("field1");
         //输出数据，查看是否删除成功
         System.out.println(jedis.get("field1"));
     }

     //连接并添加hash类型数据（我理解为给String类型的数据进行了分类，每个hash可以存储2^32-1个键值对）
     @Test
     public void fun2(){
         //通过连接池方式连接redis数据库
         Jedis jedis = RedisUtils.getJedis();
         //添加hash类型数据
         jedis.hset("hset1","name","张三");
         jedis.hset("hset1","age","22");
         jedis.hset("hset1","sex","男");
         //获取数据
         List<String> hmget = jedis.hmget("hset1", "name","age","sex");
         //输出
         System.out.println(hmget);
         //删除
         jedis.hdel("hset1","name","sex");
         //删除后再输出，看看是否删除成功
         System.out.println(jedis.hmget("hset1", "name","age","sex"));
         RedisUtils.returnResource(jedis);
     }

     //连接并添加List类型数据（队列，按照插入顺序排序，可以添加一个元素到列表的头部（左边），或者尾部（右边））
     @Test
     public void fun3() {
         //通过连接池方式连接redis数据库
         Jedis jedis = RedisUtils.getJedis();
         //添加List类型数据，lpush添加到列表头部，即后添加的数据在最前面
         jedis.lpush("field2","aaa");
         jedis.lpush("field2","bbb");
         jedis.lpush("field2","ccc");
         //从索引1的位置获取到索引6位置的值，因为超出了实际索引2，所以后面会继续循环输出
         List<String> field2 = jedis.lrange("field2", 0, 6);
         //输出添加的键值对
         for(String item:field2){
             System.out.println(item);
         }
         RedisUtils.returnResource(jedis);
     }

     //连接并添加Set类型数据（一堆不重复值的组合）
     @Test
     public void fun4(){
         //通过连接池方式连接redis数据库
         Jedis jedis = RedisUtils.getJedis();
         //添加Set类型数据
         jedis.sadd("name","zhangsan");
         jedis.sadd("name","lisi");
         jedis.sadd("name","lisi");  //同一个数据再次添加，会覆盖上一次的
         jedis.sadd("age","16");
         jedis.sadd("sex","nan");
         jedis.sadd("address","china");
         //获取Set类型数据
         Set<String> name = jedis.smembers("name");
         //输出获取到的Set类型数据（输出的顺序是无序的）
         System.out.println(name);
         System.out.println("\n");
         //获取当前redis数据库中，所有key，以Set集合的方式返回数据
         Set<String> set = jedis.keys("*");
         Iterator<String> iterator = set.iterator();
         while(iterator.hasNext()){
             System.out.println(iterator.next());
         }
         RedisUtils.returnResource(jedis);
     }

     //连接并添加ZSet类型数据（zset是set的升级版，它在set的基础上增加了顺序属性score，这一属性在添加修改元素的时候可以指定，每次指定后，zset会自动重新按新的值调整顺序）
     @Test
     public void fun5(){
         //通过连接池方式连接redis数据库
         Jedis jedis = RedisUtils.getJedis();
         //添加zset型数据
         jedis.zadd("field3",1,"hhh");
         jedis.zadd("field3",0,"jjj");
         jedis.zadd("field3",3,"bbb");
         //获取set型数据
         Set<String> field3 = jedis.zrangeByScore("field3", 0, 5);
         //用迭代器循环输出
         Iterator<String> iterator = field3.iterator();
         while(iterator.hasNext()){
             System.out.println(iterator.next());
         }
         RedisUtils.returnResource(jedis);
     }
 }

。