SpringCloud Finchley Gateway 缓存请求Body和Form表单的实现

import lombok.getter;

import lombok.setter;

import lombok.tostring;

import org.springframework.util.linkedmultivaluemap;

import org.springframework.util.multivaluemap;

@getter

@setter

@tostring

public class gatewaycontext {

   public static final string cache_gateway_context = "cachegatewaycontext" ;

   /**

    * cache json body

    */

   private string cachebody;

   /**

    * cache formdata

    */

   private multivaluemap<string, string> formdata;

   /**

    * cache reqeust path

    */

   private string path;

}

import com.choice.cloud.architect.usergate.option.filterorderenum;

import com.choice.cloud.architect.usergate.support.gatewaycontext;

import io.netty.buffer.bytebufallocator;

import lombok.extern.slf4j.slf4j;

import org.springframework.cloud.gateway.filter.gatewayfilterchain;

import org.springframework.cloud.gateway.filter.globalfilter;

import org.springframework.core.ordered;

import org.springframework.core.io.bytearrayresource;

import org.springframework.core.io.buffer.databuffer;

import org.springframework.core.io.buffer.databufferutils;

import org.springframework.core.io.buffer.nettydatabufferfactory;

import org.springframework.http.httpheaders;

import org.springframework.http.mediatype;

import org.springframework.http.codec.httpmessagereader;

import org.springframework.http.server.reactive.serverhttprequest;

import org.springframework.http.server.reactive.serverhttprequestdecorator;

import org.springframework.util.multivaluemap;

import org.springframework.web.reactive.function.server.handlerstrategies;

import org.springframework.web.reactive.function.server.serverrequest;

import org.springframework.web.server.serverwebexchange;

import reactor.core.publisher.flux;

import reactor.core.publisher.mono;

import java.io.unsupportedencodingexception;

import java.net.urlencoder;

import java.nio.charset.charset;

import java.nio.charset.standardcharsets;

import java.util.list;

import java.util.map;

@slf4j

public class gatewaycontextfilter implements globalfilter, ordered {

   /**

    * default httpmessagereader

    */

   private static final list<httpmessagereader<?>> messagereaders = handlerstrategies.withdefaults().messagereaders();

   @override

   public mono< void > filter(serverwebexchange exchange, gatewayfilterchain chain) {

     /**

      * save request path and serviceid into gateway context

      */

     serverhttprequest request = exchange.getrequest();

     string path = request.getpath().pathwithinapplication().value();

     gatewaycontext gatewaycontext = new gatewaycontext();

     gatewaycontext.getallrequestdata().addall(request.getqueryparams());

     gatewaycontext.setpath(path);

     /**

      * save gateway context into exchange

      */

     exchange.getattributes().put(gatewaycontext.cache_gateway_context,gatewaycontext);

     httpheaders headers = request.getheaders();

     mediatype contenttype = headers.getcontenttype();

     long contentlength = headers.getcontentlength();

     if (contentlength> 0 ){

       if (mediatype.application_json.equals(contenttype) || mediatype.application_json_utf8.equals(contenttype)){

         return readbody(exchange, chain,gatewaycontext);

       }

       if (mediatype.application_form_urlencoded.equals(contenttype)){

         return readformdata(exchange, chain,gatewaycontext);

       }

     }

     log.debug( "[gatewaycontext]contenttype:{},gateway context is set with {}" ,contenttype, gatewaycontext);

     return chain.filter(exchange);

   }

   @override

   public int getorder() {

     return integer.min_value;

   }

   /**

    * readformdata

    * @param exchange

    * @param chain

    * @return

    */

