如何销毁异常jedis

1.设置testOnBorrow为true

该法是在借用jedis时进行检测，如下源码

public T borrowObject(final long borrowMaxWaitMillis) throws Exception {
    assertOpen();

    final AbandonedConfig ac = this.abandonedConfig;
    if (ac != null && ac.getRemoveAbandonedOnBorrow() &&
            (getNumIdle() < 2) &&
            (getNumActive() > getMaxTotal() - 3) ) {
        removeAbandoned(ac);
    }

    PooledObject<T> p = null;

    // Get local copy of current config so it is consistent for entire
    // method execution
    final boolean blockWhenExhausted = getBlockWhenExhausted();

    boolean create;
    final long waitTime = System.currentTimeMillis();

    while (p == null) {
        create = false;
        p = idleObjects.pollFirst();
        // 初始，第一次获取jedis连接
        if (p == null) {
            p = create();
            if (p != null) {
                create = true;
            }
        }
        // 已经没有可用的jedis
        if (blockWhenExhausted) {
            if (p == null) {
                if (borrowMaxWaitMillis < 0) {
                    p = idleObjects.takeFirst();
                } else {
                    p = idleObjects.pollFirst(borrowMaxWaitMillis,
                            TimeUnit.MILLISECONDS);
                }
            }
            if (p == null) {
                throw new NoSuchElementException(
                        "Timeout waiting for idle object");
            }
        } else {
            if (p == null) {
                throw new NoSuchElementException("Pool exhausted");
            }
        }
        if (!p.allocate()) {
            p = null;
        }

        if (p != null) {
            try {
                // 激活jedis，就是更新jedis状态
                factory.activateObject(p);
            } catch (final Exception e) {
                try {
                    destroy(p);
                } catch (final Exception e1) {
                    // Ignore - activation failure is more important
                }
                p = null;
                if (create) {
                    final NoSuchElementException nsee = new NoSuchElementException(
                            "Unable to activate object");
                    nsee.initCause(e);
                    throw nsee;
                }
            }
            
            // 进行检测
            if (p != null && (getTestOnBorrow() || create && getTestOnCreate())) {
                boolean validate = false;
                Throwable validationThrowable = null;
                try {
                    validate = factory.validateObject(p);
                } catch (final Throwable t) {
                    PoolUtils.checkRethrow(t);
                    validationThrowable = t;
                }
                if (!validate) {
                    try {
                        // 不符合要求，便销毁该jedis，新建一个jedis于池中,下一轮循环获取jedis连接
                        destroy(p);
                        destroyedByBorrowValidationCount.incrementAndGet();
                    } catch (final Exception e) {
                        // Ignore - validation failure is more important
                    }
                    p = null;
                    if (create) {
                        final NoSuchElementException nsee = new NoSuchElementException(
                                "Unable to validate object");
                        nsee.initCause(validationThrowable);
                        throw nsee;
                    }
                }
            }
        }
    }

    updateStatsBorrow(p, System.currentTimeMillis() - waitTime);

    return p.getObject();
}

2.设置testOnReturn为true

该法是在归还jedis时进行检测，如下源码

public void returnObject(final T obj) {
    final PooledObject<T> p = allObjects.get(new IdentityWrapper<>(obj));

    if (p == null) {
        if (!isAbandonedConfig()) {
            throw new IllegalStateException(
                    "Returned object not currently part of this pool");
        }
        return; // Object was abandoned and removed
    }

    markReturningState(p);

    final long activeTime = p.getActiveTimeMillis();

    // 归还时检测jedis
    if (getTestOnReturn() && !factory.validateObject(p)) {
        try {
            // 销毁该jedis，新建一个jedis于池中,下一轮循环获取jedis连接
            destroy(p);
        } catch (final Exception e) {
            swallowException(e);
        }
        try {
            ensureIdle(1, false);
        } catch (final Exception e) {
            swallowException(e);
        }
        updateStatsReturn(activeTime);
        return;
    }
.......
    updateStatsReturn(activeTime);
}

3.returnBrokenResource

该法最终使用invalidateObject关闭jedis

public void invalidateObject(final T obj) throws Exception {
    final PooledObject<T> p = allObjects.get(new IdentityWrapper<>(obj));
    if (p == null) {
        if (isAbandonedConfig()) {
            return;
        }
        throw new IllegalStateException(
                "Invalidated object not currently part of this pool");
    }
    synchronized (p) {
        if (p.getState() != PooledObjectState.INVALID) {
            // 销毁该jedis，新建一个jedis于池中,下一轮循环获取jedis连接
            destroy(p);
        }
    }
    ensureIdle(1, false);
}

4.联合使用quit，disconnect，close方法

前两种方法分别是在借和归还jedis于jedisPool时进行检测，如果发现异常，便会直接销毁该jedis，并且新建一个jedis使用。

第三种方法，已经被jedis作为废弃接口。

第四种方法，虽然没有像前三种方法一样，直接销毁掉该jedis实例，但是为啥能达到效果呢？

• quit是请求服务端关闭与该客户端的连接。

• disconnect是客户端关闭客户端与服务端的连接。

public void disconnect() {
  if (isConnected()) {
    try {
      outputStream.flush();
      socket.close();
    } catch (IOException ex) {
      broken = true;
      throw new JedisConnectionException(ex);
    } finally {
      IOUtils.closeQuietly(socket);
    }
  }
}

• close便是归还该jedis。

  如果没有使用disconnect，相当于只关闭了服务端与客户端这一方向的连接，众所周知，socket连接是双端的，所以单向关闭连接后，再次客户端发起请求，会报异常。

Exception in thread “main”
redis.clients.jedis.exceptions.JedisConnectionException:
java.net.SocketException: Connection reset at
redis.clients.util.RedisInputStream.ensureFill(RedisInputStream.java:202)
at
redis.clients.util.RedisInputStream.readByte(RedisInputStream.java:40)
at redis.clients.jedis.Protocol.process(Protocol.java:151) at
redis.clients.jedis.Protocol.read(Protocol.java:215) at
redis.clients.jedis.Connection.readProtocolWithCheckingBroken(Connection.java:340)
at
redis.clients.jedis.Connection.getBinaryMultiBulkReply(Connection.java:276)
at
redis.clients.jedis.Connection.getMultiBulkReply(Connection.java:269)
at redis.clients.jedis.Jedis.mget(Jedis.java:407)

只有使用了disconnect才能达到双端都关闭连接，避免上述异常。

以上便是4种销毁或重置异常jedis的方式了。