spring cloud 微服务之间添加自定义的header头

ゝ一世哀愁。 2021-11-26 22:22 471阅读 0赞

### spring cloud 微服务之间添加自定义的header头 ###

*  spring cloud 微服务之间添加自定义的header头
 *  创建注册中心
 *   *  创建生产者
     *  创建消费者
     *  验证结果

# spring cloud 微服务之间添加自定义的header头 #

在我们的微服务开发过程中，有时候我们在调用其他微服务的时候，我们希望把一些参数放在header中，而不是作为参数往下传，这样的场景我们该如何解决呢？

# 创建注册中心 #

首先我们使用IDEA创建一个空的项目，项目的名称为cloud-header-demo，接着在该项目底下创建我们的注册中心的module。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnpoZWZlbmc4OQ_size_16_color_FFFFFF_t_70]  
接着我们引入我们的eureka的依赖，pom.xml的代码如下：

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.6.RELEASE</version>
            <relativePath/> 
        </parent>
        <groupId>com.cloud.header</groupId>
        <artifactId>eureka-demo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>eureka-demo</name>
        <description>注册中心例子</description>
    
        <properties>
            <java.version>1.8</java.version>
            <spring-cloud.version>Greenwich.SR2</spring-cloud.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>
    
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>${spring-cloud.version}</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>

接着我们修改我们的配置文件application.yml修改完成以后代码如下：

spring:
      application:
        # 工程名字
        name: eureka-demo
    
    server:
      port: 2100
    
    eureka:
      client:
        #缓存清单的更新时间,默认是30秒
        registry-fetch-interval-seconds: 30
        service-url:
          # 注册中心的地址
          defaultZone: http://127.0.0.1:2100/eureka/
      server:
        # 默认情况下，如果Eureka Server在一定时间内没有接收到某个微服务实例的心跳，Eureka Server将会注销该实例（默认90秒）。
        # 但是当网络分区故障发生时，微服务与Eureka Server之间无法正常通信，
        # 以上行为可能变得非常危险了——因为微服务本身其实是健康的，此时本不应该注销这个微服务。
        # Eureka通过“自我保护模式”来解决这个问题——当Eureka Server节点在短时间内丢失过多客户端时（可能发生了网络分区故障），
        # 那么这个节点就会进入自我保护模式。一旦进入该模式，Eureka Server就会保护服务注册表中的信息，不再删除服务注册表中的数据（也就是不会注销任何微服务）。
        # 当网络故障恢复后，该Eureka Server节点会自动退出自我保护模式。
        enable-self-preservation: true
        #节点间的读数据连接超时时间单位毫秒
        peer-node-read-timeout-ms: 1000

最后在我们的启动类上添加以下的注解

@SpringBootApplication
    @EnableEurekaServer
    public class EurekaDemoApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(EurekaDemoApplication.class, args);
        }
    
    }

## 创建生产者 ##

接着我们在cloud-header-demo底下创建我们的produce-demo的生产者项目。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnpoZWZlbmc4OQ_size_16_color_FFFFFF_t_70 1]  
接着我们引入我们的eureka的依赖，pom.xml的代码如下：

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.6.RELEASE</version>
            <relativePath/> 
        </parent>
        <groupId>com.cloud.header</groupId>
        <artifactId>produce-demo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>produce-demo</name>
        <description>生产者的demo例子</description>
    
        <properties>
            <java.version>1.8</java.version>
            <spring-cloud.version>Greenwich.SR2</spring-cloud.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>
    
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>${spring-cloud.version}</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>

接着我们修改我们的配置文件application.yml修改完成以后代码如下：

server:
      port: 11100
    
    
    spring:
      servlet:
        multipart:
          max-file-size: 100MB
          max-request-size: 500MB
      application:
        name: produce-demo
    
    
    eureka:
      client:
        service-url:
          defaultZone: http://127.0.0.1:2100/eureka/
      instance:
        instance-id: ${spring.cloud.client.ip-address}:${server.port}

最后我们编写一个最简单的controller方法来获取我们消费者传送过来的自定义的header

@RestController
    public class HeaderController {
    
        @GetMapping("getConsumerHeader")
        public String getConsumerHeader(){
            HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
            String consumerHeader = request.getHeader("consumerHeader");
            if(consumerHeader!=null && !"".equals(consumerHeader)){
                System.out.println("----" + URLDecoder.decode(consumerHeader,"GBK"));
            }else{
                System.out.println("----" +  consumerHeader);
            }
            return "success";
        }
    
    }

