Java ChannelPool类代码示例

import io.netty.channel.pool.ChannelPool; //导入依赖的package包/类
private ChannelPoolMap<URI, ChannelPool> createChannelPoolMap() {
    return new SdkChannelPoolMap<URI, ChannelPool>() {
        @Override
        protected ChannelPool newPool(URI key) {
            Bootstrap bootstrap =
                    new Bootstrap()
                            .group(group)
                            .channel(resolveSocketChannelClass(group))
                            .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, configuration.connectionTimeout())
                            .option(ChannelOption.TCP_NODELAY, true)
                            .remoteAddress(key.getHost(), key.getPort());
            SslContext sslContext = sslContext(key.getScheme());
            return new FixedChannelPool(bootstrap,
                                        // TODO expose better options for this
                                        new ChannelPipelineInitializer(sslContext),
                                        ChannelHealthChecker.ACTIVE,
                                        FixedChannelPool.AcquireTimeoutAction.FAIL,
                                        configuration.connectionAcquisitionTimeout(),
                                        configuration.maxConnectionsPerEndpoint(),
                                        10_000);
        }
    };
}
 

import io.netty.channel.pool.ChannelPool; //导入依赖的package包/类
protected static void releaseChannelBackToPoolIfCallIsActive(Channel ch, ChannelPool pool,
                                                             ObjectHolder<Boolean> callActiveHolder,
                                                             String contextReason,
                                                             Deque<Span> distributedTracingStack,
                                                             Map<String, String> distributedTracingMdcInfo) {
    if (callActiveHolder.heldObject) {
        if (logger.isDebugEnabled()) {
            runnableWithTracingAndMdc(
                () -> logger.debug(
                    "Marking call as inactive and releasing channel back to pool. "
                    + "channel_release_reason=\"{}\"", contextReason
                ),
                distributedTracingStack, distributedTracingMdcInfo
            ).run();
        }

        callActiveHolder.heldObject = false;
        pool.release(ch);
    }
}
 

import io.netty.channel.pool.ChannelPool; //导入依赖的package包/类
/**
 * <p>Acquires a {@link Channel} from the {@link ChannelPool}</p>
 *
 * @param message
 *         An {@link AbstractRequest} that will be used as the lookup reference for the {@link
 *         io.netty.channel.pool.ChannelPoolMap} key
 *
 * @return A {@link CompletableFuture} containing the acquired {@link Channel}
 */
@Override
public CompletableFuture<Channel> getChannel(M message) {
    final CompletableFuture<Channel> channelFuture = new CompletableFuture<>();
    //Retrieve our channel pool based on the message
    final ChannelPool pool = poolMap.get(message);

    log.debug("Acquiring channel from pool '{}' for message : {}", pool, message);

    //Acquire a channel from the pool and listen for completion
    pool.acquire().addListener((Future<Channel> future) -> {
        if (future.isSuccess()) {
            log.debug("Successfully acquired Channel from pool");
            Channel channel = future.get();
            channel.attr(ChannelAttributes.CHANNEL_POOL).set(pool);
            channelFuture.complete(channel);
        } else {
            log.debug("Failed to acquire Channel from Pool");
            channelFuture.completeExceptionally(new ConnectException(future.cause()));
        }
    });
    return channelFuture;
}
 

import io.netty.channel.pool.ChannelPool; //导入依赖的package包/类
/**
 * Create a new client context with optional pool support
 *
 * @param sink
 * @param options
 * @param loggingHandler
 * @param secure
 * @param providedAddress
 * @param channelOpFactory
 * @param pool
 * @param <CHANNEL>
 *
 * @return a new {@link ContextHandler} for clients
 */
public static <CHANNEL extends Channel> ContextHandler<CHANNEL> newClientContext(
		MonoSink<NettyContext> sink,
		ClientOptions options,
		LoggingHandler loggingHandler,
		boolean secure,
		SocketAddress providedAddress,
		ChannelPool pool, ChannelOperations.OnNew<CHANNEL> channelOpFactory) {
	if (pool != null) {
		return new PooledClientContextHandler<>(channelOpFactory,
				options,
				sink,
				loggingHandler,
				secure,
				providedAddress,
				pool);
	}
	return new ClientContextHandler<>(channelOpFactory,
			options,
			sink,
			loggingHandler,
			secure,
			providedAddress);
}
 

