public class TestResponseMiddleware: OcelotMiddleware

    {

        private readonly OcelotRequestDelegate _next;

        public TestResponseMiddleware(OcelotRequestDelegate next,IOcelotLoggerFactory loggerFactory)

            : base(loggerFactory.CreateLogger<TestResponseMiddleware>())

        {

            _next = next;

        }

        public async Task Invoke(DownstreamContext context)

        {

            if (!context.IsError && context.HttpContext.Request.Method.ToUpper() != "OPTIONS")

            {

                //对返回结果进行加密

                //Logger.LogInformation("");

                if (context.HttpContext.Response != null && context.DownstreamResponse.Content.Headers.ContentLength > )

                {

                    var result= await context.DownstreamResponse.Content.ReadAsStringAsync();

                    using (var md5 = MD5.Create())

                    {

                        var md5Result = md5.ComputeHash(Encoding.ASCII.GetBytes(result));

                        var strResult = BitConverter.ToString(md5Result);

                        strResult = strResult.Replace("-", "");

                        context.HttpContext.Response.Body.Write(Encoding.UTF8.GetBytes(strResult));

                    }

                }

            }

            else

            {

                await _next.Invoke(context);

            }

        }

    }

    public static class TestServiceExtension

    {

        public static IOcelotPipelineBuilder UseTestResponseMiddleware(this IOcelotPipelineBuilder builder)

        {

            return builder.UseMiddleware<TestResponseMiddleware>();

        }

    }

public static class OcelotMiddlewareExtensions

    {

        public static async Task<IApplicationBuilder> UseOcelot(this IApplicationBuilder builder)

        {

            await builder.UseOcelot(new OcelotPipelineConfiguration());

            return builder;

        }

        private static IApplicationBuilder CreateOcelotPipeline(IApplicationBuilder builder, OcelotPipelineConfiguration pipelineConfiguration)

        {

            var pipelineBuilder = new OcelotPipelineBuilder(builder.ApplicationServices);

            pipelineBuilder.BuildOcelotPipeline(pipelineConfiguration);

            var firstDelegate = pipelineBuilder.Build();

            /*

            inject first delegate into first piece of asp.net middleware..maybe not like this

            then because we are updating the http context in ocelot it comes out correct for

            rest of asp.net..

            */

            builder.Properties["analysis.NextMiddlewareName"] = "TransitionToOcelotMiddleware";

            builder.Use(async (context, task) =>

            {

                var downstreamContext = new DownstreamContext(context);

                await firstDelegate.Invoke(downstreamContext);

            });

            return builder;

        }

 public static class OcelotPipelineExtensions

    {

        public static OcelotRequestDelegate BuildCustomeOcelotPipeline(this IOcelotPipelineBuilder builder,

            OcelotPipelineConfiguration pipelineConfiguration)

        {

            // This is registered to catch any global exceptions that are not handled

            // It also sets the Request Id if anything is set globally

            builder.UseExceptionHandlerMiddleware();

            // If the request is for websockets upgrade we fork into a different pipeline

            builder.MapWhen(context => context.HttpContext.WebSockets.IsWebSocketRequest,

                app =>

                {

                    app.UseDownstreamRouteFinderMiddleware();

                    app.UseDownstreamRequestInitialiser();

                    app.UseLoadBalancingMiddleware();

                    app.UseDownstreamUrlCreatorMiddleware();

                    app.UseWebSocketsProxyMiddleware();

                });

            // Allow the user to respond with absolutely anything they want.

            builder.UseIfNotNull(pipelineConfiguration.PreErrorResponderMiddleware);

            // This is registered first so it can catch any errors and issue an appropriate response

            builder.UseResponderMiddleware();

            // Then we get the downstream route information

            builder.UseDownstreamRouteFinderMiddleware();

            // This security module, IP whitelist blacklist, extended security mechanism

            builder.UseSecurityMiddleware();

            //Expand other branch pipes

            if (pipelineConfiguration.MapWhenOcelotPipeline != null)

            {

                foreach (var pipeline in pipelineConfiguration.MapWhenOcelotPipeline)

                {

                    builder.MapWhen(pipeline);

                }

            }

            // Now we have the ds route we can transform headers and stuff?

            builder.UseHttpHeadersTransformationMiddleware();

            // Initialises downstream request

            builder.UseDownstreamRequestInitialiser();

            // We check whether the request is ratelimit, and if there is no continue processing

            builder.UseRateLimiting();

            // This adds or updates the request id (initally we try and set this based on global config in the error handling middleware)

            // If anything was set at global level and we have a different setting at re route level the global stuff will be overwritten

            // This means you can get a scenario where you have a different request id from the first piece of middleware to the request id middleware.

            builder.UseRequestIdMiddleware();

            // Allow pre authentication logic. The idea being people might want to run something custom before what is built in.

            builder.UseIfNotNull(pipelineConfiguration.PreAuthenticationMiddleware);

            // Now we know where the client is going to go we can authenticate them.

            // We allow the ocelot middleware to be overriden by whatever the

            // user wants

            if (pipelineConfiguration.AuthenticationMiddleware == null)

            {

                builder.UseAuthenticationMiddleware();

            }

            else

            {

                builder.Use(pipelineConfiguration.AuthenticationMiddleware);

            }

            // The next thing we do is look at any claims transforms in case this is important for authorisation

            builder.UseClaimsToClaimsMiddleware();

            // Allow pre authorisation logic. The idea being people might want to run something custom before what is built in.

            builder.UseIfNotNull(pipelineConfiguration.PreAuthorisationMiddleware);

            // Now we have authenticated and done any claims transformation we

            // can authorise the request

            // We allow the ocelot middleware to be overriden by whatever the

            // user wants

            if (pipelineConfiguration.AuthorisationMiddleware == null)

            {

                builder.UseAuthorisationMiddleware();

            }

            else

            {

                builder.Use(pipelineConfiguration.AuthorisationMiddleware);

            }

            // Now we can run the claims to headers transformation middleware

            builder.UseClaimsToHeadersMiddleware();

            // Allow the user to implement their own query string manipulation logic

            builder.UseIfNotNull(pipelineConfiguration.PreQueryStringBuilderMiddleware);

            // Now we can run any claims to query string transformation middleware

            builder.UseClaimsToQueryStringMiddleware();

            // Get the load balancer for this request

            builder.UseLoadBalancingMiddleware();

            // This takes the downstream route we retrieved earlier and replaces any placeholders with the variables that should be used

            builder.UseDownstreamUrlCreatorMiddleware();

            // Not sure if this is the best place for this but we use the downstream url

            // as the basis for our cache key.

            builder.UseOutputCacheMiddleware();

            //We fire off the request and set the response on the scoped data repo

            builder.UseHttpRequesterMiddleware();

            //添加自定义测试中间件

         builder.UseTestResponseMiddleware();

            return builder.Build();

        }

        private static void UseIfNotNull(this IOcelotPipelineBuilder builder,

            Func<DownstreamContext, Func<Task>, Task> middleware)

        {

            if (middleware != null)

            {

                builder.Use(middleware);

            }

        }

    }