接着我们启动我们的注册中心和生产者，我们使用访问：[http://127.0.0.1:11100/getConsumerHeader][http_127.0.0.1_11100_getConsumerHeader] 这时候我们会看到我们的请求头里面并没有我们自定义的头部信息：  
![在这里插入图片描述][20190723100459919.png]

## 创建消费者 ##

此处就是我们本章的核心部分了，我们该如何实现在调用其他生产者的时候把我们自定义的header传给下一个生产者呢，首先在cloud-header-demo底下创建我们的consumer-demo的消费者项目。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnpoZWZlbmc4OQ_size_16_color_FFFFFF_t_70 2]  
接着我们引入我们的eureka和feign的依赖，pom.xml的代码如下：

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.6.RELEASE</version>
            <relativePath/> 
        </parent>
        <groupId>com.cloud.header</groupId>
        <artifactId>consumer-demo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>consumer-demo</name>
        <description>这是一个消费者的例子</description>
    
        <properties>
            <java.version>1.8</java.version>
            <spring-cloud.version>Greenwich.SR2</spring-cloud.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-openfeign</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>
    
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>${spring-cloud.version}</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    </project>

接着我们修改我们的配置文件application.yml修改完成以后代码如下：

server:
      port: 12100
    
    
    spring:
      servlet:
        multipart:
          # 单个文件上传的最大值
          max-file-size: 100MB
          # 多个文件上传的总的最大值
          max-request-size: 500MB
      cloud:
        loadbalancer:
          retry:
            # 该参数用来开启重试机制，它默认是关闭的。
            enabled: true
      application:
        name: user-demo
    
    
    eureka:
      client:
        service-url:
          # 注册中心地址
          defaultZone: http://127.0.0.1:2100/eureka/
      instance:
        # 配置在eureka上status栏显示的信息
        instance-id: ${spring.cloud.client.ip-address}:${server.port}
    
    feign:
      hystrix:
        # 关闭hystrix默认就是关闭，若是设置为true的话一定要记得配置超时的时间，要不到时候可能会导致超时失败，因此最好将此处的熔断机制给去除
        enabled: false
      compression:
        # 开启GZIP的压缩功能以减少HTTP通信的消耗。
        request:
          enabled: true
          # 以下的请求的类型且请求数据的大小超过2048的将为会压缩传输。
          min-request-size: 2048
          mime-types: text/xml,application/xml,application/json
        response:
          enabled: true
    
    ribbon:
      # #请求连接的超时时间。
      ConnectTimeout: 6000
      # 请求处理的超时时间，该超时时间的影响层级大于全局的超时时间,设置了该时间那么，如果调用生产端的时候超过1秒那么就直接调用重试规则，因此若重试次数和切换次数都是为1那么，响应的时间不超过4秒
      ReadTimeout: 60000
      # 对所有操作请求都进行重试。
      OkToRetryOnAllOperations: true
      # 以下重试实现响应EUREKA-PRODUCER的最大次数是 ：（1 + MaxAutoRetries）* （1 + MaxAutoRetriesNextServer）
      # 假设 MaxAutoRetries = 2 ，MaxAutoRetriesNextServer = 4 ，那么最大的重试次数为15次
      # 切换实例的重试次数。
      MaxAutoRetriesNextServer: 1
      # 对当前实例的重试次数。
      MaxAutoRetries: 1

接着在我们的启动类上添加以下的注解

@SpringBootApplication
    @EnableFeignClients
    @EnableDiscoveryClient
    public class ConsumerDemoApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(ConsumerDemoApplication.class, args);
        }
    
    }

最后我们开始编写我们的相关的实现，首先我们创建一个config包，在该包底下创建一个FeignConfiguration的配置代码如下：

package com.cloud.header.consumer.demo.config;
    
    import feign.Logger;
    import feign.RequestInterceptor;
    import feign.RequestTemplate;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.http.HttpServletRequest;
    import java.util.Enumeration;
    
    /**
     * 类描述：feign在调用生产者的时候回把header传过去,若不配置则不传送request头
     * @author linzf
     */
    @Configuration
    public class FeignConfiguration {
    
        @Bean
        Logger.Level feignLoggerLevel() {
            // • NONE: 不记录任何信息。
            // • BASIC: 仅记录请求方法、URL以及响应状态码和执行时间。
            // • HEADERS: 除了记录BASIC级别的信息之外， 还会记录请求和响应的头信息。
            // • FULL: 记录所有请求与响应的明细， 包括头信息、 请求体、 元数据等。
            return Logger.Level.FULL;
        }
    
        @Bean
        public RequestInterceptor requestInterceptor() {
            return new RequestInterceptor() {
                @Override
                public void apply(RequestTemplate template) {
                    ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder
                            .getRequestAttributes();
                    HttpServletRequest request = attributes.getRequest();
                    Enumeration<String> headerNames = request.getHeaderNames();
                    if (headerNames != null) {
                        while (headerNames.hasMoreElements()) {
                            String name = headerNames.nextElement();
                            String values = request.getHeader(name);
                            template.header(name, values);
                        }
                    }
                }
            };
        }
    }

