idea+maven（远程连接）使用Jedis

我的情况：我在自己的服务器上开启的redis，然后在本机远程连接redis，开发工具为idea，使用maven来依赖注入。

1 创建项目与连接redis

• 创建普通的maven项目
• 依赖注入

 <dependencies>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>commons-pool</groupId>
            <artifactId>commons-pool</artifactId>
            <version>20030825.183949</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

    </dependencies>

• 创建java文件

public class MyJedis {
    public static void main(String[] args) {
        Jedis jedis=new Jedis("********",6379);
        System.out.println(jedis.ping());
    }
}

注意：如果你的redis是本地的，那么填写127.0.0.1，直接使用即可，如果你需要远程连接其他主机上的redis，请看下面的步骤

• 拷贝redis.conf

[root@duan myredis]# cp redis.conf redis1.conf

• 进入编辑修改配置

  • [root@duan myredis]# vim redis1.conf
  • 编辑小技巧：/后加内容回车可以进行搜索，按u撤回上一步操作，按i进入编辑状态，esc退出编辑状态，：wq保存并退出。
  • 将绑定的ip： bind 127.0.0.1注释掉
    

  • 修改protected-mode属性为no
    

  • 接着:wq保存退出，然后使用这个conf文件重新启动redis

  • 最后再自己创建的类中的*******填写为远程主机的ip

2 jedis部分代码演示

import redis.clients.jedis.Jedis;

import java.util.*;

/**
 * @author Duan
 * @date 2018/8/16 11:01
 */

public class JedisDemo {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("39.108.191.21", 6379);

        //key
        Set<String> keys = jedis.keys("*");
        for (Iterator iterator = keys.iterator(); iterator.hasNext(); ) {
            System.out.println((String) iterator.next());
        }

        System.out.println(jedis.exists("k2"));
        System.out.println(jedis.ttl("k1"));

        //String
        jedis.append("k1", "hello myredis");
        System.out.println(jedis.get("k1"));

        jedis.set("k3", "....redis");

        jedis.mset("str1", "vv1", "str2", "vv2", "str3", "vv3");
        System.out.println(jedis.mget("str1", "str2", "str3"));

        //List
        jedis.lpush("myList", "v1", "v2", "v3", "v4", "v5");
        List<String> list = jedis.lrange("myList", 0, -1);
        for (String element : list) {
            System.out.println(element);
        }

        //set
        jedis.sadd("set1", "hello");
        jedis.sadd("set1", " world!");
        Set<String> set = jedis.smembers("set1");

        for (Iterator iterator = set.iterator(); iterator.hasNext(); ) {
            System.out.println(iterator.next());
        }

        jedis.srem("set1", "hello");
        System.out.println(jedis.smembers("set1").size());

        //hash
        jedis.hset("info", "name", "lili");
        System.out.println(jedis.hget("info", "name"));

        Map<String, String> map = new HashMap<String, String>();
        map.put("email", "[email protected]");
        map.put("age", "16");
        map.put("tel", "88888888");

        jedis.hmset("info", map);
        System.out.println(jedis.hmget("info", "age", "email"));
        String[] s = new String[]{"name", "tel"};
        System.out.println(jedis.hmget("info", s));

        //zset
        jedis.zadd("zset1",60,"v1");
        jedis.zadd("zset1",70,"v2");
        jedis.zadd("zset1",80,"v3");
        jedis.zadd("zset1",90,"v4");

        Set<String> zset=jedis.zrange("zset1",0,-1);

        for (Iterator<String> iterator=zset.iterator();iterator.hasNext();){
            System.out.println(iterator.next());
        }

    }
}

更多与五大数据类型相关的知识点及命令请点击

3 使用jedis来使用事务

//自定义的测试类
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

/**
 * @author Duan
 * @date 2018/8/17 18:07
 */

public class TestTX {
    //扣费额度
    private int balance;

    //欠款
    private int debt;

    //扣费金额
    private static int price = 10;

    Jedis jedis;

    TestTX() {
        jedis = new Jedis("39.108.191.21", 6379);
        balance = Integer.parseInt(jedis.get("balance"));
        debt = Integer.parseInt(jedis.get("debt"));
    }

    public boolean test() throws InterruptedException {
        jedis.watch("balance");

        System.out.println("开始监控");

        Transaction transaction=jedis.multi();

        transaction.decrBy("balance",price);
        transaction.incrBy("debt",price);

        Thread.sleep(7000);

        if (balance < price){
            jedis.unwatch();
            transaction.discard();
            System.out.println("金额被修改");
            return false;
        }else {
            transaction.exec();
            System.out.println("扣费成功");

            balance = Integer.parseInt(jedis.get("balance"));
            debt = Integer.parseInt(jedis.get("debt"));

            System.out.println("balance*******"+balance);
            System.out.println("debt******"+debt);
            return true;
        }
    }
}


