Java NettyContext类代码示例

import reactor.ipc.netty.NettyContext; //导入依赖的package包/类
@Override
public Mono<? extends NettyContext> newHandler(BiFunction<? super UdpInbound, ? super UdpOutbound, ? extends Publisher<Void>> handler) {
	final BiFunction<? super UdpInbound, ? super UdpOutbound, ? extends Publisher<Void>>
			targetHandler =
			null == handler ? ChannelOperations.noopHandler() : handler;

	return Mono.create(sink -> {
		Bootstrap b = options.get();
		SocketAddress adr = options.getAddress();
		if(adr == null){
			sink.error(new NullPointerException("Provided UdpServerOptions do not " +
					"define any address to bind to "));
			return;
		}
		b.localAddress(adr);
		ContextHandler<DatagramChannel> c = doHandler(targetHandler, sink, adr);
		b.handler(c);
		c.setFuture(b.bind());
	});
}
 

import reactor.ipc.netty.NettyContext; //导入依赖的package包/类
@Override
public Mono<? extends NettyContext> newHandler(BiFunction<? super UdpInbound, ? super UdpOutbound, ? extends Publisher<Void>> handler) {
	final BiFunction<? super UdpInbound, ? super UdpOutbound, ? extends Publisher<Void>>
			targetHandler =
			null == handler ? ChannelOperations.noopHandler() : handler;

	return Mono.create(sink -> {
		Bootstrap b = options.get();
		SocketAddress adr = options.getAddress();
		if(adr == null){
			sink.error(new NullPointerException("Provided UdpClientOptions do not " +
					"define any address to bind to "));
			return;
		}
		b.remoteAddress(adr);
		ContextHandler<DatagramChannel> c = doHandler(targetHandler, sink, adr);
		b.handler(c);
		c.setFuture(b.connect());
	});
}
 

import reactor.ipc.netty.NettyContext; //导入依赖的package包/类
/**
 * Create a new client context
 *
 * @param sink
 * @param options
 * @param loggingHandler
 * @param secure
 * @param channelOpFactory
 * @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,
		ChannelOperations.OnNew<CHANNEL> channelOpFactory) {
	return newClientContext(sink,
			options,
			loggingHandler,
			secure,
			providedAddress,
			null,
			channelOpFactory);
}
 

import reactor.ipc.netty.NettyContext; //导入依赖的package包/类
/**
 * @param channelOpFactory
 * @param options
 * @param sink
 * @param loggingHandler
 * @param providedAddress the {@link InetSocketAddress} targeted by the operation
 * associated with that handler (useable eg. for SNI), or null if unavailable.
 */
@SuppressWarnings("unchecked")
protected ContextHandler(ChannelOperations.OnNew<CHANNEL> channelOpFactory,
		NettyOptions<?, ?> options,
		MonoSink<NettyContext> sink,
		LoggingHandler loggingHandler,
		SocketAddress providedAddress) {
	this.channelOpFactory =
			Objects.requireNonNull(channelOpFactory, "channelOpFactory");
	this.options = options;
	this.sink = sink;
	this.loggingHandler = loggingHandler;
	this.autoCreateOperations = true;
	this.providedAddress = providedAddress;

}
 

import reactor.ipc.netty.NettyContext; //导入依赖的package包/类
final void release(CHANNEL c) {
	if (log.isDebugEnabled()) {
		log.debug("Releasing channel: {}", c.toString());
	}

	if (!NettyContext.isPersistent(c) && c.isActive()) {
		c.close();
	}

	pool.release(c)
	    .addListener(f -> {
		    if (f.isSuccess()) {
			    onReleaseEmitter.onComplete();
		    }
		    else {
			    onReleaseEmitter.onError(f.cause());
		    }
	    });

}
 

import reactor.ipc.netty.NettyContext; //导入依赖的package包/类
/**
 * {@inheritDoc}
 * <p>
 * This adds a ChunkedWriter to the pipeline to extract chunks from the
 * {@link io.netty.handler.stream.ChunkedInput} that the strategy produces. This step
 * is skipped if the handler is already present, and the placement of the handler
 * depends on the presence of the ReactiveBridge handler (see {@link NettyPipeline}).
 *
 * @param context the context from which to obtain the channel and pipeline
 */
@Override
public final void preparePipeline(NettyContext context) {
	this.addHandler = context.channel()
	                         .pipeline()
	                         .get(NettyPipeline.ChunkedWriter) == null;
	if (addHandler) {
		boolean hasReactiveBridge = context.channel()
		                                   .pipeline()
		                                   .get(NettyPipeline.ReactiveBridge) != null;

		if (hasReactiveBridge) {
			context.channel()
			       .pipeline()
			       .addBefore(NettyPipeline.ReactiveBridge,
					       NettyPipeline.ChunkedWriter,
					       new ChunkedWriteHandler());
		}
		else {
			context.channel()
			       .pipeline()
			       .addLast(NettyPipeline.ChunkedWriter, new ChunkedWriteHandler());
		}
	}
}
 

