Jedis
 
前言
什么是Jedis
为什么要使用Jedis
1、导入对应的依赖
2、编码测试
3、常用的API
3.1 String
3.2 List
3.3 Set
3.4 Hash
3.5 Key
3.6 Password
  
4、通过Jedis再次理解 事务

 
前言
 
提示：本文章是日常学习内容的总结，并非全部原创；仅供大家参考借鉴，并无其他商业用途。Bilibili搜索关注：狂神说
 真正在公司中的实践：NoSQL + RDBMS 一起使用才是最强的，阿里巴巴的架构演进！
 技术没有高低之分，就看你如何去使用！（提升内功，思维的提高！）
 云计算的长征之路：阿里云的这群疯子
 
什么是Jedis
 
 
 
是Jedis 是 Redis 官方推荐的 java连接开发工具！
 是使用Java 操作Redis 中间件！
 如果你要使用java去操作redis
 那么一定要对Jedis 十分的熟悉！
 
 
为什么要使用Jedis
 
 
 
知其然并知其所以然，授人以渔！ 学习不能急躁，慢慢来会很快！
 先了解Jedis，再用spring-data-redis去整合
 所以我们要先使用 Java 来操作 Redis，
 
 
1、导入对应的依赖
 
<!--导入jedis的包-->
<dependencies>
    <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.2.0</version>
    </dependency>
    <!--fastjson-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.62</version>
    </dependency>
</dependencies>
 
2、编码测试
 
1. 连接数据库
 2. 操作命令
 3. 断开连接！
 
package com.kuang;

import redis.clients.jedis.Jedis;

public class TestPing {
    public static void main(String[] args) {
    // new Jedis 对象即可
    Jedis jedis = new Jedis("127.0.0.1",6379);
    // jedis 所有的命令就是redis-cli客户端的所有指令！

    System.out.println(jedis.ping());
    }
}
 
4. 输出
 
 
3、常用的API
 
所有的api命令，都对应前面文章的五大数据类型的指令，一个都没有变化！
 
3.1 String
 
 public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        jedis.flushDB();
        System.out.println("===========增加数据===========");
        System.out.println(jedis.set("key1","value1"));
        System.out.println(jedis.set("key2","value2"));
        System.out.println(jedis.set("key3", "value3"));
        System.out.println("删除键key2:"+jedis.del("key2"));
        System.out.println("获取键key2:"+jedis.get("key2"));
        System.out.println("修改key1:"+jedis.set("key1", "value1Changed"));
        System.out.println("获取key1的值："+jedis.get("key1"));
        System.out.println("在key3后面加入值："+jedis.append("key3", "End"));
        System.out.println("key3的值："+jedis.get("key3"));
        System.out.println("增加多个键值对："+jedis.mset("key01","value01","key02","value02","key03","value03"));
        System.out.println("获取多个键值对："+jedis.mget("key01","key02","key03"));
        System.out.println("获取多个键值对："+jedis.mget("key01","key02","key03","key04"));
        System.out.println("删除多个键值对："+jedis.del("key01","key02"));
        System.out.println("获取多个键值对："+jedis.mget("key01","key02","key03"));

        jedis.flushDB();
        System.out.println("===========新增键值对防止覆盖原先值==============");
        System.out.println(jedis.setnx("key1", "value1"));
        System.out.println(jedis.setnx("key2", "value2"));
        System.out.println(jedis.setnx("key2", "value2-new"));
        System.out.println(jedis.get("key1"));
        System.out.println(jedis.get("key2"));

        System.out.println("===========新增键值对并设置有效时间=============");
        System.out.println(jedis.setex("key3", 2, "value3"));
        System.out.println(jedis.get("key3"));
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(jedis.get("key3"));

        System.out.println("===========获取原值，更新为新值==========");
        System.out.println(jedis.getSet("key2", "key2GetSet"));
        System.out.println(jedis.get("key2"));

        System.out.println("获得key2的值的字串："+jedis.getrange("key2", 2, 4));
    }
 
