基于Feign的微服务文件与复杂参数传输

Bertha 。 2022-08-29 13:45 17阅读 0赞

# 1、问题背景 #

随着微服务普及程度的提升，IT人员面对的问题也随之复杂。原先微服务之间只进行简单参数的传输，而随着文件服务的微量化，微服务之间也需要进行文件传输，因此本文旨在解决以下两个问题：

(1) 实现服务之间的文件传输；

(2) 实现服务之间复杂参数的传输(例如：实体中含有文件类型参数)；

# 2、结构介绍 #

![20210720173530293.png][]

本文主要使用上图红色框中的四个组件：

eureka-server：服务注册中心

eureka-common：公共类与工具存放

eureka-client：服务提供者

eureka-feign-client：服务消费者

# 3、系统搭建 #

## 3.1 eureka-server ##

该组件主要作用是服务注册与发现

依赖部分：

<dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-eureka-server</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>

配置信息：

---
    server:
      port: 8761
    eureka:
      client:
        # 防止eureka-server自己注册自己
        register-with-eureka: false
        fetch-registry: false
        service-url:
          defaultZone: http://localhost:8761/eureka/

启动项：

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

本组件比较简单，各位看官按图操作即可。

## 3.2 eureka-common ##

个人习惯与将多个组件之间可能会共用的类、工具抽离为一个公共组件，便于管理与维护。

依赖部分：

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <version>1.5.3.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.70</version>
            </dependency>

复杂参数实体：

@FileFeignAnnotation
    public class UserInfo implements Serializable {
    
        private String name;
    
        private String sex;
    
        @JSONField(serialize = false)
        private MultipartFile file;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public MultipartFile getFile() {
            return file;
        }
    
        public void setFile(MultipartFile file) {
            this.file = file;
        }
    }

自定义注解：

@Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface FileFeignAnnotation {
        String value() default "";
    }

此处自定义一个注解是为了后面区分普通参数与复杂参数。通过注解去控制，避免太多冗余代码。

## 3.3 eureka-client ##

此组件为服务提供者

依赖部分：

配置信息：

spring:
      application:
        name: eureka-client
    eureka:
      client:
        service-url:
          # 服务注册地址
          defaultZone: http://localhost:8761/eureka/
    server:
      port: 8763

接口信息：

// 用于测试复杂参数
        @PostMapping("/test")
        public String test(UserInfo info) {
            LOGGER.info(JSON.toJSON(info).toString());
            return "Hello World!";
        }
        
        // 用于测试文件传输
        @PostMapping("/file")
        public String file(@RequestPart(value = "file") MultipartFile file) {
            return file.getOriginalFilename();
        }

接口测试结果：

文件传输：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21fc29waGlh_size_16_color_FFFFFF_t_70][]

复杂参数：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21fc29waGlh_size_16_color_FFFFFF_t_70 1][]

由以上测试结果可知：服务提供者接口测试正常。

## 3.4 eureka-feign-client ##

依赖部分：

<dependency>
                <groupId>com.forezp</groupId>
                <artifactId>eureka-common</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-eureka</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-feign</artifactId>
                <version>1.3.1.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-hystrix</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
            </dependency>
    
            <dependency>
                <groupId>io.github.openfeign.form</groupId>
                <artifactId>feign-form</artifactId>
                <version>3.0.3</version>
            </dependency>
    
            <dependency>
                <groupId>io.github.openfeign.form</groupId>
                <artifactId>feign-form-spring</artifactId>
                <version>3.0.3</version>
            </dependency>

配置信息：

spring:
      application:
        name: eureka-feign-client
    server:
      port: 8766
    eureka:
      client:
        service-url:
          defaultZone: http://localhost:8761/eureka/
    
    feign:
      hystrix:
        enabled: true

### 3.4.1 问题一：文件传输 ###

**feign不支持文件传输的原因是在对Form参数进行编码时，没有默认的HttpMessageConverters对Form格式的参数进行编码转换，需要自己注入配置**。

接口定义：

@FeignClient(value = "eureka-client")
    public interface UploadFeign {
    
        @RequestMapping(value = "/load/file", method = RequestMethod.POST, consumes = MediaType.MULTIPART_FORM_DATA_VALUE
                , produces = {MediaType.APPLICATION_JSON_VALUE})
        String upload(@RequestPart("file") MultipartFile file);
    
    }

在接口定义中声明了以下信息：

@FeignClient: 声明了服务提供者的服务名

@RequestMapping：声明了接口信息与请求headers

@RequestPart：声明了文件参数的接收体

引入配置，声明编码转换：

@Configuration
    public class MultipartSupportConfig {
        @Autowired
        private ObjectFactory<HttpMessageConverters> messageConverters;
    
        /**
         * override a new FormEncoder to match complex param
         * param include properties and MultipartFile
         * @return
         */
        @Bean
        Encoder feignFormEncoder() {
            return new SpringFormEncoder(new SpringEncoder(messageConverters))
        }
    
    }