import reactor.ipc.netty.NettyContext; //导入依赖的package包/类
@Test
public void testIssue186() {
	NettyContext server =
			HttpServer.create(0)
			          .newHandler((req, res) -> res.status(200).send())
			          .block(Duration.ofSeconds(300));

	HttpClient client =
			HttpClient.create(ops -> ops.connectAddress(() -> server.address())
					                    .poolResources(PoolResources.fixed("test", 1)));

	try {
		doTestIssue186(client);
		doTestIssue186(client);
	}
	finally {
		server.dispose();
	}

}
 

import reactor.ipc.netty.NettyContext; //导入依赖的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 reactor.ipc.netty.NettyContext; //导入依赖的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 reactor.ipc.netty.NettyContext; //导入依赖的package包/类
@Override
public WebsocketOutbound sendWebsocket(String subprotocols) {
	Mono<Void> m = withWebsocketSupport(websocketUri(), subprotocols, noopHandler());

	return new WebsocketOutbound() {

		@Override
		public String selectedSubprotocol() {
			return null;
		}

		@Override
		public NettyContext context() {
			return HttpClientOperations.this;
		}

		@Override
		public Mono<Void> then() {
			return m;
		}
	};
}
 

import reactor.ipc.netty.NettyContext; //导入依赖的package包/类
@Test
public void nonContentStatusCodes() {
	NettyContext server =
			HttpServer.create(ops -> ops.host("localhost"))
			          .newRouter(r -> r.get("/204-1", (req, res) -> res.status(HttpResponseStatus.NO_CONTENT)
			                                                           .sendHeaders())
			                           .get("/204-2", (req, res) -> res.status(HttpResponseStatus.NO_CONTENT))
			                           .get("/205-1", (req, res) -> res.status(HttpResponseStatus.RESET_CONTENT)
			                                                           .sendHeaders())
			                           .get("/205-2", (req, res) -> res.status(HttpResponseStatus.RESET_CONTENT))
			                           .get("/304-1", (req, res) -> res.status(HttpResponseStatus.NOT_MODIFIED)
			                                                           .sendHeaders())
			                           .get("/304-2", (req, res) -> res.status(HttpResponseStatus.NOT_MODIFIED)))
			          .block(Duration.ofSeconds(30));

	checkResponse("/204-1", server.address());
	checkResponse("/204-2", server.address());
	checkResponse("/205-1", server.address());
	checkResponse("/205-2", server.address());
	checkResponse("/304-1", server.address());
	checkResponse("/304-2", server.address());

	server.dispose();
}
 

import reactor.ipc.netty.NettyContext; //导入依赖的package包/类
static void autoAddHttpExtractor(NettyContext c, String name, ChannelHandler
		handler){

	if (handler instanceof ByteToMessageDecoder
			|| handler instanceof ByteToMessageCodec
			|| handler instanceof CombinedChannelDuplexHandler) {
		String extractorName = name+"$extractor";

		if(c.channel().pipeline().context(extractorName) != null){
			return;
		}

		c.channel().pipeline().addBefore(name, extractorName, HTTP_EXTRACTOR);

		if(NettyContext.isPersistent(c.channel())){
			c.onClose(() -> c.removeHandler(extractorName));
		}

	}
}
 

import reactor.ipc.netty.NettyContext; //导入依赖的package包/类
@Test
public void testTcpClient() throws InterruptedException {
	final CountDownLatch latch = new CountDownLatch(1);

	NettyContext client = TcpClient.create("localhost", echoServerPort)
	                               .newHandler((in, out) -> {
		                               in.receive()
		                                 .log("conn")
		                                 .subscribe(s -> latch.countDown());

		                               return out.sendString(Flux.just("Hello World!"))
		                                  .neverComplete();
	                               })
	                               .block(Duration.ofSeconds(30));

	latch.await(30, TimeUnit.SECONDS);

	client.dispose();

	assertThat("latch was counted down", latch.getCount(), is(0L));
}
 

import reactor.ipc.netty.NettyContext; //导入依赖的package包/类
@Test
public void testTcpClientWithInetSocketAddress() throws InterruptedException {
	final CountDownLatch latch = new CountDownLatch(1);

	TcpClient client =
			TcpClient.create(echoServerPort);

	NettyContext s = client.newHandler((in, out) -> {
		in.receive()
		  .subscribe(d -> latch.countDown());

		return out.sendString(Flux.just("Hello"))
		   .neverComplete();
	})
	                       .block(Duration.ofSeconds(5));

	latch.await(5, TimeUnit.SECONDS);

	s.dispose();

	assertThat("latch was counted down", latch.getCount(), is(0L));
}
 

import reactor.ipc.netty.NettyContext; //导入依赖的package包/类
@Test
public void readIdleDoesNotFireWhileDataIsBeingRead()
		throws InterruptedException, IOException {
	final CountDownLatch latch = new CountDownLatch(1);
	long start = System.currentTimeMillis();

	TcpClient client = TcpClient.create("localhost", heartbeatServerPort);

	NettyContext s = client.newHandler((in, out) -> {
		in.onReadIdle(500, latch::countDown);
		return Flux.never();
	})
	                       .block(Duration.ofSeconds(30));

	assertTrue(latch.await(15, TimeUnit.SECONDS));
	heartbeatServer.close();

	long duration = System.currentTimeMillis() - start;

	assertThat(duration, is(greaterThanOrEqualTo(500L)));
	s.dispose();
}