3.2 List
 
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        jedis.flushDB();
        System.out.println("===========添加一个list===========");
        jedis.lpush("collections", "ArrayList", "Vector", "Stack", "HashMap", "WeakHashMap", "LinkedHashMap");
        jedis.lpush("collections", "HashSet");
        jedis.lpush("collections", "TreeSet");
        jedis.lpush("collections", "TreeMap");
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));//-1代表倒数第一个元素，-2代表倒数第二个元素,end为-1表示查询全部
        System.out.println("collections区间0-3的元素："+jedis.lrange("collections",0,3));
        System.out.println("===============================");
        // 删除列表指定的值 ，第二个参数为删除的个数（有重复时），后add进去的值先被删，类似于出栈
        System.out.println("删除指定元素个数："+jedis.lrem("collections", 2, "HashMap"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("删除下表0-3区间之外的元素："+jedis.ltrim("collections", 0, 3));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("collections列表出栈（左端）："+jedis.lpop("collections"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("collections添加元素，从列表右端，与lpush相对应："+jedis.rpush("collections", "EnumMap"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("collections列表出栈（右端）："+jedis.rpop("collections"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("修改collections指定下标1的内容："+jedis.lset("collections", 1, "LinkedArrayList"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("===============================");
        System.out.println("collections的长度："+jedis.llen("collections"));
        System.out.println("获取collections下标为2的元素："+jedis.lindex("collections", 2));
        System.out.println("===============================");
        jedis.lpush("sortedList", "3","6","2","0","7","4");
        System.out.println("sortedList排序前："+jedis.lrange("sortedList", 0, -1));
        System.out.println(jedis.sort("sortedList"));
        System.out.println("sortedList排序后："+jedis.lrange("sortedList", 0, -1));
    }
 
3.3 Set
 
 public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        jedis.flushDB();
        System.out.println("============向集合中添加元素（不重复）============");
        System.out.println(jedis.sadd("eleSet", "e1","e2","e4","e3","e0","e8","e7","e5"));
        System.out.println(jedis.sadd("eleSet", "e6"));
        System.out.println(jedis.sadd("eleSet", "e6"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("eleSet"));
        System.out.println("删除一个元素e0："+jedis.srem("eleSet", "e0"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("eleSet"));
        System.out.println("删除两个元素e7和e6："+jedis.srem("eleSet", "e7","e6"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("eleSet"));
        System.out.println("随机的移除集合中的一个元素："+jedis.spop("eleSet"));
        System.out.println("随机的移除集合中的一个元素："+jedis.spop("eleSet"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("eleSet"));
        System.out.println("eleSet中包含元素的个数："+jedis.scard("eleSet"));
        System.out.println("e3是否在eleSet中："+jedis.sismember("eleSet", "e3"));
        System.out.println("e1是否在eleSet中："+jedis.sismember("eleSet", "e1"));
        System.out.println("e1是否在eleSet中："+jedis.sismember("eleSet", "e5"));
        System.out.println("=================================");
        System.out.println(jedis.sadd("eleSet1", "e1","e2","e4","e3","e0","e8","e7","e5"));
        System.out.println(jedis.sadd("eleSet2", "e1","e2","e4","e3","e0","e8"));
        //移到集合元素
        System.out.println("将eleSet1中删除e1并存入eleSet3中："+jedis.smove("eleSet1", "eleSet3", "e1"));
        System.out.println("将eleSet1中删除e2并存入eleSet3中："+jedis.smove("eleSet1", "eleSet3", "e2"));
        System.out.println("eleSet1中的元素："+jedis.smembers("eleSet1"));
        System.out.println("eleSet3中的元素："+jedis.smembers("eleSet3"));
        System.out.println("============集合运算=================");
        System.out.println("eleSet1中的元素："+jedis.smembers("eleSet1"));
        System.out.println("eleSet2中的元素："+jedis.smembers("eleSet2"));
        System.out.println("eleSet1和eleSet2的交集:"+jedis.sinter("eleSet1","eleSet2"));
        System.out.println("eleSet1和eleSet2的并集:"+jedis.sunion("eleSet1","eleSet2"));
        System.out.println("eleSet1和eleSet2的差集:"+jedis.sdiff("eleSet1","eleSet2"));//eleSet1中有，eleSet2中没有
        jedis.sinterstore("eleSet4","eleSet1","eleSet2");//求交集并将交集保存到dstkey的集合
        System.out.println("eleSet4中的元素："+jedis.smembers("eleSet4"));
    }
 
3.4 Hash
 
 public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        jedis.flushDB();
        Map<String,String> map = new HashMap<String,String>();
        map.put("key1","value1");
        map.put("key2","value2");
        map.put("key3","value3");
        map.put("key4","value4");
        //添加名称为hash（key）的hash元素
        jedis.hmset("hash",map);
        //向名称为hash的hash中添加key为key5，value为value5元素
        jedis.hset("hash", "key5", "value5");
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));//return Map<String,String>
        System.out.println("散列hash的所有键为："+jedis.hkeys("hash"));//return Set<String>
        System.out.println("散列hash的所有值为："+jedis.hvals("hash"));//return List<String>
        System.out.println("将key6保存的值加上一个整数，如果key6不存在则添加key6："+jedis.hincrBy("hash", "key6", 6));
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));
        System.out.println("将key6保存的值加上一个整数，如果key6不存在则添加key6："+jedis.hincrBy("hash", "key6", 3));
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));
        System.out.println("删除一个或者多个键值对："+jedis.hdel("hash", "key2"));
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));
        System.out.println("散列hash中键值对的个数："+jedis.hlen("hash"));
        System.out.println("判断hash中是否存在key2："+jedis.hexists("hash","key2"));
        System.out.println("判断hash中是否存在key3："+jedis.hexists("hash","key3"));
        System.out.println("获取hash中的值："+jedis.hmget("hash","key3"));
        System.out.println("获取hash中的值："+jedis.hmget("hash","key3","key4"));
    }
 
3.5 Key
 
public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        System.out.println("清空数据："+jedis.flushDB());
        System.out.println("判断某个键是否存在："+jedis.exists("username"));
        System.out.println("新增<'username','kuangshen'>的键值对："+jedis.set("username", "kuangshen"));
        System.out.println("新增<'password','password'>的键值对："+jedis.set("password", "password"));
        System.out.print("系统中所有的键如下：");
        Set<String> keys = jedis.keys("*");
        System.out.println(keys);
        System.out.println("删除键password:"+jedis.del("password"));
        System.out.println("判断键password是否存在："+jedis.exists("password"));
        System.out.println("查看键username所存储的值的类型："+jedis.type("username"));
        System.out.println("随机返回key空间的一个："+jedis.randomKey());
        System.out.println("重命名key："+jedis.rename("username","name"));
        System.out.println("取出改后的name："+jedis.get("name"));
        System.out.println("按索引查询："+jedis.select(0));
        System.out.println("删除当前选择数据库中的所有key："+jedis.flushDB());
        System.out.println("返回当前数据库中key的数目："+jedis.dbSize());
        System.out.println("删除所有数据库中的所有key："+jedis.flushAll());
    }
 
3.6 Password
 
public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        //验证密码，如果没有设置密码这段代码省略
        //jedis.auth("password");
        jedis.connect(); //连接
        jedis.disconnect(); //断开连接
        jedis.flushAll(); //清空所有的key
    }
 
4、通过Jedis再次理解 事务
 
 public static void main(String[] args) {
        //创建客户端连接服务端，redis服务端需要被开启
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        jedis.flushDB();

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("hello", "world");
        jsonObject.put("name", "java");

        //开启事务
        Transaction multi = jedis.multi();
        String result = jsonObject.toJSONString();
        try{
            //向redis存入一条数据
            multi.set("json", result);
            //再存入一条数据
            multi.set("json2", result);
            //故意引发ArithmeticException: / by zero异常
            int i = 100/0;
            //如果没有引发异常，执行进入队列的命令
            multi.exec();
        }catch(Exception e){
            e.printStackTrace();
            //如果出现异常，回滚
            multi.discard();
        }finally{
            System.out.println(jedis.get("json"));
            System.out.println(jedis.get("json2"));
            //最终关闭客户端
            jedis.close();
        }
    }
 
结果：由于异常，事务回滚。json，json2没有执行成功，返回null。
 
java.lang.ArithmeticException: / by zero
	at com.kuang.multi.TestMulti.main(TestMulti.java:26)
null
null

　　jedis是redis的java版本的客户端实现。下面演示jedis的相关操作： 
 　　 
 　　首先在eclipse新建动态web工程： 
 　　 
 　　 
 　　 
 　　将jedis所需的jar包导入到工程中： 
 　　 
 　　 
 　　 
 　　编写Java代码测试连通性：
 
import redis.clients.jedis.Jedis;

public class TestPing {

    public static void main(String[] args) {
    　　//192.168.202.131是我虚拟机的IP地址，6379是redis服务的端口号，请自行配置
        Jedis jedis = new Jedis("192.168.202.131", 6379);
        System.out.println(jedis.ping());

    }

}
 
　　运行程序，会报错： 
 　　Exception in thread “main” redis.clients.jedis.exceptions.JedisConnectionException: java.net.ConnectException: Connection refused: connect 
 　　 
 　　我们需要更改redis的配置文件，将bind 127.0.0.1注释掉，使任何IP都可以访问redis服务： 
 　　 
 　　 
 　　 
 　　重启redis服务，再运行程序，发现继续报错： 
 　　 
 　　Exception in thread “main” redis.clients.jedis.exceptions.JedisDataException: DENIED Redis is running in protected mode because protected mode is enabled, no bind address was specified, no authentication password is requested to clients. In this mode connections are only accepted from the loopback interface. If you want to connect from external computers to Redis you may adopt one of the following solutions: 1) Just disable protected mode sending the command ‘CONFIG SET protected-mode no’ from the loopback interface by connecting to Redis from the same host the server is running, however MAKE SURE Redis is not publicly accessible from internet if you do so. Use CONFIG REWRITE to make this change permanent. 2) Alternatively you can just disable the protected mode by editing the Redis configuration file, and setting the protected mode option to ‘no’, and then restarting the server. 3) If you started the server manually just for testing, restart it with the ‘–protected-mode no’ option. 4) Setup a bind address or an authentication password. NOTE: You only need to do one of the above things in order for the server to start accepting connections from the outside. 
 　　 
 　　大意是redis在保护模式下，拒绝在没有绑定IP地址或者没有授权密码的情况下进行访问。我们需要继续更改redis配置文件，将protected-mode yes改为protected-mode no： 
 　　 
 　　 
 　　 
 　　重启redis服务，重新运行程序，会输出“PONG”，证明连接成功： 
 　　 
 　　 
 　　 
 　　下面根据数据类型来测试jedis的API：
 
    //String类型
