下面列出了io.netty.channel.ChannelPipeline#addBefore ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Redirect(method = "setCompressionThreshold", at = @At(
value = "INVOKE",
remap = false,
target = "Lio/netty/channel/ChannelPipeline;addBefore(Ljava/lang/String;Ljava/lang/String;Lio/netty/channel/ChannelHandler;)Lio/netty/channel/ChannelPipeline;"
))
private ChannelPipeline decodeEncodePlacement(ChannelPipeline instance, String base, String newHandler, ChannelHandler handler) {
// Fixes the handler order
switch (base) {
case "decoder": {
if (instance.get(CommonTransformer.HANDLER_DECODER_NAME) != null)
base = CommonTransformer.HANDLER_DECODER_NAME;
break;
}
case "encoder": {
if (instance.get(CommonTransformer.HANDLER_ENCODER_NAME) != null)
base = CommonTransformer.HANDLER_ENCODER_NAME;
break;
}
}
return instance.addBefore(base, newHandler, handler);
}
private void configureHttp2(ChannelPipeline pipeline) {
// setup the initial stream settings for the server to use.
Http2Settings settings = new Http2Settings()
.maxConcurrentStreams(maxConcurrentStreams)
.initialWindowSize(initialWindowSize)
.headerTableSize(maxHeaderTableSize)
.maxHeaderListSize(maxHeaderListSize);
Http2FrameCodec frameCodec = Http2FrameCodecBuilder.forServer()
.frameLogger(FRAME_LOGGER)
.initialSettings(settings)
.validateHeaders(true)
.build();
Http2MultiplexHandler multiplexHandler = new Http2MultiplexHandler(http2StreamHandler);
// The frame codec MUST be in the pipeline.
pipeline.addBefore("codec_placeholder", /* name= */ null, frameCodec);
pipeline.replace("codec_placeholder", HTTP_CODEC_HANDLER_NAME, multiplexHandler);
}
void upgradeToSSLConnection(Handler<AsyncResult<Void>> completionHandler) {
ChannelPipeline pipeline = socket.channelHandlerContext().pipeline();
Promise<Void> upgradePromise = Promise.promise();
upgradePromise.future().onComplete(ar->{
if (ar.succeeded()) {
completionHandler.handle(Future.succeededFuture());
} else {
Throwable cause = ar.cause();
if (cause instanceof DecoderException) {
DecoderException err = (DecoderException) cause;
cause = err.getCause();
}
completionHandler.handle(Future.failedFuture(cause));
}
});
pipeline.addBefore("handler", "initiate-ssl-handler", new InitiateSslHandler(this, upgradePromise));
}
@Override
protected void addCodec(ChannelHandlerContext ctx) throws Exception {
ChannelPipeline p = ctx.pipeline();
String name = ctx.name();
Socks5InitialResponseDecoder decoder = new Socks5InitialResponseDecoder();
p.addBefore(name, null, decoder);
decoderName = p.context(decoder).name();
encoderName = decoderName + ".encoder";
p.addBefore(name, encoderName, Socks5ClientEncoder.DEFAULT);
}
public PacketHandler(Events eventHandler) {
this.protector = new MainProtector();
this.protector.init();
this.eventHandler = eventHandler;
try {
ChannelPipeline pipeline = Wrapper.INSTANCE.mc().getNetHandler().getNetworkManager().channel().pipeline();
pipeline.addBefore("packet_handler", "PacketHandler", this);
InteropUtils.log("Attached", "PacketHandler");
} catch (Exception exception) {
InteropUtils.log("Error on attaching", "PacketHandler");
}
}
@Override
public void init() {
codec = new PgCodec();
ChannelPipeline pipeline = socket.channelHandlerContext().pipeline();
pipeline.addBefore("handler", "codec", codec);
super.init();
}
@Override
public void init() {
codec = new DB2Codec(this);
ChannelPipeline pipeline = socket.channelHandlerContext().pipeline();
pipeline.addBefore("handler", "codec", codec);
super.init();
}
public static void initPipeLine(ChannelPipeline pipeline) {
final ArrayDeque<MSSQLCommandCodec<?, ?>> inflight = new ArrayDeque<>();
TdsMessageEncoder encoder = new TdsMessageEncoder(inflight);
TdsMessageDecoder messageDecoder = new TdsMessageDecoder(inflight, encoder);
TdsPacketDecoder packetDecoder = new TdsPacketDecoder();
pipeline.addBefore("handler", "encoder", encoder);
pipeline.addBefore("encoder", "messageDecoder", messageDecoder);
pipeline.addBefore("messageDecoder", "packetDecoder", packetDecoder);
}
@Override
public void init() {
codec = new MySQLCodec(this);
ChannelPipeline pipeline = socket.channelHandlerContext().pipeline();
pipeline.addBefore("handler", "codec", codec);
super.init();
}
@Override
public void handlerAdded(ChannelHandlerContext ctx) {
ChannelPipeline pipeline = ctx.pipeline();
pipeline.addBefore(ctx.name(), null, httpCodecSupplier.get());
HttpRequest connectRequest = connectRequest();
ctx.channel().writeAndFlush(connectRequest).addListener(f -> {
if (!f.isSuccess()) {
ctx.close();
sourcePool.release(ctx.channel());
initPromise.setFailure(new IOException("Unable to send CONNECT request to proxy", f.cause()));
}
});
}
@Override
public void channelRead0(ChannelHandlerContext ctx, FullHttpRequest req) throws Exception {
try {
HttpResponse response = connection.handleRequest(new FullRequestHttpRequestImpl(req));
if (response.doUpgrade()) {
ChannelPipeline pipeline = ctx.channel().pipeline();
pipeline.addBefore(
ServerInitializer.HTTP_HANDLER_NAME, "binary", new BinaryHandler(connection));
}
sendResponse(response, ctx);
} catch (Exception e) {
LOGGER.warn("Error handling homekit http request", e);
sendResponse(HttpResponseStatus.INTERNAL_SERVER_ERROR, "Error: " + e.getMessage(), ctx);
}
}
private void initChannel(ChannelPipeline pipeline) {
pipeline.addBefore("handler", "mqttEncoder", MqttEncoder.INSTANCE);
if (this.options.getMaxMessageSize() > 0) {
pipeline.addBefore("handler", "mqttDecoder", new MqttDecoder(this.options.getMaxMessageSize()));
} else {
// max message size not set, so the default from Netty MQTT codec is used
pipeline.addBefore("handler", "mqttDecoder", new MqttDecoder());
}
// adding the idle state handler for timeout on CONNECT packet
pipeline.addBefore("handler", "idle", new IdleStateHandler(this.options.timeoutOnConnect(), 0, 0));
pipeline.addBefore("handler", "timeoutOnConnect", new ChannelDuplexHandler() {
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
if (evt instanceof IdleStateEvent) {
IdleStateEvent e = (IdleStateEvent) evt;
if (e.state() == IdleState.READER_IDLE) {
// as MQTT 3.1.1 describes, if no packet is sent after a "reasonable" time (here CONNECT timeout)
// the connection is closed
ctx.channel().close();
}
}
}
});
}
private void writeClientRequestToOrigin(final PooledConnection conn, int readTimeout) {
final Channel ch = conn.getChannel();
passport.setOnChannel(ch);
// set read timeout on origin channel
ch.attr(ClientTimeoutHandler.ORIGIN_RESPONSE_READ_TIMEOUT).set(readTimeout);
context.set(ORIGIN_CHANNEL, ch);
context.set(POOLED_ORIGIN_CONNECTION_KEY, conn);
preWriteToOrigin(chosenServer.get(), zuulRequest);
final ChannelPipeline pipeline = ch.pipeline();
originResponseReceiver = getOriginResponseReceiver();
pipeline.addBefore("connectionPoolHandler", OriginResponseReceiver.CHANNEL_HANDLER_NAME, originResponseReceiver);
// check if body needs to be repopulated for retry
repopulateRetryBody();
ch.write(zuulRequest);
writeBufferedBodyContent(zuulRequest, ch);
ch.flush();
//Get ready to read origin's response
ch.read();
originConn = conn;
channelCtx.read();
}
public final ChannelFuture handshake(Channel channel, boolean sendResponse, ChannelPromise promise) {
ChannelPipeline p = channel.pipeline();
ChannelHandlerContext ctx = p.context(RfbClientDecoder.class);
p.addBefore(ctx.name(), "rfb-security-decoder", newSecurityDecoder());
ChannelHandlerContext ctx2 = p.context(RfbClientEncoder.class);
p.addBefore(ctx2.name(), "rfb-security-encoder", newSecurityEncoder());
if (!sendResponse) {
return promise.setSuccess();
}
channel.writeAndFlush(Unpooled.buffer(1).writeByte(securityType.getType()), promise);
return promise;
}
static void configureHttp11Pipeline(ChannelPipeline p,
boolean acceptGzip,
HttpResponseDecoderSpec decoder,
@Nullable Supplier<? extends ChannelMetricsRecorder> metricsRecorder,
@Nullable Function<String, String> uriTagValue) {
p.addBefore(NettyPipeline.ReactiveBridge,
NettyPipeline.HttpCodec,
new HttpClientCodec(
decoder.maxInitialLineLength(),
decoder.maxHeaderSize(),
decoder.maxChunkSize(),
decoder.failOnMissingResponse,
decoder.validateHeaders(),
decoder.initialBufferSize(),
decoder.parseHttpAfterConnectRequest));
if (acceptGzip) {
p.addAfter(NettyPipeline.HttpCodec, NettyPipeline.HttpDecompressor, new HttpContentDecompressor());
}
if (metricsRecorder != null) {
ChannelMetricsRecorder channelMetricsRecorder = metricsRecorder.get();
if (channelMetricsRecorder instanceof HttpClientMetricsRecorder) {
p.addBefore(NettyPipeline.ReactiveBridge,
NettyPipeline.HttpMetricsHandler,
new HttpClientMetricsHandler((HttpClientMetricsRecorder) channelMetricsRecorder, uriTagValue));
}
}
}
public void addProxyHandler(Channel channel) {
ChannelPipeline pipeline = channel.pipeline();
pipeline.addFirst(NettyPipeline.ProxyHandler, newProxyHandler());
if (pipeline.get(NettyPipeline.LoggingHandler) != null) {
pipeline.addBefore(NettyPipeline.ProxyHandler,
NettyPipeline.ProxyLoggingHandler,
new LoggingHandler("reactor.netty.proxy"));
}
}
@Override
protected void addCodec(ChannelHandlerContext ctx) throws Exception {
ChannelPipeline p = ctx.pipeline();
String name = ctx.name();
p.addBefore(name, null, codec);
}
@Override
protected void decode(final ChannelHandlerContext ctx, Object msg, List<Object> out) throws Exception {
if (msg instanceof ImageRect) {
final ImageRect rect = (ImageRect) msg;
render.render(rect);
return;
}
if (msg instanceof ServerDecoderEvent) {
final ServerDecoderEvent event = (ServerDecoderEvent) msg;
render.eventReceived(event);
return;
}
if (!(msg instanceof ServerInitEvent)) {
logger.error("unknown message: {}", msg);
ctx.fireChannelRead(msg);
return;
}
serverInit = (ServerInitEvent) msg;
logger.debug("handshake completed with {}", serverInit);
FrameDecoderHandler frameHandler = new FrameDecoderHandler(serverInit.getPixelFormat());
if (!frameHandler.isPixelFormatSupported()) {
ProtocolException e = new ProtocolException(String.format("pixelformat: (%s bpp) not supported yet", serverInit.getPixelFormat().getBitPerPixel()));
exceptionCaught(ctx, e);
return;
}
ChannelPipeline cp = ctx.pipeline();
cp.addBefore(ctx.name(), "rfb-encoding-encoder", new PreferedEncodingEncoder());
PreferedEncoding prefEncodings = getPreferedEncodings(frameHandler.getSupportedEncodings());
ctx.write(prefEncodings);
cp.addBefore(ctx.name(), "rfb-pixelformat-encoder", new PixelFormatEncoder());
ctx.write(serverInit.getPixelFormat());
ctx.flush();
cp.addBefore(ctx.name(), "rfb-frame-handler", frameHandler);
cp.addBefore(ctx.name(), "rfb-keyevent-encoder", new KeyButtonEventEncoder());
cp.addBefore(ctx.name(), "rfb-pointerevent-encoder", new PointerEventEncoder());
cp.addBefore(ctx.name(), "rfb-cuttext-encoder", new ClientCutTextEncoder());
render.eventReceived(getConnectInfoEvent(ctx, prefEncodings));
render.registerInputEventListener(event -> ctx.writeAndFlush(event, ctx.voidPromise()));
logger.debug("request full framebuffer update");
sendFramebufferUpdateRequest(ctx, false, 0, 0, serverInit.getFrameBufferWidth(), serverInit.getFrameBufferHeight());
logger.trace("channel pipeline: {}", cp.toMap().keySet());
}
static void configureHttp11OrH2CleartextPipeline(ChannelPipeline p,
@Nullable BiPredicate<HttpServerRequest, HttpServerResponse> compressPredicate,
ServerCookieDecoder cookieDecoder,
ServerCookieEncoder cookieEncoder,
HttpRequestDecoderSpec decoder,
boolean forwarded,
Http2Settings http2Settings,
ConnectionObserver listener,
@Nullable Supplier<? extends ChannelMetricsRecorder> metricsRecorder,
int minCompressionSize,
ChannelOperations.OnSetup opsFactory,
@Nullable Function<String, String> uriTagValue) {
HttpServerCodec httpServerCodec =
new HttpServerCodec(decoder.maxInitialLineLength(), decoder.maxHeaderSize(),
decoder.maxChunkSize(), decoder.validateHeaders(), decoder.initialBufferSize());
Http11OrH2CleartextCodec
upgrader = new Http11OrH2CleartextCodec(cookieDecoder, cookieEncoder, p.get(NettyPipeline.LoggingHandler) != null,
forwarded, http2Settings, listener, opsFactory, decoder.validateHeaders());
ChannelHandler http2ServerHandler = new H2CleartextCodec(upgrader);
CleartextHttp2ServerUpgradeHandler h2cUpgradeHandler = new CleartextHttp2ServerUpgradeHandler(
httpServerCodec,
new HttpServerUpgradeHandler(httpServerCodec, upgrader, decoder.h2cMaxContentLength()),
http2ServerHandler);
p.addBefore(NettyPipeline.ReactiveBridge,
NettyPipeline.H2CUpgradeHandler, h2cUpgradeHandler)
.addBefore(NettyPipeline.ReactiveBridge,
NettyPipeline.HttpTrafficHandler,
new HttpTrafficHandler(listener, forwarded, compressPredicate, cookieEncoder, cookieDecoder));
if (ACCESS_LOG) {
p.addAfter(NettyPipeline.H2CUpgradeHandler, NettyPipeline.AccessLogHandler, new AccessLogHandler());
}
boolean alwaysCompress = compressPredicate == null && minCompressionSize == 0;
if (alwaysCompress) {
p.addBefore(NettyPipeline.HttpTrafficHandler, NettyPipeline.CompressionHandler, new SimpleCompressionHandler());
}
if (metricsRecorder != null) {
ChannelMetricsRecorder channelMetricsRecorder = metricsRecorder.get();
if (channelMetricsRecorder instanceof HttpServerMetricsRecorder) {
p.addAfter(NettyPipeline.HttpTrafficHandler, NettyPipeline.HttpMetricsHandler,
new HttpServerMetricsHandler((HttpServerMetricsRecorder) channelMetricsRecorder, uriTagValue));
if (channelMetricsRecorder instanceof MicrometerHttpServerMetricsRecorder) {
// MicrometerHttpServerMetricsRecorder does not implement metrics on protocol level
// ChannelMetricsHandler will be removed from the pipeline
p.remove(NettyPipeline.ChannelMetricsHandler);
}
}
}
}
static void configureHttp11Pipeline(ChannelPipeline p,
@Nullable BiPredicate<HttpServerRequest, HttpServerResponse> compressPredicate,
ServerCookieDecoder cookieDecoder,
ServerCookieEncoder cookieEncoder,
HttpRequestDecoderSpec decoder,
boolean forwarded,
ConnectionObserver listener,
@Nullable Supplier<? extends ChannelMetricsRecorder> metricsRecorder,
int minCompressionSize,
@Nullable Function<String, String> uriTagValue) {
p.addBefore(NettyPipeline.ReactiveBridge,
NettyPipeline.HttpCodec,
new HttpServerCodec(decoder.maxInitialLineLength(), decoder.maxHeaderSize(),
decoder.maxChunkSize(), decoder.validateHeaders(), decoder.initialBufferSize()))
.addBefore(NettyPipeline.ReactiveBridge,
NettyPipeline.HttpTrafficHandler,
new HttpTrafficHandler(listener, forwarded, compressPredicate, cookieEncoder, cookieDecoder));
if (ACCESS_LOG) {
p.addAfter(NettyPipeline.HttpCodec, NettyPipeline.AccessLogHandler, new AccessLogHandler());
}
boolean alwaysCompress = compressPredicate == null && minCompressionSize == 0;
if (alwaysCompress) {
p.addBefore(NettyPipeline.HttpTrafficHandler, NettyPipeline.CompressionHandler, new SimpleCompressionHandler());
}
if (metricsRecorder != null) {
ChannelMetricsRecorder channelMetricsRecorder = metricsRecorder.get();
if (channelMetricsRecorder instanceof HttpServerMetricsRecorder) {
p.addAfter(NettyPipeline.HttpTrafficHandler, NettyPipeline.HttpMetricsHandler,
new HttpServerMetricsHandler((HttpServerMetricsRecorder) channelMetricsRecorder, uriTagValue));
if (channelMetricsRecorder instanceof MicrometerHttpServerMetricsRecorder) {
// MicrometerHttpServerMetricsRecorder does not implement metrics on protocol level
// ChannelMetricsHandler will be removed from the pipeline
p.remove(NettyPipeline.ChannelMetricsHandler);
}
}
}
}