org.apache.commons.pool2.impl.DefaultPooledObject Java Examples

@Override
public PooledObject<NettyClient> makeObject(Endpoint key) throws Exception {
    if(!isProxyEnabled(key)) {
        return super.makeObject(key);
    }
    ProxyConnectProtocol protocol = ((ProxyEnabled) key).getProxyProtocol();
    ChannelFuture f = proxyedConnectionFactory.getProxyedConnectionChannelFuture(protocol, b);
    f.addListener(new ChannelFutureListener() {
        @Override
        public void operationComplete(ChannelFuture future) throws Exception {
            future.channel().writeAndFlush(protocol.output());
        }
    });
    NettyClient nettyClient = new AsyncNettyClient(f, key);
    f.channel().attr(NettyClientHandler.KEY_CLIENT).set(nettyClient);
    return new DefaultPooledObject<>(nettyClient);
}
 

private synchronized GenericKeyedObjectPool<String, Script> getPool() {
    if (pool == null) {
        GenericKeyedObjectPoolConfig<Script> poolConfig = new GenericKeyedObjectPoolConfig<>();
        poolConfig.setMaxTotalPerKey(-1);
        poolConfig.setMaxIdlePerKey(globalConfig.getGroovyEvaluationPoolMaxIdle());
        pool = new GenericKeyedObjectPool<>(
                new BaseKeyedPooledObjectFactory<String, Script>() {
                    @Override
                    public Script create(String key) {
                        return createScript(key);
                    }

                    @Override
                    public PooledObject<Script> wrap(Script value) {
                        return new DefaultPooledObject<>(value);
                    }
                },
                poolConfig
        );
    }
    return pool;
}
 

@Override
public PooledObject<TrackerServer> makeObject() {
    TrackerClient trackerClient = new TrackerClient();
    TrackerServer trackerServer = null;
    try {
        trackerServer = trackerClient.getConnection();
        int flag = 0;
        while (trackerServer == null && flag < 5) {
            log.info("[创建TrackerServer(createTrackerServer)][第" + flag + "次重建]");
            flag++;
            trackerServer = trackerClient.getConnection();
        }

    } catch (Exception e) {
        e.printStackTrace();
    }
    return new DefaultPooledObject<>(trackerServer);
}
 

@Override
public PooledObject<Jedis> makeObject() throws Exception {
  final HostAndPort hostAndPort = this.hostAndPort.get();
  final Jedis jedis = new Jedis(hostAndPort.getHost(), hostAndPort.getPort(), connectionTimeout,
      soTimeout);

  try {
    jedis.connect();
    if (null != this.password) {
      jedis.auth(this.password);
    }
    if (database != 0) {
      jedis.select(database);
    }
    if (clientName != null) {
      jedis.clientSetname(clientName);
    }
  } catch (JedisException je) {
    jedis.close();
    throw je;
  }

  return new DefaultPooledObject<Jedis>(jedis);

}
 

private void createGenericObjectPool() {
    genericObjectPoolCount++;
    GenericObjectPoolConfig<Object> config = new GenericObjectPoolConfig<>();
    config.setMaxTotal(10);

    new GenericObjectPool<>(new BasePooledObjectFactory<Object>() {
        @Override
        public Object create() {
            return new Object();
        }

        @Override
        public PooledObject<Object> wrap(Object testObject) {
            return new DefaultPooledObject<>(testObject);
        }
    }, config);
}
 

public PooledObject<FTPClient> makeObject() throws Exception {
    FTPClient ftpClient = new FTPClient();
    ftpClient.setConnectTimeout(config.getClientTimeout());
    ftpClient.connect(config.getHost(), config.getPort());
    int reply = ftpClient.getReplyCode();
    if (!FTPReply.isPositiveCompletion(reply)) {
        ftpClient.disconnect();
        logger.warn("FTPServer refused connection");
        return null;
    }
    boolean result = ftpClient.login(config.getUsername(), config.getPassword());
    if (!result) {
        throw new ConnectException("ftp登陆失败:" + config.getUsername() + "/password:" + config.getPassword() + "@" + config.getHost());
    }
    ftpClient.setFileType(config.getTransferFileType());
    ftpClient.setBufferSize(1024);
    ftpClient.setControlEncoding(config.getEncoding());
    if (config.isPassiveMode()) {
        ftpClient.enterLocalPassiveMode();
    }
    return new DefaultPooledObject<>(ftpClient);

}
 

@Override
public PooledObject<JedisConnection> makeObject() throws Exception {
	final HostAndPort hostAndPort = this.hostAndPort.get();

	final JedisConnection jedis = new JedisConnection(hostAndPort.getHost(), hostAndPort.getPort(),
			connectionTimeout, soTimeout);

	try {
		jedis.connect();
		if (password != null) {
			jedis.sendCommand(RedisCommand.AUTH, password);
			jedis.getStatusCodeReply();
		}
	} catch (JedisException je) {
		jedis.close();
		throw je;
	}

	return new DefaultPooledObject<JedisConnection>(jedis);

}
 