　　@Test
    public void testString() {
        Jedis jedis = new Jedis("192.168.202.131", 6379);

        //清空数据库
        jedis.flushDB();

        String k1 = "k1";
        String v1 = "v1";
        jedis.set("k1", v1);
        System.out.println(jedis.get(k1));

        //是否存在
        System.out.println(jedis.exists(k1));

        //类型
        System.out.println(jedis.type(k1));

        //拼接
        jedis.append(k1, "v1v1v1");
        System.out.println(jedis.get(k1));

        //设置多个数据
        jedis.mset("k2","v2","k3","3");
        System.out.println(jedis.keys("*"));

        //删除
        jedis.del("k2");
        System.out.println(jedis.keys("*"));

        //自增
        jedis.incr("k3");
        System.out.println(jedis.get("k3"));
    }
 
　　输出： 
 　　 
 　　 
 　　
 
    //List类型
    @Test
    public void testList(){
        Jedis jedis = new Jedis("192.168.202.131", 6379);

        //清空数据库
        jedis.flushDB();

        //从列表头部插入
        jedis.lpush("l1", "a","b","c");
        //从列表尾部插入
        jedis.rpush("l1", "d","e");
        //返回列表中所有值
        System.out.println(jedis.lrange("l1", 0, -1));
        //返回列表长度
        System.out.println(jedis.llen("l1"));
        //从列表头部移除一个元素并返回
        System.out.println(jedis.lpop("l1"));
    }
 
