public static VirtualHost getVirtualHost(String name, String clusterName) {

    RouteAction routeAction = RouteAction.newBuilder()

            .setCluster(clusterName)

            .build();

    HeaderMatcher headerMatcher = HeaderMatcher.newBuilder()

            .setName("UID")

            .setExactMatch("5784024476")

            .build();

    RouteMatch routeMatch = RouteMatch.newBuilder()

            .setGrpc(GrpcRouteMatchOptions.newBuilder()) // 确定只匹配Grpc Match

            .setPrefix("/")

            .addHeaders(headerMatcher)

            .build();

    Route route = Route.newBuilder()

            .setMatch(routeMatch)

            .setRoute(routeAction)

            .build();

    VirtualHost virtualHost = VirtualHost.newBuilder()

            .setName(name)

            .addDomains("*")

            .addRoutes(route)

            .build();

    return virtualHost;

}

Endpoint endpoint = ClusterSnapshot.toEndpoint(host + ":" + port);

ClusterLoadAssignment clusterLoadAssignment = simpleCache.getSnapshot(0).endpoints().resources().get(CLUSTER_NAME);

LocalityLbEndpoints localityLbEndpoints = LocalityLbEndpoints.newBuilder()

        .addLbEndpoints(LbEndpoint.newBuilder().setEndpoint(endpoint).build())

        .build();

List<ClusterLoadAssignment> assignments = ImmutableList.<ClusterLoadAssignment>builder()

        .add(clusterLoadAssignment.toBuilder().addEndpoints(localityLbEndpoints).build())

        .build();

Cluster.EdsClusterConfig edsClusterConfig = ClusterSnapshot.getEdsClusterConfig(CLUSTER_NAME, DISCOVERY_CLUSTER_NAME);

List<Cluster> clusters = ImmutableList.<Cluster>builder()

        .add(ClusterSnapshot.getCluster(CLUSTER_NAME, edsClusterConfig))

        .build();

Snapshot snapshot = Snapshot.create(

        clusters,

        assignments,

        ImmutableList.of(),

        ImmutableList.of(),

        ImmutableList.of(),

        version);

simpleCache.setSnapshot(0, snapshot);

public class ClientHeaderInterceptor implements ClientInterceptor {

    private static final Logger logger = Logger.getLogger(ClientHeaderInterceptor.class.getName());

    Metadata.Key<String> cookie = Metadata.Key.of("cookie", Metadata.ASCII_STRING_MARSHALLER);

    @Override

    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method,

                                                               CallOptions callOptions, Channel next) {

        return new ForwardingClientCall.SimpleForwardingClientCall<ReqT, RespT>(next.newCall(method, callOptions)) {

            @Override

            public void start(Listener<RespT> responseListener, Metadata headers) {

                //此处为你登录后获得的cookie的值

                headers.put(cookie, "U=6371181803");

                super.start(new ForwardingClientCallListener.SimpleForwardingClientCallListener<RespT>(responseListener) {

                    @Override

                    public void onHeaders(Metadata headers) {

                        /**

                         * if you don't need receive header from server, you can

                         * use {@link io.grpc.stub.MetadataUtils#attachHeaders}

                         * directly to send header

                         */

                        logger.info("header received from server:" + headers);

                        super.onHeaders(headers);

                    }

                }, headers);

            }

        };

    }

}

static final Metadata.Key<String> COOKIE = Metadata.Key.of("cookie", Metadata.ASCII_STRING_MARSHALLER);

private final ManagedChannel originalChannel;

private final XUserDeviceServiceGrpc.XUserDeviceServiceBlockingStub blockingStub;

private final XUserDeviceServiceGrpc.XUserDeviceServiceBlockingStub headerBlockingStub;

public XueqiuPushUserClientTest(String host, int port) {

    originalChannel = ManagedChannelBuilder.forAddress(host, port).usePlaintext(true).build();

    //将ClientHeaderInterceptor和原有的channel结合，生成包含拦截器的channel

    Channel channel = ClientInterceptors.intercept(originalChannel, new ClientHeaderInterceptor());

    blockingStub = XUserDeviceServiceGrpc.newBlockingStub(channel);

    //如果只需要在客户端传送header，而不需要接受服务端的header可以简单调用MetadataUtils.attachHeaders注册meta数据而不用定义Interceptor

    XUserDeviceServiceGrpc.XUserDeviceServiceBlockingStub stub = XUserDeviceServiceGrpc.newBlockingStub(originalChannel);

    Metadata meta = new Metadata();

    meta.put(COOKIE, "U=6371181803");

    headerBlockingStub = MetadataUtils.attachHeaders(stub, meta);

}

@Override

public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

    //1. 获取请求

    ServerHttpRequest request = exchange.getRequest();

    //2. 则获取响应

    ServerHttpResponse response = exchange.getResponse();

    //3. 如果是登录请求则放行

    if (request.getURI().getPath().contains("/login")) {

        return chain.filter(exchange);

    }

    //4. 获取请求头

    HttpHeaders headers = request.getHeaders();

    //5. 请求头中获取令牌

    String token = headers.getFirst(AUTHORIZE_TOKEN);

    //6. 判断请求头中是否有令牌

    if (StringUtils.isEmpty(token)) {

        //7. 响应中放入返回的状态吗, 没有权限访问

        response.setStatusCode(HttpStatus.UNAUTHORIZED);

        //8. 返回

        return response.setComplete();

    }

    //9. 如果请求头中有令牌则解析令牌

    try {

        JwtUtil.parseJWT(token);

    } catch (Exception e) {

        e.printStackTrace();

        //10. 解析jwt令牌出错, 说明令牌过期或者伪造等不合法情况出现

        response.setStatusCode(HttpStatus.UNAUTHORIZED);

        //11. 返回

        return response.setComplete();

    }

    //12. 放行

    return chain.filter(exchange);

}