Feign完美解决服务之间传递文件、传递list，map、对象等情况-低调大师

Feign完美解决服务之间传递文件、传递list，map、对象等情况

2020-10-16 460

先说下背景，前段时间有一个需求，需要将服务A生成的一个文件传递到服务B，交予服务B去做处理，最开始的时候使用的spring-cloud-starter-openfeign，发现这一块是不支持的，然后引入了io.github.openfeign.form ,解决，但过一段时间又有新需求，在传递文件的同时，还传递对象和一些其他参数，这个时候发现feign就有些不行了。这个时候引入了feign-httpclient，暂时解决。用了一段时间，发现大文件的时候又出现了数据丢失等等问题。还有其他各种坑就不说了，都是用升级版本，引入其他的jar来解决的，但这个大文件数据丢失的问题一直不行。

之前使用的maven重要坐标

<!--feign支持文件上传-->
<dependency>
    <groupId>io.github.openfeign.form</groupId>
    <artifactId>feign-form</artifactId>
    <version>${feign-form-version}</version>
</dependency>
<dependency>
    <groupId>io.github.openfeign.form</groupId>
    <artifactId>feign-form-spring</artifactId>
    <version>${feign-form-version}</version>
</dependency>
<!--解决feign的传递数据丢失的问题，而且版本也要注意，中文有乱码问题-->
<dependency>
    <groupId>io.github.openfeign</groupId>
    <artifactId>feign-httpclient</artifactId>
    <version>${feign-httpclient}</version>
</dependency>

决定解决这个，首先说下使用的版本，这点很重要、很重要、很重要！

使用的版本：

springboot 2.0.3.RELEASE
springcloud Finchley.RELEASE

替换为下面的maven。上面的那些maven地址没必要了。

<!--版本管理-->
    <properties>
        <spring-mock-version>2.0.8</spring-mock-version>
        <!--netflix.feign 核心，使用openfeign有问题-->
        <netflix.feign-version>8.17.0</netflix.feign-version>
    </properties>

<!--远程服务调用，springboot2.0版本以上，需要导入下面的包才能使用 @EnableFeignClients 注解-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

        <!--feign服务直接调用，支持文件、基础数据类型、对象，list等-->
        <dependency>
            <groupId>com.netflix.feign</groupId>
            <artifactId>feign-core</artifactId>
            <version>${netflix.feign-version}</version>
        </dependency>
        <dependency>
            <groupId>com.netflix.feign</groupId>
            <artifactId>feign-jackson</artifactId>
            <version>${netflix.feign-version}</version>
        </dependency>
        <dependency>
            <groupId>com.netflix.feign</groupId>
            <artifactId>feign-slf4j</artifactId>
            <version>${netflix.feign-version}</version>
        </dependency>

        <!--file转MultipartFile-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-mock</artifactId>
            <version>${spring-mock-version}</version>
        </dependency>

注意，我已经测试过 openfeign、feign-httpclient，如果使用这些版本的并不能解决文件传递的问题，虽然可以接收文件，但是文件是残缺的，一定要替换成上面的maven才行。

核心思路就是：对编码器重写，Encoder的原理就是将每个参数json序列化，设置requestHeader为Multipart/form-data,采用表单请求去请求生成者提供的接口。这个方法能够同时发送多个实体文件，以及MultipartFile[]的数组.

首先对编码器重写，

import feign.RequestTemplate;
import feign.codec.EncodeException;
import feign.codec.Encoder;
import org.springframework.core.io.InputStreamResource;
import org.springframework.core.io.Resource;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.multipart.MultipartFile;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Type;
import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

/**
 * @author ：LX
 * 创建时间： 2020/10/14. 15:06
 * 地点：广州
 * 目的: 自定义表单编码器。feign 实现多pojo传输与MultipartFile上传 编码器，需配合开启feign自带注解使用
 *      用于支持多对象和文件的上传
 *
 *      Encoder的原理就是将每个参数json序列化，设置requestHeader为Multipart/form-data,采用表单请求去请求生成者提供的接口。
 *      这个方法能够同时发送多个实体文件，以及MultipartFile[]的数组.
 *
 *      参考资料：
 *              https://github.com/pcan/feign-client-test
 * 备注说明：
 */
public class FeignSpringFormEncoder implements Encoder{

    private final List<HttpMessageConverter<?>> converters = new RestTemplate().getMessageConverters();

    public static final Charset UTF_8 = Charset.forName("UTF-8");

    public FeignSpringFormEncoder() {}

    /**
     * 实现一个 HttpOutputMessage
     */
    private class HttpOutputMessageImpl implements HttpOutputMessage{
        /**
         * 输出流，请求体
         */
        private final OutputStream body;
        /**
         * 请求头
         */
        private final HttpHeaders headers;