　　输出： 
 　　 
 　　 
 　　
 
       //Hash类型
        @Test
        public void testHash(){
            Jedis jedis = new Jedis("192.168.202.131", 6379);

            //清空数据库
            jedis.flushDB();

            Map<String,String> map = new HashMap<>();
            map.put("name", "Alan");
            map.put("age", "22");
            jedis.hmset("user",map);
            jedis.hset("user", "gender", "male");

            //获取单个数据
            System.out.println(jedis.hget("user", "age"));

            //获取多个数据
            System.out.println(jedis.hmget("user", "name","gender"));

            //获取所有数据
            System.out.println(jedis.hgetAll("user"));

            //获取所有的键
            System.out.println(jedis.hkeys("user"));

            //获取所有的值
            System.out.println(jedis.hvals("user"));
        }
 
　　输出： 
 　　 
 　　 
 　　
 
    // Set类型
    @Test
    public void testSet() {
        Jedis jedis = new Jedis("192.168.202.131", 6379);

        // 清空数据库
        jedis.flushDB();

        //添加一个或多个数据
        jedis.sadd("s1", "a","b","c");
        jedis.sadd("s1", "d");

        //返回集合中所有元素
        System.out.println(jedis.smembers("s1"));

        //成员个数
        System.out.println(jedis.scard("s1"));

        //求交集，并集，差集
        jedis.sadd("s2", "c","d","e","f");

        System.out.println(jedis.sinter("s1","s2"));

        System.out.println(jedis.sunion("s1","s2"));

        System.out.println(jedis.sdiff("s1","s2"));

        //判断是否是成员
        System.out.println(jedis.sismember("s1", "c"));

        //移除一个或者多个元素
        jedis.srem("s1", "b","c");
        System.out.println(jedis.smembers("s1"));
    }
 
