gateway、webflux、reactor-netty请求日志输出方式

package reactor.netty.http.server; 

import reactor.util.Logger;

import reactor.util.Loggers;

import java.time.ZonedDateTime;

import java.time.format.DateTimeFormatter;

import java.util.Locale;

import java.util.Objects;

final class AccessLog {

     static final Logger log = Loggers.getLogger( "reactor.netty.http.server.AccessLog" );

     static final DateTimeFormatter DATE_TIME_FORMATTER =

             DateTimeFormatter.ofPattern( "dd/MMM/yyyy:HH:mm:ss Z" , Locale.US);

     static final String COMMON_LOG_FORMAT =

             "{} - {} [{}] \"{} {} {}\" {} {} {} {} ms" ;

     static final String MISSING = "-" ; 

     final String zonedDateTime;

     String address;

     CharSequence method;

     CharSequence uri;

     String protocol;

     String user = MISSING;

     CharSequence status;

     long contentLength;

     boolean chunked;

     long startTime = System.currentTimeMillis();

     int port;

     AccessLog() {

         this .zonedDateTime = ZonedDateTime.now().format(DATE_TIME_FORMATTER);

     }

     AccessLog address(String address) {

         this .address = Objects.requireNonNull(address, "address" );

         return this ;

     }

     AccessLog port( int port) {

         this .port = port;

         return this ;

     }

     AccessLog method(CharSequence method) {

         this .method = Objects.requireNonNull(method, "method" );

         return this ;

     }

     AccessLog uri(CharSequence uri) {

         this .uri = Objects.requireNonNull(uri, "uri" );

         return this ;

     }

     AccessLog protocol(String protocol) {

         this .protocol = Objects.requireNonNull(protocol, "protocol" );

         return this ;

     }

     AccessLog status(CharSequence status) {

         this .status = Objects.requireNonNull(status, "status" );

         return this ;

     }

     AccessLog contentLength( long contentLength) {

         this .contentLength = contentLength;

         return this ;

     }

     AccessLog increaseContentLength( long contentLength) {

         if (chunked) {

             this .contentLength += contentLength;

         }

         return this ;

     }

     AccessLog chunked( boolean chunked) {

         this .chunked = chunked;

         return this ;

     }

     long duration() {

         return System.currentTimeMillis() - startTime;

     }

     void log() {

         if (log.isInfoEnabled()) {

             log.info(COMMON_LOG_FORMAT, address, user, zonedDateTime,

                     method, uri, protocol, status, (contentLength > - 1 ? contentLength : MISSING), port, duration());

         }

     }

}

package reactor.netty.http.server; 

import io.netty.buffer.ByteBuf;

import io.netty.buffer.ByteBufHolder;

import io.netty.channel.ChannelDuplexHandler;

import io.netty.channel.ChannelHandlerContext;

import io.netty.channel.ChannelPromise;

import io.netty.channel.socket.SocketChannel;

import io.netty.handler.codec.http.HttpRequest;

import io.netty.handler.codec.http.HttpResponse;

import io.netty.handler.codec.http.HttpResponseStatus;

import io.netty.handler.codec.http.HttpUtil;

import io.netty.handler.codec.http.LastHttpContent;

/**

  * @author Violeta Georgieva

  */

final class AccessLogHandler extends ChannelDuplexHandler {

     AccessLog accessLog = new AccessLog();

     @Override

     public void channelRead(ChannelHandlerContext ctx, Object msg) {

         if (msg instanceof HttpRequest) {

             final HttpRequest request = (HttpRequest) msg;

             final SocketChannel channel = (SocketChannel) ctx.channel();

             accessLog = new AccessLog()

                     .address(channel.remoteAddress().getHostString())

                     .port(channel.localAddress().getPort())

                     .method(request.method().name())

                     .uri(request.uri())

                     .protocol(request.protocolVersion().text());

         }

         ctx.fireChannelRead(msg);

     }

     @Override

     @SuppressWarnings ( "FutureReturnValueIgnored" )

     public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) {

         if (msg instanceof HttpResponse) {

             final HttpResponse response = (HttpResponse) msg;

             final HttpResponseStatus status = response.status();

             if (status.equals(HttpResponseStatus.CONTINUE)) {

                 //"FutureReturnValueIgnored" this is deliberate

                 ctx.write(msg, promise);

                 return ;

             }

             final boolean chunked = HttpUtil.isTransferEncodingChunked(response);

             accessLog.status(status.codeAsText())

                     .chunked(chunked);

             if (!chunked) {

                 accessLog.contentLength(HttpUtil.getContentLength(response, - 1 ));

             }

         }

         if (msg instanceof LastHttpContent) {

             accessLog.increaseContentLength(((LastHttpContent) msg).content().readableBytes());

             ctx.write(msg, promise.unvoid())

               .addListener(future -> {

                   if (future.isSuccess()) {

                       accessLog.log();

                   }

               });

             return ;

         }

         if (msg instanceof ByteBuf) {

             accessLog.increaseContentLength(((ByteBuf) msg).readableBytes());

         }

         if (msg instanceof ByteBufHolder) {

             accessLog.increaseContentLength(((ByteBufHolder) msg).content().readableBytes());

         }

         //"FutureReturnValueIgnored" this is deliberate

         ctx.write(msg, promise);

     }

}

< dependency >

     < groupId >org.springframework.boot</ groupId >

     < artifactId >spring-boot-starter-webflux</ artifactId >

</ dependency >

< dependency >

     < groupId >org.springframework.boot</ groupId >

     < artifactId >spring-boot-starter-web</ artifactId >

</ dependency >

< dependency >

     < groupId >org.springframework.cloud</ groupId >

     < artifactId >spring-cloud-starter-gateway</ artifactId >

</ dependency >