        public HttpOutputMessageImpl(OutputStream body, HttpHeaders headers) {
            this.body = body;
            this.headers = headers;
        }

        @Override
        public OutputStream getBody() throws IOException {
            return body;
        }

        @Override
        public HttpHeaders getHeaders() {
            return headers;
        }
    }

    /**
     * 判断是否表单请求
     * @param type
     * @return
     */
    static boolean isFormRequest(Type type){
        return MAP_STRING_WILDCARD.equals(type);
    }

    /**
     * 内部静态类,保存 MultipartFile 数据
     */
    static class MultipartFileResource extends InputStreamResource {
        /**
         * 文件名
         */
        private final String filename;
        /**
         * 文件大小
         */
        private final long size;

        /**
         * 构造方法
         * @param inputStream
         * @param filename
         * @param size
         */
        public MultipartFileResource(InputStream inputStream, String filename, long size) {
            super(inputStream);
            this.filename = filename;
            this.size = size;
        }

        @Override
        public String getFilename() {
            return this.filename;
        }

        @Override
        public InputStream getInputStream() throws IOException, IllegalStateException {
            return super.getInputStream();
        }

        @Override
        public long contentLength() throws IOException {
            return size;
        }
    }

    /**
     * 重写编码器
     * @param object
     * @param bodyType
     * @param template
     * @throws EncodeException
     */
    @Override
    public void encode(Object object, Type bodyType, RequestTemplate template) throws EncodeException {
        if (isFormRequest(bodyType)){
            final HttpHeaders multipartHeaders = new HttpHeaders();
            multipartHeaders.setContentType(MediaType.MULTIPART_FORM_DATA);
            encodeMultipartFormRequest((Map<Object, ?>) object, multipartHeaders, template);
        } else {
            final HttpHeaders jsonHeaders = new HttpHeaders();
            jsonHeaders.setContentType(MediaType.APPLICATION_JSON);
            encodeRequest(object, jsonHeaders, template);
        }
    }

    /**
     * 对有文件、表单的进行编码
     * @param formMap
     * @param multipartHeaders
     * @param template
     */
    private void encodeMultipartFormRequest(Map<Object, ?> formMap, HttpHeaders multipartHeaders, RequestTemplate template){
        if (formMap == null){
            throw new EncodeException("无法对格式为null的请求进行编码。");
        }

        LinkedMultiValueMap<Object, Object> map = new LinkedMultiValueMap<>();
        //对每个参数进行检查校验
        for (Entry<Object, ?> entry : formMap.entrySet()){
            Object value = entry.getValue();
            //不同的数据类型进行不同的编码逻辑处理
            if (isMultipartFile(value)){
                //单个文件
                map.add(entry.getKey(), encodeMultipartFile((MultipartFile)value));

            } else if (isMultipartFileArray(value)){
                //多个文件
                encodeMultipartFiles(map, (String) entry.getKey(), Arrays.asList((MultipartFile[]) value));

            } else {
                //普通请求数据
                map.add(entry.getKey(), encodeJsonObject(value));
            }
        }

        encodeRequest(map, multipartHeaders, template);
    }

    /**
     * 对请求进行编码
     * @param value
     * @param requestHeaders
     * @param template
     */
    private void encodeRequest(Object value, HttpHeaders requestHeaders, RequestTemplate template){
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        HttpOutputMessage dummyRequest = new HttpOutputMessageImpl(outputStream, requestHeaders);

        try {
            Class<?> requestType = value.getClass();
            MediaType requestContentType = requestHeaders.getContentType();
            for (HttpMessageConverter<?> messageConverter : converters){
                if (messageConverter.canWrite(requestType, requestContentType)){
                    ((HttpMessageConverter<Object>) messageConverter).write(value, requestContentType, dummyRequest);
                    break;
                }
            }
        } catch (IOException e) {
            throw new EncodeException("无法对请求进行编码:", e);
        }

        HttpHeaders headers = dummyRequest.getHeaders();
        if (headers != null){
            for (Entry<String, List<String>> entry : headers.entrySet()){
                template.header(entry.getKey(), entry.getValue());
            }
        }

        /*
        请使用模板输出流。。。如果文件太大，这将导致问题，因为整个请求都将在内存中。
         */
        template.body(outputStream.toByteArray(), UTF_8);
    }

    /**
     * 编码为json对象
     * @param obj
     * @return
     */
    private HttpEntity<?> encodeJsonObject(Object obj){
        HttpHeaders jsonPartHeaders = new HttpHeaders();
        jsonPartHeaders.setContentType(MediaType.APPLICATION_JSON);
        return new HttpEntity<>(obj, jsonPartHeaders);
    }

