如何验证Netflix Zuul是否正确转发请求？求Spring Boot+Zuul 1.x代码示例

Got it, let's break down how to confirm where Zuul 1.x is forwarding your requests—without having to spin up all those downstream services. The key is leveraging Zuul's RequestContext for internal routing details, plus using mock tests to validate the logic without real services running.

1. Capture Routing Details with a Custom Zuul Filter #

Zuul stores all routing metadata in its RequestContext, including the target service ID, route host, and rewritten path. You can create a simple filter to log or expose this info:

import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
public class RouteTrackingFilter extends ZuulFilter {

    private static final Logger logger = LoggerFactory.getLogger(RouteTrackingFilter.class);

    @Override
    public String filterType() {
        // Use "pre" to capture routing details before the request is forwarded
        return "pre";
    }

    @Override
    public int filterOrder() {
        // Set order to ensure it runs after Zuul's core routing filters but before forwarding
        return 10;
    }

    @Override
    public boolean shouldFilter() {
        // Enable for all requests; adjust if you need to target specific paths
        return true;
    }

    @Override
    public Object run() {
        RequestContext ctx = RequestContext.getCurrentContext();
        
        // Get target service ID (for service-based routing, e.g., with Eureka)
        String targetServiceId = (String) ctx.get("serviceId");
        // Get target host URL (for URL-based routing)
        String targetHost = ctx.getRouteHost() != null ? ctx.getRouteHost().toString() : null;
        // Get the rewritten path Zuul uses internally
        String forwardedPath = (String) ctx.get("requestURI");

        logger.info("Zuul routing details: Service ID={}, Target Host={}, Forwarded Path={}",
                    targetServiceId, targetHost, forwardedPath);

        // Optional: Store this info in the context for use elsewhere in your app
        ctx.set("zuulRoutingMetadata", String.format("Service: %s | Path: %s", targetServiceId, forwardedPath));
        
        return null;
    }
}

Once this filter is active, you'll see clear logs showing exactly where Zuul intends to send each request—no need to check downstream services.

2. Mock Test Routing Logic (No Downstream Services Required) #

To validate your routing rules without running actual services, use Spring Boot Test with MockMvc to simulate requests and inspect the RequestContext:

Step 1: Ensure Your Zuul Route Config is Set Up #

First, confirm your application.yml has the routing rules you want to test (example below):

zuul:
  routes:
    user-service:
      path: /api/users/**
      serviceId: user-service
      stripPrefix: true # Removes the /api prefix when forwarding to user-service
    order-service:
      path: /api/orders/**
      url: http://localhost:8082 # URL-based routing example

Step 2: Write the Mock Test #

import com.netflix.zuul.context.RequestContext;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;

import static org.junit.jupiter.api.Assertions.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest
@AutoConfigureMockMvc
public class ZuulRouteValidationTest {

    @Autowired
    private MockMvc mockMvc;

    @BeforeEach
    void resetRequestContext() {
        // Clear the context before each test to avoid cross-test contamination
        RequestContext.testSetCurrentContext(new RequestContext());
    }

    @Test
    void testUserServiceRouting() throws Exception {
        // Simulate a request to your Zuul endpoint
        MvcResult result = mockMvc.perform(get("/api/users/456"))
                .andExpect(status().isServiceUnavailable()) // Expected since no real service is running
                .andReturn();

        // Extract routing details from Zuul's context
        RequestContext ctx = RequestContext.getCurrentContext();
        String serviceId = (String) ctx.get("serviceId");
        String forwardedPath = (String) ctx.get("requestURI");

        // Verify the routing matches your config
        assertEquals("user-service", serviceId);
        assertEquals("/users/456", forwardedPath); // Matches stripPrefix: true behavior
    }

    @Test
    void testOrderServiceUrlRouting() throws Exception {
        mockMvc.perform(get("/api/orders/789"))
                .andExpect(status().isServiceUnavailable())
                .andReturn();

        RequestContext ctx = RequestContext.getCurrentContext();
        String targetHost = ctx.getRouteHost().toString();
        String forwardedPath = (String) ctx.get("requestURI");

        assertEquals("http://localhost:8082", targetHost);
        assertEquals("/orders/789", forwardedPath);
    }
}

This test will pass as long as Zuul's routing logic is correct—even if the downstream user-service or order-service isn't running. We're only validating that Zuul is applying the routing rules you configured, not that the services themselves work.

Key Notes #

• Use serviceId for service-discovery-based routing (e.g., with Eureka).
• Use routeHost for direct URL-based routing.
• The requestURI in RequestContext is the rewritten path Zuul uses internally, not the original browser request URL.

内容的提问来源于stack exchange，提问作者Shekhar Patil