如何销毁异常jedis

客官°小女子只卖身不卖艺 2023-07-15 12:48 52阅读 0赞

### 文章目录 ###

*   *   *  1.设置testOnBorrow为true
         *  2.设置testOnReturn为true
         *  3.returnBrokenResource
         *  4.联合使用quit，disconnect，close方法

### 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的方式了。