    /**
     * 编码MultipartFile文件，将其转换为HttpEntity，同时设置 Content-type 为 application/octet-stream
     * @param map 当前请求 map.
     * @param name 数组字段的名称
     * @param fileList 要处理的文件
     */
    private void encodeMultipartFiles(LinkedMultiValueMap<Object, Object> map, String name, List<? extends MultipartFile> fileList){
        HttpHeaders filePartHeaders = new HttpHeaders();
        //设置 Content-type
        filePartHeaders.setContentType(MediaType.APPLICATION_OCTET_STREAM);
        try {
            for (MultipartFile file : fileList){
                Resource multipartFileResource = new MultipartFileResource(file.getInputStream(), file.getOriginalFilename(), file.getSize());
                map.add(name, new HttpEntity<>(multipartFileResource, filePartHeaders));
            }
        } catch (IOException e) {
            throw new EncodeException("无法对请求进行编码:", e);
        }
    }

    /**
     * 编码MultipartFile文件，将其转换为HttpEntity，同时设置 Content-type 为 application/octet-stream
     * @param file 要编码的文件
     * @return
     */
    private HttpEntity<?> encodeMultipartFile(MultipartFile file){
        HttpHeaders filePartHeaders = new HttpHeaders();
        //设置 Content-type
        filePartHeaders.setContentType(MediaType.APPLICATION_OCTET_STREAM);
        try {
            Resource multipartFileResource = new MultipartFileResource(file.getInputStream(), file.getOriginalFilename(), file.getSize());
            return new HttpEntity<>(multipartFileResource, filePartHeaders);
        } catch (IOException e) {
            throw new EncodeException("无法对请求进行编码:", e);
        }
    }

    /**
     * 判断是否多个 MultipartFile
     * @param object
     * @return
     */
    private boolean isMultipartFileArray(Object object){
        return object != null && object.getClass().isArray() && MultipartFile.class.isAssignableFrom(object.getClass().getComponentType());
    }

    /**
     * 判断是否MultipartFile文件
     * @param object 要判断的对象
     * @return
     */
    private boolean isMultipartFile(Object object){
        return object instanceof MultipartFile;
    }


}

将该编码器注册为bean

import feign.Contract;
import feign.codec.Encoder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 上传文件所用配置
 * @author admin
 */
@Configuration
public class MultipartSupportConfig {


    /**
     * 启用feigin自定义注解支持，如 @RequestLine 和 @Param
     * @return
     */
    @Bean
    public Contract feignContract(){
        return new Contract.Default();
    }

    /**
     * feign 实现多pojo传输与MultipartFile上传 编码器，需配合开启feign自带注解使用
     * @return
     */
    @Bean
    public Encoder feignSpringFormEncoder(){
        //注入自定义编码器
        return new FeignSpringFormEncoder();
    }


}

这个时候就基本告一段落，

所有的请求按照这个标准来写

/**
     * 示例代码：请求方式和路径之间须有一个空格。 表单提交的话请求方式只能是post
     * 支持如下的所有请求方式。
     * 请求参数需要 @Param 修饰
     * 在接收端，采用@RequestPart注解接收每一个参数。所有接收都用 @RequestPart(value = "advertiser", required = false)
     * @return
     */
    @RequestLine(value = "POST /data/test01")
    ResultJson test01(@Param(value = "name") String name,
                      @Param(value = "nametwo") String nametwo,
                      @Param(value = "file") MultipartFile file,
                      @Param(value = "advertiserMap") Map<String, User> advertiserMap,
                      @Param(value = "materials") List<User> materials,
                      @Param(value = "user") User user,
                      @Param(value = "files") MultipartFile[] files);

要使用 Feign 自带的注解，@RequesLine 和 @Param 来做请求参数的注入，