测试结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21fc29waGlh_size_16_color_FFFFFF_t_70 2][]

### 3.4.2 源码分析 ###

编码过程中，底层源码主要涉及下图代码：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21fc29waGlh_size_16_color_FFFFFF_t_70 3][]

SpringFormEncoder:

public void encode (Object object, Type bodyType, RequestTemplate template) throws EncodeException {
        if (!bodyType.equals(MultipartFile.class)) {
          super.encode(object, bodyType, template);
          return;
        }
    
        val file = (MultipartFile) object;
        val data = singletonMap(file.getName(), object);
        super.encode(data, MAP_STRING_WILDCARD, template);
      }

在SpringFormEncoder中根据请求参数的type，选择不同的处理方式：

(1) 参数类型不为MultipartFile(文件格式)，调用父类FormEncoder.encode()方法，参数不处理

(2) 参数类型为MultipartFile时，参数转换为Map，type设置为MAP\_STRING\_WILDCARD

FormEncoder：

public void encode(Object object, Type bodyType, RequestTemplate template) throws EncodeException {
            String contentTypeValue = this.getContentTypeValue(template.headers());
            ContentType contentType = ContentType.of(contentTypeValue);
            if (MAP_STRING_WILDCARD.equals(bodyType) && this.processors.containsKey(contentType)) {
                Charset charset = this.getCharset(contentTypeValue);
                Map data = (Map)object;
    
                try {
                    ((ContentProcessor)this.processors.get(contentType)).process(template, charset, data);
                } catch (Exception var9) {
                    throw new EncodeException(var9.getMessage());
                }
            } else {
                this.delegate.encode(object, bodyType, template);
            }
        }

根据SpringFormEncoder中传值bodyType的区别，决定不同的处理逻辑：

(1) MAP\_STRING\_WILDCARD类型时，调用MultipartFormContentProcessor.process()方法进行编码，包括：参数封装、头部设置，请求体设置等。

public void process(RequestTemplate template, Charset charset, Map<String, Object> data) throws Exception {
            String boundary = Long.toHexString(System.currentTimeMillis());
            Output output = new Output(charset);
            Iterator var6 = data.entrySet().iterator();
    
            while(var6.hasNext()) {
                Entry<String, Object> entry = (Entry)var6.next();
                Writer writer = this.findApplicableWriter(entry.getValue());
                writer.write(output, boundary, (String)entry.getKey(), entry.getValue());
            }
    
            output.write("--").write(boundary).write("--").write("\r\n");
            String contentTypeHeaderValue = this.getSupportedContentType().getHeader() + "; charset=" + charset.name() + "; boundary=" + boundary;
            template.header("Content-Type", new String[]{contentTypeHeaderValue});
            template.body(output.toByteArray(), (Charset)null);
            output.close();
        }

(2) 其他类型时，调用SpringEncoder的encode()方法进行编码处理，在此过程中遍历消息转换器对参数进行编码转换。

public void encode(Object requestBody, Type bodyType, RequestTemplate request)
    			throws EncodeException {
    		// template.body(conversionService.convert(object, String.class));
    		if (requestBody != null) {
    			Class<?> requestType = requestBody.getClass();
    			Collection<String> contentTypes = request.headers().get("Content-Type");
    
    			MediaType requestContentType = null;
    			if (contentTypes != null && !contentTypes.isEmpty()) {
    				String type = contentTypes.iterator().next();
    				requestContentType = MediaType.valueOf(type);
    			}
    
    			for (HttpMessageConverter<?> messageConverter : this.messageConverters
    					.getObject().getConverters()) {
    				if (messageConverter.canWrite(requestType, requestContentType)) {
    					if (log.isDebugEnabled()) {
    						if (requestContentType != null) {
    							log.debug("Writing [" + requestBody + "] as \""
    									+ requestContentType + "\" using ["
    									+ messageConverter + "]");
    						}
    						else {
    							log.debug("Writing [" + requestBody + "] using ["
    									+ messageConverter + "]");
    						}
    
    					}
    
    					FeignOutputMessage outputMessage = new FeignOutputMessage(request);
    					try {
    						@SuppressWarnings("unchecked")
    						HttpMessageConverter<Object> copy = (HttpMessageConverter<Object>) messageConverter;
    						copy.write(requestBody, requestContentType, outputMessage);
    					}
    					catch (IOException ex) {
    						throw new EncodeException("Error converting request body", ex);
    					}
    					// clear headers
    					request.headers(null);
    					// converters can modify headers, so update the request
    					// with the modified headers
    					request.headers(getHeaders(outputMessage.getHeaders()));
    
    					// do not use charset for binary data
    					if (messageConverter instanceof ByteArrayHttpMessageConverter) {
    						request.body(outputMessage.getOutputStream().toByteArray(), null);
    					} else {
    						request.body(outputMessage.getOutputStream().toByteArray(), Charset.forName("UTF-8"));
    					}
    					return;
    				}
    			}
    			String message = "Could not write request: no suitable HttpMessageConverter "
    					+ "found for request type [" + requestType.getName() + "]";
    			if (requestContentType != null) {
    				message += " and content type [" + requestContentType + "]";
    			}
    			throw new EncodeException(message);
    		}
    	}