@Override
public PooledObject<ClosableSmtpConnection> makeObject() throws Exception {
  LOG.debug("makeObject");

  Transport transport = transportFactory.getTransport(session);
  connectionStrategy.connect(transport);

  DefaultClosableSmtpConnection closableSmtpTransport = new DefaultClosableSmtpConnection(transport, invalidateConnectionOnException);
  initDefaultListeners(closableSmtpTransport);

  return new DefaultPooledObject(closableSmtpTransport);
}
 

@Test
void testWrap()
{
    PooledObject<String> actual = factory.wrap(VALUE);
    assertThat(actual, instanceOf(DefaultPooledObject.class));
    assertEquals(VALUE, actual.getObject());
}
 

@Override
public PooledObject<JenkinsClient> makeObject() throws Exception {
    final JenkinsClient jenkinsClient = new JenkinsClient(url, username, password, clientBuilder());
    try {
        jenkinsClient.isRunning();
    } catch (Exception e) {
        jenkinsClient.close();
        throw e;
    }
    return new DefaultPooledObject<>(jenkinsClient);
}
 

public PooledObject<RestHighLevelClient> makeObject() throws Exception {
    HttpHost[] nodes = new HttpHost[nodesReference.get().size()];
    List<HttpHost> nodeList = new ArrayList<HttpHost>();
    for(HostAndPort each: nodesReference.get()){
        nodeList.add(new HttpHost(each.getHost(),each.getPort(),each.getSchema()));
    }
    nodes = nodeList.toArray(nodes);
    RestClientBuilder clientBuilder = RestClient.builder(nodes);
    RestHighLevelClient client = new RestHighLevelClient(clientBuilder);
    return new DefaultPooledObject(client);
}
 

/**
 * {@inheritDoc}
 * 
 * Specifically, we are creating a new connection based on the LdapConnection Factory
 * we used to create this pool of connections. The default is to create bound connections.
 * 
 * @throws LdapException If unable to connect.
 */
@Override
public PooledObject<LdapConnection> makeObject() throws LdapException
{
    if ( LOG.isDebugEnabled() )
    {
        LOG.debug( I18n.msg( I18n.MSG_04150_CREATING_LDAP_CONNECTION ) );
    }
    
    return new DefaultPooledObject<LdapConnection>( new MonitoringLdapConnection( connectionFactory.newLdapConnection() ) );
}
 

/**
 * {@inheritDoc}
 * Specifically, we are creating a new connection based on the LdapConnection Factory
 * we used to create this pool of connections. The default is to create bound connections.
 * 
 * @throws LdapException If unable to connect.
 */
@Override
public PooledObject<LdapConnection> makeObject() throws LdapException
{
    if ( LOG.isDebugEnabled() )
    {
        LOG.debug( I18n.msg( I18n.MSG_04150_CREATING_LDAP_CONNECTION ) );
    }
    
    return new DefaultPooledObject<>( connectionFactory.newLdapConnection() );
}
 

private void createGenericKeyedObjectPool() {
    new GenericKeyedObjectPool<>(new BaseKeyedPooledObjectFactory<Object, Object>() {
        @Override
        public Object create(Object key) {
            return key;
        }

        @Override
        public PooledObject<Object> wrap(Object value) {
            return new DefaultPooledObject<>(value);
        }
    });
}
 

@Override
public PooledObject<TTransport> makeObject(ThriftServer thriftServer) throws Exception {
	TSocket tsocket = new TSocket(thriftServer.getHost(), thriftServer.getPort());
	tsocket.setTimeout(timeout);
	TFramedTransport transport = new TFramedTransport(tsocket);
	
	transport.open();
	DefaultPooledObject<TTransport> result = new DefaultPooledObject<TTransport>(transport);
	logger.trace("Make new thrift connection: {}:{}", thriftServer.getHost(), thriftServer.getPort());
	
	return result;
}
 

@Override
public PooledObject<WebSocketSubscriptionClient> makeObject(TimelyBalancedHost k) throws Exception {

    int bufferSize = balancerConfig.getWebsocket().getIncomingBufferSize();
    WebSocketSubscriptionClient client = new WebSocketSubscriptionClient(sslContext, k.getHost(), k.getHttpPort(),
            k.getWsPort(), balancerConfig.getSecurity().getClientSsl().isUseClientCert(),
            balancerConfig.isLoginRequired(), "", "",
            balancerConfig.getSecurity().getClientSsl().isHostVerificationEnabled(), bufferSize);
    return new DefaultPooledObject<>(client);
}
 

@Override
public PooledObject<CloseableHttpClient> makeObject() throws Exception {
    RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(connectionRequestTimeout)
            .setConnectTimeout(connectTimeout).setSocketTimeout(socketTimeout).build();
    HttpClientBuilder builder = HttpClientBuilder.create();
    builder.setDefaultRequestConfig(requestConfig);
    builder.setConnectionTimeToLive(connectionTimeToLive, TimeUnit.MILLISECONDS);
    return new DefaultPooledObject<>(builder.build());
}
 