我测试的时候，使用如下这些参数，都可以完成传递、

 /**
     * 示例代码：feign请求测试
     * @return
     */
    public String test01(){
        try {
            String name = "中文";
            String nametwo = "two";

            MultipartFile file = fileToMultipartFile(new File("E:\\临时\\1.xlsx"));
            MultipartFile file2 = fileToMultipartFile(new File("E:\\临时\\2.xlsx"));

            Map<String, User> advertiserMap = new HashMap<>();
            User user = new User();
            user.setXm("张三");
            User user1 = new User();
            user1.setXm("张四");
            advertiserMap.put("zw", user);
            advertiserMap.put("中", user1);

            List<User> list = new ArrayList<>();
            list.add(user);
            list.add(user1);

            MultipartFile[] files = new MultipartFile[2];
            files[0] = file;
            files[1] = file2;

            ResultJson resultJson = resourceAdminFeignImp.test01(name, nametwo, file, advertiserMap, list, user, files);

            if (ResultEnum.SUCCESS.getStatus().equals(resultJson.getStatus())){
                log.info("测试结果：{}", resultJson.getData());
                return (String) resultJson.getData();
            } else {
                log.error("测试失败，失败原因，{}", resultJson.getMsg());
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.error("服务不可用或服务调用失败，上传数据失败");
            return null;
        }
    }

接收端同样要注意，要使用@RequestPart 来接收参数。

/**
     * 演示用demo，用来测试这些类型是不是都可以接收
     * @param name 普通参数
     * @param file 普通文件
     * @param advertiserMap 普通map对象
     * @param materials 普通list对象
     * @param user 对象
     * @param files 多文件
     * @return
     */
    @ResponseBody
    @PostMapping("/test01")
    public ResultJson test01(@RequestPart(value = "name", required = false) String name,
                             @RequestPart(value = "nametwo", required = false) String nametwo,
                             @RequestPart(value = "file", required = false) MultipartFile file,
                             @RequestPart(value = "advertiserMap", required = false) Map<String, User> advertiserMap,
                             @RequestPart(value = "materials", required = false) List<User> materials,
                             @RequestPart(value = "user", required = false) User user,
                             @RequestPart(value = "files", required = false) MultipartFile[] files){
        log.info("name:{}", name);
        log.info("nametwo:{}", nametwo);
        log.info("文件名:{},文件大小:{},文件名：{}", file.getOriginalFilename(), file.getSize(), file.getName());
        log.info("map对象大小：{}", advertiserMap.size());
        log.info("list对象大小:{}", materials.size());
        log.info("用户:{}", user.toString());
        log.info("文件名:{},文件大小:{},文件名：{}", files[0].getOriginalFilename(), files[0].getSize(), files[0].getName());

        return new ResultJson("查询成功", null);
    }

注意，基础的数据类型，String 之类的可以不用写注解也可以接收。

总的实现参考了 https://blog.csdn.net/qq_34523427/article/details/88863800 和 https://github.com/pcan/feign-client-test

微信关注我们

原文链接：https://my.oschina.net/sprouting/blog/4676419

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

数据结构与算法 | 来来来，让我们重新认识一下什么是树

Hi! 大家好，我是小小，我们开始今天的内容，今天主要讲解什么是树。树的递归结构从一张图中解释什么是树这张图，主要讲解关于cart这个单词的所有的可能组合，按照常理，需要先考虑三个字母的排列，然后对三个字母进行拆分，直到最后一个节点，这个过程就类似于树到底什么是树什么是树树是节点集合(A tree is a collection of nodes)，集合：集合是允许一个元素都没有的集合，称之为空集。首先，集合是允许一个元素都没有的集合，称之为空集，那么书是不是也允许一个节点都没有的呢，是的，一个节点都没有的树，称之为空树，如果不是空的，则会存在根节点r和零个或更多非空子树，T1，T2.。。Tk，他们的根由来自r的有向连接，什么叫有向边，大致可以理解为箭头。用图的关系说明树的内部关系根节点（root）一棵树只有一个跟节点，所有的节点都在该节点的下面，尝试把图倒过来看，可以看成一个我们日常见到的数的根部，在这里显然字母A就是这颗树的根节点。子节点，父节点，一个节点，它对应的下面有连这的节点，那么被连着的节点就是这个节点的子节点，也叫做孩子，那么这个节点叫做被连接的节点的父...

2020-10-14

444

1.背景当我们打开导航，开车驶向目的地的过程中，有时候会碰到这样的问题：前方明明没有路，可能在施工封闭，可是导航仍然让我们往前开车，以至于我们无法顺利到达目的地。全国道路千千万，每天都有巨量的道路变得不可通行，那么如何动态的识别出哪些道路走不通了呢？图中所示即为因封路事件导致的导航路线改变道路不通往往导致该条道路汽车流量突然降低。监控汽车流量的变化是挖掘封路事件的重要指标。但是，目前业务中遇到的一个重要问题是，针对汽车无法通行的封路事件，行人、自行车可能都可以穿行，这些行人、自行车等的噪声流量大大削弱了道路流量变化。因此，如果能够对行人、自行车、汽车的轨迹进行分类，就可以对道路流量的噪声进行过滤，仅仅关注汽车流量，流量随着封路事件的变化将更为显著，从而便于道路封闭的挖掘。本文主要针对非机动车、机动车分类探索轨迹分类问题。 2.样本获取与标签制定由于轨迹数据缺少原始真值，我们将用户导航模式作为轨迹分类的伪标签。例如当时用户采用汽车导航，其轨迹对应的标签即为汽车。由于汽车导航数据远远多于非机动车，不同伪标签样本比例差异巨大，存在严重的样本不平衡问题。此外，用户导航模式与用...

2020-10-16

467

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。