### 3.4.3 问题二：复杂参数 ###

**问题说明**：

**当采用问题一的解决代码处理问题二时，最后会调用SpringEncoder的encode()进行处理，由于参数中既包含属性，又包含文件，在编码过程中最后会报错："Could not write request: no suitable HttpMessageConverter "。**

**问题分析**：

(1) 针对问题二，可以借鉴MultipartFile的处理方法调用MultipartFormContentProcessor.process()方法进行编码处理；

(2) 考虑到后续其他复杂参数的使用，本文在3.4.2自定义了注解@FileFeignAnnotation来标记实体为复杂参数；

接口信息：

@RequestMapping(value = "/load/test", method = RequestMethod.POST, consumes = MediaType.MULTIPART_FORM_DATA_VALUE
                , produces = {MediaType.APPLICATION_JSON_UTF8_VALUE})
        String uploadInfo(UserInfo userInfo);

**自定义编码器DefinedSpringFormEncoder**

public DefinedSpringFormEncoder(Encoder delegate) {
            super(delegate);
            MultipartFormContentProcessor processor = (MultipartFormContentProcessor) this.getContentProcessor(ContentType.MULTIPART);
            processor.addWriter(new SpringSingleMultipartFileWriter());
            processor.addWriter(new SpringManyMultipartFilesWriter());
        }
    
        @Override
        public void encode(Object object, Type bodyType, RequestTemplate template) throws EncodeException {
            if (!bodyType.equals(MultipartFile.class) && !isAnnotation(object)) {
                super.encode(object, bodyType, template);
                return;
            }
            if (isAnnotation(object)) {
                Map<String, Object> data = JSON.parseObject(JSON.toJSONString(object), new TypeReference<Map<String, Object>>() {
                });
                try {
                    addNotSerializeField(data,object);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
                super.encode(data, MAP_STRING_WILDCARD, template);
                return;
            }
            MultipartFile file = (MultipartFile) object;
            Map<String, Object> data = singletonMap(file.getName(), object);
            super.encode(data, MAP_STRING_WILDCARD, template);
        }
    
        /**
         * add these properties into map
         * properties is not Serialize and annotation by @JSONField
         * @param map
         * @param object
         * @throws IllegalAccessException
         */
        private void addNotSerializeField(Map<String, Object> map, Object object) throws IllegalAccessException {
            Field[] fields = object.getClass().getDeclaredFields();
            for (Field field : fields) {
                if (field.isAnnotationPresent(JSONField.class)) {
                    field.setAccessible(true);
                    String name = field.getName();
                    Object value = field.get(object);
                    map.put(name, value);
                }
            }
        }
    
        /**
         * estimate if object is annotation by @FileFeignAnnotation
         *
         * @param object
         * @return
         */
        private boolean isAnnotation(Object object) {
            Class objectClass = object.getClass();
            FileFeignAnnotation annotation = AnnotationUtils.findAnnotation(objectClass, FileFeignAnnotation.class);
            return annotation != null;
        }

核心代码为encode()方法：

(1) 对于非MultipartFile和非@FileFeignAnnotation的参数，调用SpringEncoder的encode()方法进行编码处理；

(2) 对于MultipartFile参数，调用MultipartFormContentProcessor.process()方法进行编码

(3) 对于@FileFeignAnnotation的实体参数，首先转换为Map，再将未序列化的参数添加到Map中，最后调用MultipartFormContentProcessor.process()方法进行编码。

测试结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21fc29waGlh_size_16_color_FFFFFF_t_70 4][]

# 4 小结 #

本文通过注入SpringFormEncoder编码器，解决了Feign服务间文件传输问题，测试结果正常；通过对源码进行分析，自定义编码器，解决了复杂参数传输问题，测试结果正常。

#  #

[20210720173530293.png]: /images/20220829/677e30d5a1e04c809a60469c527a02dc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21fc29waGlh_size_16_color_FFFFFF_t_70]: /images/20220829/fe559f20c09645eab707725364d0b9e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21fc29waGlh_size_16_color_FFFFFF_t_70 1]: /images/20220829/d28f178069734800987fa866744fe39e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21fc29waGlh_size_16_color_FFFFFF_t_70 2]: /images/20220829/c32d6b6f31ee4efe910cf9a207374e8e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21fc29waGlh_size_16_color_FFFFFF_t_70 3]: /images/20220829/02976f08eac04726921bf7eb25671c9c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21fc29waGlh_size_16_color_FFFFFF_t_70 4]: /images/20220829/d488e5f5128942bcb145b1a7fb5e7c73.png