import io.netty.channel.pool.ChannelPool; //导入依赖的package包/类
/**
 * Create a {@link ContextHandler} for {@link Bootstrap#handler()}
 *
 * @param handler user provided in/out handler
 * @param sink user provided bind handler
 * @param secure if operation should be secured
 * @param pool if channel pool
 * @param onSetup if operation has local setup callback
 *
 * @return a new {@link ContextHandler}
 */
protected ContextHandler<SocketChannel> doHandler(BiFunction<? super NettyInbound, ? super NettyOutbound, ? extends Publisher<Void>> handler,
		MonoSink<NettyContext> sink,
		boolean secure,
		SocketAddress providedAddress,
		ChannelPool pool,
		Consumer<? super Channel> onSetup) {
	return ContextHandler.newClientContext(sink,
			options,
			loggingHandler,
			secure,
			providedAddress,
			pool,
			handler == null ? EMPTY :
					(ch, c, msg) -> ChannelOperations.bind(ch, handler, c));
}
 

import io.netty.channel.pool.ChannelPool; //导入依赖的package包/类
@Override
protected ContextHandler<SocketChannel> doHandler(BiFunction<? super NettyInbound, ? super NettyOutbound, ? extends Publisher<Void>> handler,
		MonoSink<NettyContext> sink,
		boolean secure,
		SocketAddress providedAddress,
		ChannelPool pool,
		Consumer<? super Channel> onSetup) {
	return ContextHandler.<SocketChannel>newClientContext(sink,
			options,
			loggingHandler,
			secure,
			providedAddress,
			pool,
			handler != null ? (ch, c, msg) -> {
				if(onSetup != null){
					onSetup.accept(ch);
				}
				return HttpClientOperations.bindHttp(ch, handler, c);
			} : EMPTY).onPipeline(this);
}
 

import io.netty.channel.pool.ChannelPool; //导入依赖的package包/类
public RequestContext(ChannelPool channelPool,
                      SdkHttpRequest sdkRequest,
                      SdkHttpRequestProvider requestProvider,
                      HttpRequest nettyRequest,
                      SdkHttpResponseHandler handler,
                      NettyConfiguration configuration) {
    this.channelPool = channelPool;
    this.sdkRequest = sdkRequest;
    this.requestProvider = requestProvider;
    this.nettyRequest = nettyRequest;
    this.handler = handler;
    this.configuration = configuration;
}
 

import io.netty.channel.pool.ChannelPool; //导入依赖的package包/类
StreamingChannel(Channel channel,
                 ChannelPool pool,
                 ObjectHolder<Boolean> callActiveHolder,
                 ObjectHolder<Boolean> downstreamLastChunkSentHolder,
                 Deque<Span> distributedTracingSpanStack,
                 Map<String, String> distributedTracingMdcInfo) {
    this.channel = channel;
    this.pool = pool;
    this.callActiveHolder = callActiveHolder;
    this.downstreamLastChunkSentHolder = downstreamLastChunkSentHolder;
    this.distributedTracingSpanStack = distributedTracingSpanStack;
    this.distributedTracingMdcInfo = distributedTracingMdcInfo;
}
 

import io.netty.channel.pool.ChannelPool; //导入依赖的package包/类
@Before
public void beforeMethod() {
    channelMock = mock(Channel.class);
    channelPoolMock = mock(ChannelPool.class);
    eventLoopMock = mock(EventLoop.class);

    contentChunkMock = mock(HttpContent.class);

    callActiveHolder = new ObjectHolder<>();
    callActiveHolder.heldObject = true;

    downstreamLastChunkSentHolder = new ObjectHolder<>();
    downstreamLastChunkSentHolder.heldObject = false;

    streamingChannelSpy = spy(new StreamingChannel(channelMock, channelPoolMock, callActiveHolder,
                                                   downstreamLastChunkSentHolder, null, null));

    writeAndFlushChannelFutureMock = mock(ChannelFuture.class);

    doReturn(eventLoopMock).when(channelMock).eventLoop();

    doReturn(writeAndFlushChannelFutureMock).when(channelMock).writeAndFlush(contentChunkMock);

    channelIsBrokenAttrMock = mock(Attribute.class);
    doReturn(channelIsBrokenAttrMock).when(channelMock).attr(CHANNEL_IS_BROKEN_ATTR);

    streamChunkChannelPromiseMock = mock(ChannelPromise.class);
    doReturn(streamChunkChannelPromiseMock).when(channelMock).newPromise();

    failedFutureMock = mock(ChannelFuture.class);
    doReturn(failedFutureMock).when(channelMock).newFailedFuture(any(Throwable.class));
}
 