　　输出：
 
　　 
 　　
 
    // Zset类型
        @Test
        public void testZset() {
            Jedis jedis = new Jedis("192.168.202.131", 6379);

            // 清空数据库
            jedis.flushDB();

            //向有序集合中添加多个成员
            Map<Double,String> map = new HashMap<>();
            map.put(60.0, "Alan");
            map.put(70.0, "Jack");
            map.put(75.0, "Tom");

            jedis.zadd("rank", map);

            //返回所有成员
            System.out.println(jedis.zrange("rank", 0, -1));

            //带有分数地返回所有成员,字符串由ASCII码表示
            System.out.println(jedis.zrangeWithScores("rank", 0, -1));

            //增加成员分数
            jedis.zincrby("rank", 0.5, "Alan");
            System.out.println(jedis.zscore("rank", "Alan"));

            //返回分数在60到70之间的成员
            System.out.println(jedis.zrangeByScore("rank", 60, 70));


        }
 
　　输出： 
 　　 
 　　 
 　　

Jedis客户端使用,如何使用jedis，jedis入门教程
 
Jedis客户端使用
 Jedis是redis的java版本的客户端实现，Jedis提供了完整Redis命令
 
一 基本使用
 
1导入jar文件
 
Maven方式
 
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.8.2</version>
</dependency>
 