@Override
public void activateObject(PooledObject<PhantomJSProcess> pooledObject) throws Exception
{
	super.activateObject(pooledObject);
	
	PhantomJSProcess process = pooledObject.getObject();
	if (process.hasEnded())
	{
		if (log.isDebugEnabled())
		{
			log.debug(process.getId() + " has ended");
		}
		
		throw new JRRuntimeException("Process " + process.getId() + " has ended");
	}
	
	long borrowedCount = ((DefaultPooledObject<PhantomJSProcess>) pooledObject).getBorrowedCount();
	if (borrowedCount >= expirationCount)
	{
		if (log.isDebugEnabled())
		{
			log.debug(process.getId() + " borrow count " + borrowedCount 
					+ " exceeded expiration count " + expirationCount);
		}
		
		throw new JRRuntimeException("Process " + process.getId() + " borrow count exceeded");
	}
	
	long now = System.currentTimeMillis();
	if (now >= pooledObject.getCreateTime() + expirationTime)
	{
		if (log.isDebugEnabled())
		{
			log.debug(process.getId() + " expiration time " + expirationTime 
					+ " from " + pooledObject.getCreateTime() + " exceeded");
		}
		
		throw new JRRuntimeException("Process " + process.getId() + " expiration time exceeded");
	}
}
 

@Override
public PooledObject<NettyClient> makeObject(Endpoint key) {
    ProxyEndpoint endpoint = (ProxyEndpoint) key;
    ChannelFuture f = getBootstrap(endpoint).connect(key.getHost(), key.getPort());
    NettyClient nettyClient = new AsyncNettyClient(f, key);
    f.channel().attr(NettyClientHandler.KEY_CLIENT).set(nettyClient);
    return new DefaultPooledObject<>(nettyClient);
}
 

@Override
public PooledObject<NettyClient> makeObject(Endpoint key) throws Exception {

	ChannelFuture f = b.connect(key.getHost(), key.getPort());
	NettyClient nettyClient = new AsyncNettyClient(f, key);
	f.channel().attr(NettyClientHandler.KEY_CLIENT).set(nettyClient);
	return new DefaultPooledObject<NettyClient>(nettyClient);
}
 

@Override
public PooledObject<NettyClient> makeObject() throws Exception {

	ChannelFuture f = b.connect(endpoint.getHost(), endpoint.getPort());
	f.get(connectTimeoutMilli, TimeUnit.MILLISECONDS);
	Channel channel = f.channel();
	sendProxyProtocolIfNeeded(channel);
	logger.info("[makeObject]{}", channel);
	NettyClient nettyClient = new DefaultNettyClient(channel);
	channel.attr(NettyClientHandler.KEY_CLIENT).set(nettyClient);
	return new DefaultPooledObject<NettyClient>(nettyClient);
}
 

@SuppressWarnings("resource")
@Override
      public PooledObject<SocketHolder> makeObject(SocketAddress addr) throws Exception {
          SocketHolder socketHolder = new SocketHolder();
          Socket socket = new Socket();
          socket.connect(addr, 1000);
          socketHolder.socket = socket;
          socketHolder.dis = new DataInputStream(socket.getInputStream());
          socketHolder.dos = new DataOutputStream(socket.getOutputStream());
          return new DefaultPooledObject<TcpRpcEndpoint.SocketHolder>(socketHolder);
      }
 

@Override
public PooledObject<ReadByteBuf> wrap(ReadByteBuf obj) {
    return new DefaultPooledObject<>(obj);
}
 

/**
 * 将对象池化pooledObject
 */
@Override
public PooledObject<Connection> wrap(Connection conn) {
    return new DefaultPooledObject<Connection>(conn);
}
 

@Override
public PooledObject<ThriftSocket> wrap(ThriftSocket thriftSocket) {
	return new DefaultPooledObject<>(thriftSocket);
}
 

@Override
public PooledObject<PhantomJSProcess> wrap(PhantomJSProcess process)
{
	return new DefaultPooledObject<PhantomJSProcess>(process);
}
 

@Override
public PooledObject<ShardedJedis> makeObject() throws Exception {
  ShardedJedis jedis = new ShardedJedis(shards, algo, keyTagPattern);
  return new DefaultPooledObject<ShardedJedis>(jedis);
}
 

@Override
public PooledObject<CarreraConnection> wrap(CarreraConnection value) {
    return new DefaultPooledObject<>(value);
}
 

@Override
public PooledObject<HerdDBConnection> makeObject() throws Exception {
    HerdDBConnection res = new HerdDBConnection(BasicHerdDBDataSource.this, getHDBConnection(), defaultSchema);
    return new DefaultPooledObject<>(res);
}
 

@Override
public PooledObject<Channel> wrap(Channel obj) {
    return new DefaultPooledObject<>(obj);
}