import io.netty.channel.pool.ChannelPool; //导入依赖的package包/类
PooledClientContextHandler(ChannelOperations.OnNew<CHANNEL> channelOpFactory,
		ClientOptions options,
		MonoSink<NettyContext> sink,
		LoggingHandler loggingHandler,
		boolean secure,
		SocketAddress providedAddress,
		ChannelPool pool) {
	super(channelOpFactory, options, sink, loggingHandler, providedAddress);
	this.clientOptions = options;
	this.secure = secure;
	this.pool = pool;
	this.onReleaseEmitter = DirectProcessor.create();
}
 

import io.netty.channel.pool.ChannelPool; //导入依赖的package包/类
@Override
public ChannelPool selectOrCreate(SocketAddress remote,
		Supplier<? extends Bootstrap> bootstrap,
		Consumer<? super Channel> onChannelCreate,
		EventLoopGroup group) {
	SocketAddress address = remote;
	for (; ; ) {
		Pool pool = channelPools.get(remote);
		if (pool != null) {
			return pool;
		}
		Bootstrap b = bootstrap.get();
		if (remote != null) {
			b = b.remoteAddress(remote);
		}
		else {
			address = b.config()
			          .remoteAddress();
		}
		if (log.isDebugEnabled()) {
			log.debug("New {} client pool for {}", name, address);
		}
		pool = new Pool(b, provider, onChannelCreate, group);
		if (channelPools.putIfAbsent(address, pool) == null) {
			return pool;
		}
		pool.close();
	}
}
 

import io.netty.channel.pool.ChannelPool; //导入依赖的package包/类
@Override
public ChannelPool selectOrCreate(SocketAddress address,
		Supplier<? extends Bootstrap> bootstrap,
		Consumer<? super Channel> onChannelCreate,
		EventLoopGroup group) {
	return defaultPools.selectOrCreate(address, bootstrap, onChannelCreate, group);
}
 

import io.netty.channel.pool.ChannelPool; //导入依赖的package包/类
/**
 * @param handler
 * @param address
 * @param secure
 * @param onSetup
 *
 * @return a new Mono to connect on subscribe
 */
protected Mono<NettyContext> newHandler(BiFunction<? super NettyInbound, ? super NettyOutbound, ? extends Publisher<Void>> handler,
		InetSocketAddress address,
		boolean secure,
		Consumer<? super Channel> onSetup) {

	final BiFunction<? super NettyInbound, ? super NettyOutbound, ? extends Publisher<Void>>
			targetHandler =
			null == handler ? ChannelOperations.noopHandler() : handler;

	return Mono.create(sink -> {
		SocketAddress remote = address != null ? address : options.getAddress();

		ChannelPool pool = null;

		PoolResources poolResources = options.getPoolResources();
		if (poolResources != null) {
			pool = poolResources.selectOrCreate(remote, options,
					doHandler(null, sink, secure, remote, null, null),
					options.getLoopResources().onClient(options.preferNative()));
		}

		ContextHandler<SocketChannel> contextHandler =
				doHandler(targetHandler, sink, secure, remote, pool, onSetup);
		sink.onCancel(contextHandler);

		if (pool == null) {
			Bootstrap b = options.get();
			b.remoteAddress(remote);
			b.handler(contextHandler);
			contextHandler.setFuture(b.connect());
		}
		else {
			contextHandler.setFuture(pool.acquire());
		}
	});
}
 

import io.netty.channel.pool.ChannelPool; //导入依赖的package包/类
RequestSender(String s3Location, Request requestData, SubscriptionCompletionHandler completionHandler, HandlerDemultiplexer demultiplexer, ChannelPool channelPool) {
    this.s3Location = s3Location;
    this.requestData = requestData;
    this.completionHandler = completionHandler;
    this.demultiplexer = demultiplexer;
    this.channelPool = channelPool;
}
 

import io.netty.channel.pool.ChannelPool; //导入依赖的package包/类
ChannelPool channelPool() {
    return channelPool;
}