2 代码
 

//创建jedis对象
Jedis jedis = new Jedis("127.0.0.1", 6379);
//设置密码
jedis.auth("redis");
//设置key-value数据
jedis.set("name", "zhangsan");
//根据key值获取数据
System.out.println(jedis.get("name"));
jedis.set("age", "12");
//数据自增
jedis.incr("age");

jedis.hset("myhash", "name", "lisi");
Map<String, String> map = new HashMap<>();
map.put("age", "12");
map.put("qq", "1234567");
jedis.hmset("myhash", map);
String hget = jedis.hget("myhash", "name");
Map<String, String> hgetAll = jedis.hgetAll("myhash");
jedis.hdel("myhash", "qq");
jedis.hkeys("myhash");
jedis.hvals("myhash");
 
3 JedisPool
 
Jedis对象并不是线程安全的，在多线程下使用同一个Jedis对象会出现并发问题。为了避免每次使用Jedis对象时都需要重新构建，Jedis提供了JedisPool。JedisPool是基于Commons Pool 2实现的一个线程安全的连接池。如果使用jedis连接池，需要commons-pool2的jar包
 
public class JedisUtil {

   //jedis连接池
   private static JedisPool jedisPool = null;

   static{
      //连接池配置对象
      JedisPoolConfig config = new JedisPoolConfig();
      //最多与多少个jedis对象
      config.setMaxTotal(50);
      //最多有多少空闲的jedis对象
      config.setMaxIdle(20);
      //最大等待时间
      config.setMaxWaitMillis(5000);
      //检查连接的有效性
      config.setTestOnBorrow(true);

      //第二个参数：redis服务器的ip
      //第三个参数：端口
      //第四个参数：连接服务器的超时时间
      //第五个参数：密码
      jedisPool = new JedisPool(config, "127.0.0.1", 6379, 1000, "redis");
   }

   //通过连接池获取jedis对象
   public static Jedis getJedis(){
      Jedis jedis = jedisPool.getResource();
      return jedis;
   }

   //jedis对象放回连接池
   public static void closeJedis(Jedis jedis){
      //jedisPool.returnResource(jeids);//教新的版本中已经废弃
      jedis.close();
   }

}

 
JedisPool属性说明：
 
<!-- 最大连接数 -->
		<property name="maxTotal" value="30" />
		<!-- 最大空闲连接数 -->
		<property name="maxIdle" value="10" />
		<!-- 每次释放连接的最大数目 -->
		<property name="numTestsPerEvictionRun" value="1024" />
		<!-- 释放连接的扫描间隔（毫秒） -->
		<property name="timeBetweenEvictionRunsMillis" value="30000" />
		<!-- 连接最小空闲时间 -->
		<property name="minEvictableIdleTimeMillis" value="1800000" />
		<!-- 连接空闲多久后释放, 当空闲时间>该值 且 空闲连接>最大空闲连接数 时直接释放 -->
		<property name="softMinEvictableIdleTimeMillis" value="10000" />
		<!-- 获取连接时的最大等待毫秒数,小于零:阻塞不确定的时间,默认-1 -->
		<property name="maxWaitMillis" value="1500" />
		<!-- 在获取连接的时候检查有效性, 默认false -->
		<property name="testOnBorrow" value="true" />
		<!-- 在空闲时检查有效性, 默认false -->
		<property name="testWhileIdle" value="true" />
		<!-- 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true -->
		<property name="blockWhenExhausted" value="false" />

 
二 与spring整合
 
Spring的配置文件中增加内容：
 