   private mono< void > readformdata(serverwebexchange exchange,gatewayfilterchain chain,gatewaycontext gatewaycontext){

     httpheaders headers = exchange.getrequest().getheaders();

     return exchange.getformdata()

         .doonnext(multivaluemap -> {

           gatewaycontext.setformdata(multivaluemap);

           log.debug( "[gatewaycontext]read formdata:{}" ,multivaluemap);

         })

         .then(mono.defer(() -> {

           charset charset = headers.getcontenttype().getcharset();

           charset = charset == null ? standardcharsets.utf_8:charset;

           string charsetname = charset.name();

           multivaluemap<string, string> formdata = gatewaycontext.getformdata();

           /**

            * formdata is empty just return

            */

           if ( null == formdata || formdata.isempty()){

             return chain.filter(exchange);

           }

           stringbuilder formdatabodybuilder = new stringbuilder();

           string entrykey;

           list<string> entryvalue;

           try {

             /**

              * remove system param ,repackage form data

              */

             for (map.entry<string, list<string>> entry : formdata.entryset()) {

               entrykey = entry.getkey();

               entryvalue = entry.getvalue();

               if (entryvalue.size() > 1 ) {

                 for (string value : entryvalue){

                   formdatabodybuilder.append(entrykey).append( "=" ).append(urlencoder.encode(value, charsetname)).append( "&" );

                 }

               } else {

                 formdatabodybuilder.append(entrykey).append( "=" ).append(urlencoder.encode(entryvalue.get( 0 ), charsetname)).append( "&" );

               }

             }

           } catch (unsupportedencodingexception e){

             //ignore urlencode exception

           }

           /**

            * substring with the last char '&'

            */

           string formdatabodystring = "" ;

           if (formdatabodybuilder.length()> 0 ){

             formdatabodystring = formdatabodybuilder.substring( 0 , formdatabodybuilder.length() - 1 );

           }

           /**

            * get data bytes

            */

           byte [] bodybytes = formdatabodystring.getbytes(charset);

           int contentlength = bodybytes.length;

           serverhttprequestdecorator decorator = new serverhttprequestdecorator(

               exchange.getrequest()) {

             /**

              * change content-length

              * @return

              */

             @override

             public httpheaders getheaders() {

               httpheaders httpheaders = new httpheaders();

               httpheaders.putall( super .getheaders());

               if (contentlength > 0 ) {

                 httpheaders.setcontentlength(contentlength);

               } else {

                 httpheaders.set(httpheaders.transfer_encoding, "chunked" );

               }

               return httpheaders;

             }

             /**

              * read bytes to flux<databuffer>

              * @return

              */

             @override

             public flux<databuffer> getbody() {

               return databufferutils.read( new bytearrayresource(bodybytes), new nettydatabufferfactory(bytebufallocator. default ),contentlength);

             }

           };

           serverwebexchange mutateexchange = exchange.mutate().request(decorator).build();

           log.debug( "[gatewaycontext]rewrite form data :{}" ,formdatabodystring);

           return chain.filter(mutateexchange);

         }));

   }

   /**

    * readjsonbody

    * @param exchange

    * @param chain

    * @return

    */

   private mono< void > readbody(serverwebexchange exchange,gatewayfilterchain chain,gatewaycontext gatewaycontext){

     /**

      * join the body

      */

     return databufferutils.join(exchange.getrequest().getbody())

         .flatmap(databuffer -> {

           /**

            * read the body flux<databuffer>

            */

           databufferutils.retain(databuffer);

           flux<databuffer> cachedflux = flux.defer(() -> flux.just(databuffer.slice( 0 , databuffer.readablebytecount())));

           /**

            * repackage serverhttprequest

            */

           serverhttprequest mutatedrequest = new serverhttprequestdecorator(exchange.getrequest()) {

             @override

             public flux<databuffer> getbody() {

               return cachedflux;

             }

           };

           /**

            * mutate exchage with new serverhttprequest

            */

           serverwebexchange mutatedexchange = exchange.mutate().request(mutatedrequest).build();

           /**

            * read body string with default messagereaders

            */

           return serverrequest.create(mutatedexchange, messagereaders)

               .bodytomono(string. class )

               .doonnext(objectvalue -> {

                 gatewaycontext.setcachebody(objectvalue);

                 log.debug( "[gatewaycontext]read jsonbody:{}" ,objectvalue);

               }).then(chain.filter(mutatedexchange));

         });

   }

}