//main
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

/**
 * @author Duan
 * @date 2018/8/16 19:40
 */

public class Affair {
    public static void main(String[] args) throws InterruptedException {
        //watch监控
        TestTX testTX=new TestTX();

        testTX.test();
    }
}

更多关于事务的知识点及命令，请点击

4 使用jedis来实现主从复制

我们需要模仿前面的步骤再创建一个新的redis.conf，然后换个端口启用一个redis（我使用的是6380）

import redis.clients.jedis.Jedis;

/**
 * @author Duan
 * @date 2018/8/21 10:41
 */

public class TestMS {
    public static void main(String[] args) throws InterruptedException {
        Jedis jedis_M=new Jedis("39.108.191.21", 6379);
        Jedis jedis_S=new Jedis("39.108.191.21", 6380);

        jedis_S.slaveof("39.108.191.21", 6379);

        System.out.println(jedis_M.keys("*"));
        jedis_M.set("kkk","vvv");
        Thread.sleep(1000);
        System.out.println(jedis_S.get("kkk"));
    }
}

更多关于主从复制的知识点及命令，请点击

5 JedisPool

JedisPool的配置参数大部分是由JedisPoolConfig的对应项来赋值的。


maxTotal：控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted。
maxIdle：控制一个pool最多有多少个状态为idle(空闲)的jedis实例；
whenExhaustedAction：表示当pool中的jedis实例都被allocated完时，pool要采取的操作；默认有三种。
 WHEN_EXHAUSTED_FAIL --> 表示无jedis实例时，直接抛出NoSuchElementException；
 WHEN_EXHAUSTED_BLOCK --> 则表示阻塞住，或者达到maxWait时抛出JedisConnectionException；
 WHEN_EXHAUSTED_GROW --> 则表示新建一个jedis实例，也就说设置的maxActive无用；
maxWaitMillis：表示当borrow一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛JedisConnectionException；
testOnBorrow：获得一个jedis实例的时候是否检查连接可用性（ping()）；如果为true，则得到的jedis实例均是可用的；


testOnReturn：return 一个jedis实例给pool时，是否检查连接可用性（ping()）；


testWhileIdle：如果为true，表示有一个idle object evitor线程对idle object进行扫描，如果validate失败，此object会被从pool中drop掉；这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义；


timeBetweenEvictionRunsMillis：表示idle object evitor两次扫描之间要sleep的毫秒数；


numTestsPerEvictionRun：表示idle object evitor每次扫描的最多的对象数；


minEvictableIdleTimeMillis：表示一个对象至少停留在idle状态的最短时间，然后才能被idle object evitor扫描并驱逐；这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义；


softMinEvictableIdleTimeMillis：在minEvictableIdleTimeMillis基础上，加入了至少minIdle个对象已经在pool里面了。如果为-1，evicted不会根据idle time驱逐任何对象。如果minEvictableIdleTimeMillis>0，则此项设置无意义，且只有在timeBetweenEvictionRunsMillis大于0时才有意义；


lifo：borrowObject返回对象时，是采用DEFAULT_LIFO（last in first out，即类似cache的最频繁使用队列），如果为False，则表示FIFO队列；


==================================================================================================================
其中JedisPoolConfig对一些参数的默认设置如下：
testWhileIdle=true
minEvictableIdleTimeMills=60000
timeBetweenEvictionRunsMillis=30000
numTestsPerEvictionRun=-1

简单自定义工具类，及使用

//自定义工具类
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class JedisPoolUtil 
{
    private static volatile JedisPool jedisPool = null;

    private JedisPoolUtil(){}

    public static JedisPool getJedisPoolInstance()
    {
        if(null == jedisPool)
        {
            synchronized (JedisPoolUtil.class)
            {
                if(null == jedisPool)
                {
                    JedisPoolConfig poolConfig = new JedisPoolConfig();
                    poolConfig.setMaxTotal(1000);
                    poolConfig.setMaxIdle(32);
                    poolConfig.setMaxWaitMillis(100*1000);
                    poolConfig.setTestOnBorrow(true);

                    jedisPool = new JedisPool(poolConfig,"39.108.191.21", 6379);
                }
            }
        }
        return jedisPool;
    }

    public static void release(JedisPool jedisPool,Jedis jedis)
    {
        if(null != jedis)
        {
            jedisPool.returnResourceObject(jedis);
        }
    }

}

//Test
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

public class TestPool {

    public static void main(String[] args) {
        JedisPool jedisPool = JedisPoolUtil.getJedisPoolInstance();

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.set("aa","bb");
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            JedisPoolUtil.release(jedisPool, jedis);
        }
    }
}