<!-- jedis 连接池配置参数：  -->
		<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
			<property name="maxTotal" value="100"></property>
			<property name="maxIdle" value="25"></property>
			<property name="maxWaitMillis" value="15000"></property>
			<property name="testOnBorrow" value="false"></property>
			<property name="testOnReturn" value="false"></property>
		</bean>
		<!-- jedis 连接池  连接本地redis服务 构造器注入-->
		<bean id="pool" class="redis.clients.jedis.JedisPool">
			<constructor-arg index="0"  ref="poolConfig"/> 
			<constructor-arg index="1" value="${redis_ip}"/> 
			<constructor-arg index="2" value="${redis_port}"/>
			<constructor-arg index="3" value="${redis_timeout}"/> 
			<constructor-arg index="4" value="${redis_auth}"/> 
		</bean>

 
文章目录
 
1. Jedis概述(java客户端操作Redis的工具类)
1.1 测试Jedis连接Redis操作
   
2. Jedis连接池原理(空间换时间，就相当于一个集合)
连接池的优势：
2.1 Jedis连接池实现(硬编码)
2.2 Jedis连接池优化(写成工具类调用)
   
  
 

 
1. Jedis概述(java客户端操作Redis的工具类)
 
   Jedis是Redis官方推荐使用的Java连接开发工具。除了使用命令方式，现在基本上主流的语言都有客户端支持。Java的客户端，主要使用的就是Jedis。Jedis提供了完整Redis命令，而Redisson有更多分布式的容器实现。
 
   java操作Redis的工具类：Jedis
 
Jedis连接池使用
    jedis连接池是基于apache-commons pool2实现的。在构建连接池对象的时候，需要提供池对象的配置对象，及JedisPoolConfig(继承自GenericObjectPoolConfig)。我们可以通过这个配置对象对连接池进行相关参数的配置(如最大连接数，最大空数等)。
 
   j两个jar包
 
 
1.1 测试Jedis连接Redis操作
 
public class TestJedis {
    @Test
    public void test01(){
        //1:创建一个Jedis对象   创建一个连接，参1 ip地址(Redis服务器的ip地址) 参2 端口
        Jedis jedis = new Jedis("localhost", 6379);
        //2:执行Redis的指令(set指令)
        //写入数据
        jedis.set("name","strive_gf@163.com");//添加 string-string
        jedis.sadd("set","hello","strive_gf@163.com","Welcome to use");//添加string-set集合类型
        //读取数据
        System.out.println(jedis.get("name"));
        System.out.println(jedis.smembers("set"));
        //关闭连接
        jedis.close();
    }
}
 
运行结果：
 
 
 
strive_gf@163.com
 [hello, Welcome to use, strive_gf@163.com]
 
 
2. Jedis连接池原理(空间换时间，就相当于一个集合)
 
连接池的优势：
 
 
 
因为频繁创建与销毁连接非常的消耗性能(TCP/IP的三次握手四次挥手非常的消耗性能)，连接池就是为了解决资源的频繁分配、释放所造成消耗性能问题。
 方法：创建集合初始化多个Connection，需要时调getConnection()方法申请连接，使用完后调用close()放回连接池中。(这里的close()是放回连接池，不是关闭连接)
 
 
2.1 Jedis连接池实现(硬编码)
 
硬编码
 配置参数写在java代码，编译成class，将来必须修改java代码才能改配置
 
public class TestJedisPool {
    @Test
    public void test01(){

//        1:创建连接池的配置对象
        JedisPoolConfig config = new JedisPoolConfig();
        //设置最大链接数
        config.setMaxTotal(20);
        //设置空闲连接数
        config.setMaxIdle(10);
//        2:创建连接池 参1：Redis服务器ip地址  参2：端口号
        JedisPool pool = new JedisPool(config, "localhost", 6379);
//        3:从连接池中获取一个连接
        Jedis jedis = pool.getResource();//获取一个连接
//        4:执行Redis执行  Map<String,String>   set   get
        jedis.set("name","JedisPool连接池");
        String value = jedis.get("name");
        System.out.println(value);
//        5:释放连接
        jedis.close();
    }
}
 