接着创建一个feign包，在底下创建我们的feign的调用HeaderFeign，代码如下：

package com.cloud.header.consumer.demo.feign;
    
    import org.springframework.cloud.openfeign.FeignClient;
    import org.springframework.web.bind.annotation.GetMapping;
    
    /**
     * @author linzf
     * @since 2019/7/23
     * 类描述：
     */
    @FeignClient(value="PRODUCE-DEMO")
    public interface HeaderFeign {
    
        /**
         * 功能描述：实现调用生产者的方法
         * @return 返回调用结果
         */
        @GetMapping("getConsumerHeader")
        String getConsumerHeader();
    
    }

接着创建一个controller包，在底下创建HeaderController，代码实现如下：

package com.cloud.header.consumer.demo.controller;
    
    import com.cloud.header.consumer.demo.feign.HeaderFeign;
    import org.apache.tomcat.util.http.MimeHeaders;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.http.HttpServletRequest;
    import java.lang.reflect.Field;
    
    /**
     * @author linzf
     * @since 2019/7/23
     * 类描述：
     */
    @RestController
    public class HeaderController {
    
        @Autowired
        private HeaderFeign headerFeign;
    
        @GetMapping("getConsumerHeader")
        public String getConsumerHeader(){
            HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
            // 中文在请求头中会变为乱码，因此要进行转化
            reflectSetHeader(request,"consumerHeader", URLEncoder.encode("我是从消费者传过来的请求头", "GBK"));
            return headerFeign.getConsumerHeader();
        }
    
        /**
         * 功能描述：实现往请求里加入我们的header
         * @param request request对象
         * @param key header的key
         * @param value header的值
         */
        private void reflectSetHeader(HttpServletRequest request, String key, String value){
            Class<? extends HttpServletRequest> requestClass = request.getClass();
            try {
                Field request1 = requestClass.getDeclaredField("request");
                request1.setAccessible(true);
                Object o = request1.get(request);
                Field coyoteRequest = o.getClass().getDeclaredField("coyoteRequest");
                coyoteRequest.setAccessible(true);
                Object o1 = coyoteRequest.get(o);
                Field headers = o1.getClass().getDeclaredField("headers");
                headers.setAccessible(true);
                MimeHeaders o2 = (MimeHeaders)headers.get(o1);
                o2.removeHeader(key);
                o2.addValue(key).setString(value);
            } catch (Exception e) {
    
            }
        }
    }

## 验证结果 ##

最后我们将我们的注册中心，消费者和生产者全部启动起来，然后我们在浏览器访问以下的网址：[http://127.0.0.1:12100/getConsumerHeader][http_127.0.0.1_12100_getConsumerHeader]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnpoZWZlbmc4OQ_size_16_color_FFFFFF_t_70 3]  
这时候我们的生产者就获取了消费者传过来的请求头的信息了，到此为止我们就完成了我们的微服务之间自定义请求头的传送了，到此为止的代码，大家可以直接去github上下载运行，github上的地址：[https://github.com/lazyboyl/cloud-header-demo][https_github.com_lazyboyl_cloud-header-demo]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnpoZWZlbmc4OQ_size_16_color_FFFFFF_t_70]: /images/20211126/db95dc34ea164c228b8a6bb6a6024730.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnpoZWZlbmc4OQ_size_16_color_FFFFFF_t_70 1]: /images/20211126/4a210e338b3147e6a62ac0664fee1718.png
[http_127.0.0.1_11100_getConsumerHeader]: http://127.0.0.1:11100/getConsumerHeader
[20190723100459919.png]: /images/20211126/0cd245c125c44c81897660297c9ed73a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnpoZWZlbmc4OQ_size_16_color_FFFFFF_t_70 2]: /images/20211126/76e02f7eb14a4cac843dbcbbf4d67a28.png
[http_127.0.0.1_12100_getConsumerHeader]: http://127.0.0.1:12100/getConsumerHeader
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnpoZWZlbmc4OQ_size_16_color_FFFFFF_t_70 3]: /images/20211126/48222859c0944a5eba8cb093ab79971c.png
[https_github.com_lazyboyl_cloud-header-demo]: https://github.com/lazyboyl/cloud-header-demo