运行结果：
 
 
 
JedisPool连接池
 
 

 

 
2.2 Jedis连接池优化(写成工具类调用)
 
项目中，使用配置文件来配置参数，以后不需要修改java代码，直接改文件中的参数。
 
编写测试类(业务逻辑)
 
//Jedis连接池优化(JedisPool优化)
public class TestJedisUtils {
    @Test
    public void test01(){
        //1：从连接池获取连接
        Jedis jedis = JedisUtils.getRedis();
        //2: 进行读写操作
        jedis.set("name","JedisPool连接池优化JedisUtils");
        
        String value = jedis.get("name");
        System.out.println(value);
        //3: 关闭连接
        JedisUtils.close(jedis);
    }
}
 
创建properties文件存放参数变量(jedis.properties)
 //properties文件里面存的是键值对形式的数据，可以使用专门的读取工具Properties类来读取
 
maxTotal=50
maxIdle=15
url=localhost
port=6379
 
创建jedis连接池的工具类(读取.properties中文件)
 
  读.properties文件的方式：
 
可以先使用类加载器去加载成流，再使用Properties类来读。
也可以使用ResourceBundle读.propties
 
3.1 使用类加载器去加载成流，再使用Properties类来读
 
public class JedisUtils {
    //单例模式 静态代码块只执行一次，因为创建会很消耗性能
    private static JedisPool pool;
    //静态代码在项目中，如果被使用只会加载一次
    static {

        //读src下的文件用类加载器的方式  - 类加载器去加载成流，再使用Properties类来读
        InputStream inputStream= JedisUtils.class.getClassLoader().getResourceAsStream("jedis.properties");

        //.properties文件专门的读取工具
        Properties properties = new Properties();
        try {
            //将流中的数据读成map
            properties.load(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 1:创建连接池的配置对象
        JedisPoolConfig config = new JedisPoolConfig();
        //设置最大链接数
        config.setMaxTotal(Integer.parseInt(properties.getProperty("maxTotal")));
        //设置空闲连接数  "3"
        config.setMaxIdle(Integer.parseInt(properties.getProperty("maxIdle")));
        //2:创建连接池
         pool = new JedisPool(config, properties.getProperty("url"), Integer.parseInt(properties.getProperty("port")));
    }
    public static Jedis getRedis() {
//        3:从连接池中获取一个连接
        Jedis jedis = pool.getResource();//获取一个连接
        return jedis;
    }

    public static void close(Jedis jedis) {
        if(jedis!=null){
            jedis.close();
        }
    }
}

 
3.2 使用ResourceBundle读.propties
 
public class JedisUtils {
    private static JedisPool pool = null;
    //1:创建一个连接池
    static{
        //1.1 解析properties文件
        ResourceBundle bundle = ResourceBundle.getBundle("jedis");
        //获取参数
        String maxTotal = bundle.getString("maxTotal");
        String maxIdle = bundle.getString("maxIdle");
        String url = bundle.getString("url");
        String port = bundle.getString("port");

        //1.2创建连接池
        //1:创建连接池的配置对象
        JedisPoolConfig config = new JedisPoolConfig();
        //1.1 设置最大连接数
        config.setMaxTotal(Integer.parseInt(maxTotal));
        //1.2 设置空闲连接数
        config.setMaxIdle(Integer.parseInt(maxIdle));

        //2:创建连接池
         pool = new JedisPool(config, url, Integer.parseInt(port));
    }

    //2:对外提供一个获取连接的方法
    public static Jedis getJedis(){
        return  pool.getResource();
    }

    //3:提供释放资源的方法
    public static void close(Jedis jedis){
        if(jedis != null) {
            jedis.close();
        }
    }
}
 
运行结果：
 
 
 
JedisPool连接池优化JedisUtils