devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

使用jdk序列化的方式实现微服务之间抽象类的数据传输_将multipartfile转换为httpentity对象

作者：繁依Fanyi0 | 2024-03-24 14:04:55

赞

踩

将multipartfile转换为httpentity对象

根据日常业务需求微服务之间数据传输对象可能是比较复杂的对象,就以Mybatis-plus QueryWrapper为例,对象中的属性可能存在抽象类的引用,甚至是集合中的抽象类,如果使用json进行传输时,json可能无法转化为对象

以QueryWrapper为例,normal变量中3个元素的真实类型是不相同的,但他们都实现了接口ISqlSegment

 

 所以当我们反序列化json字符串成对象的时候,无法知道数组中的三个ISqlSegment对象具体的实现具体是什么,所以会抛出转化异常

 

可以看出 json序列化的方式并没有办法在反序列化时知道到抽象类实例的具体子类型,所以博主采用了jdk的序列化的方式传输(借鉴rabbitMq SimpleMessageConverter 消息传输的思路)

这里引用一个博主的文章代码,本文以feign为例

Feign完美解决服务之间传递文件、传递list，map、对象等情况 - sprouting的个人空间 - OSCHINA - 中文开源技术交流社区

调用端代码(请求方)

在编码对象的时候我们判断如果需要使用jdk编码传输,则使用jdk编码传输,否则默认使用json(上面文章是使用json编码)

  1. package cn.ssq.config;
  2.  
  3.  
  4. import cn.ssq.http.model.JdkSerializable;
  5. import cn.ssq.uploadPolicyService.entity.OnlineShop;
  6. import com.alibaba.fastjson.JSON;
  7. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  8. import com.fasterxml.jackson.core.JsonProcessingException;
  9. import com.fasterxml.jackson.databind.ObjectMapper;
  10. import com.fasterxml.jackson.dataformat.xml.XmlMapper;
  11. import feign.RequestTemplate;
  12. import feign.codec.EncodeException;
  13. import feign.codec.Encoder;
  14. import org.springframework.core.io.InputStreamResource;
  15. import org.springframework.core.io.Resource;
  16. import org.springframework.http.HttpEntity;
  17. import org.springframework.http.HttpHeaders;
  18. import org.springframework.http.HttpOutputMessage;
  19. import org.springframework.http.MediaType;
  20. import org.springframework.http.converter.HttpMessageConverter;
  21. import org.springframework.util.LinkedMultiValueMap;
  22. import org.springframework.util.SerializationUtils;
  23. import org.springframework.web.client.RestTemplate;
  24. import org.springframework.web.multipart.MultipartFile;
  25.  
  26. import java.io.ByteArrayOutputStream;
  27. import java.io.IOException;
  28. import java.io.InputStream;
  29. import java.io.OutputStream;
  30. import java.lang.reflect.Type;
  31. import java.nio.charset.Charset;
  32. import java.util.Arrays;
  33. import java.util.List;
  34. import java.util.Map;
  35. import java.util.Map.Entry;
  36.  
  37.  
  38. /**
  39.  * @author ：LX
  40.  * 创建时间： 2020/10/14. 15:06
  41.  * 地点：广州
  42.  * 目的: 自定义表单编码器。feign 实现多pojo传输与MultipartFile上传 编码器，需配合开启feign自带注解使用
  43.  *      用于支持多对象和文件的上传
  44.  *
  45.  *      Encoder的原理就是将每个参数json序列化，设置requestHeader为Multipart/form-data,采用表单请求去请求生成者提供的接口。
  46.  *      这个方法能够同时发送多个实体文件，以及MultipartFile[]的数组.
  47.  *
  48.  *      参考资料：
  49.  *              https://github.com/pcan/feign-client-test
  50.  * 备注说明：
  51.  */
  52. public class FeignSpringFormEncoder implements Encoder{
  53.  
  54.     private final List<HttpMessageConverter<?>> converters = new RestTemplate().getMessageConverters();
  55.  
  56.     public static final Charset UTF_8 = Charset.forName("UTF-8");
  57.  
  58.     public FeignSpringFormEncoder() {}
  59.  
  60.     /**
  61.      * 实现一个 HttpOutputMessage
  62.      */
  63.     private class HttpOutputMessageImpl implements HttpOutputMessage{
  64.         /**
  65.          * 输出流，请求体
  66.          */
  67.         private final OutputStream body;
  68.         /**
  69.          * 请求头
  70.          */
  71.         private final HttpHeaders headers;
  72.  
  73.         public HttpOutputMessageImpl(OutputStream body, HttpHeaders headers) {
  74.             this.body = body;
  75.             this.headers = headers;
  76.         }
  77.  
  78.         @Override
  79.         public OutputStream getBody() throws IOException {
  80.             return body;
  81.         }
  82.  
  83.         @Override
  84.         public HttpHeaders getHeaders() {
  85.             return headers;
  86.         }
  87.     }
  88.  
  89.     /**
  90.      * 判断是否表单请求
  91.      * @param type
  92.      * @return
  93.      */
  94.     static boolean isFormRequest(Type type){
  95.         return MAP_STRING_WILDCARD.equals(type);
  96.     }
  97.  
  98.     /**
  99.      * 内部静态类,保存 MultipartFile 数据
  100.      */
  101.     static class MultipartFileResource extends InputStreamResource {
  102.         /**
  103.          * 文件名
  104.          */
  105.         private final String filename;
  106.         /**
  107.          * 文件大小
  108.          */
  109.         private final long size;
  110.  
  111.         /**
  112.          * 构造方法
  113.          * @param inputStream
  114.          * @param filename
  115.          * @param size
  116.          */
  117.         public MultipartFileResource(InputStream inputStream, String filename, long size) {
  118.             super(inputStream);
  119.             this.filename = filename;
  120.             this.size = size;
  121.         }
  122.  
  123.         @Override
  124.         public String getFilename() {
  125.             return this.filename;
  126.         }
  127.  
  128.         @Override
  129.         public InputStream getInputStream() throws IOException, IllegalStateException {
  130.             return super.getInputStream();
  131.         }
  132.  
  133.         @Override
  134.         public long contentLength(){
  135.             return size;
  136.         }
  137.     }
  138.  
  139.     /**
  140.      * 重写编码器
  141.      * @param object
  142.      * @param bodyType
  143.      * @param template
  144.      * @throws EncodeException
  145.      */
  146.     @Override
  147.     public void encode(Object object, Type bodyType, RequestTemplate template) throws EncodeException {
  148.         if (isFormRequest(bodyType)){
  149.             final HttpHeaders multipartHeaders = new HttpHeaders();
  150.             multipartHeaders.setContentType(MediaType.MULTIPART_FORM_DATA);
  151.             encodeMultipartFormRequest((Map<Object, ?>) object, multipartHeaders, template);
  152.         } else {
  153.             final HttpHeaders jsonHeaders = new HttpHeaders();
  154.             jsonHeaders.setContentType(MediaType.APPLICATION_JSON);
  155.             encodeRequest(object, jsonHeaders, template);
  156.         }
  157.     }
  158.  
  159.     /**
  160.      * 对有文件、表单的进行编码
  161.      * @param formMap
  162.      * @param multipartHeaders
  163.      * @param template
  164.      */
  165.     private void encodeMultipartFormRequest(Map<Object, ?> formMap, HttpHeaders multipartHeaders, RequestTemplate template){
  166.         if (formMap == null){
  167.             throw new EncodeException("无法对格式为null的请求进行编码。");
  168.         }
  169.  
  170.         LinkedMultiValueMap<Object, Object> map = new LinkedMultiValueMap<>();
  171.         //对每个参数进行检查校验
  172.         for (Entry<Object, ?> entry : formMap.entrySet()){
  173.             Object value = entry.getValue();
  174.             //不同的数据类型进行不同的编码逻辑处理
  175.             if (isMultipartFile(value)){
  176.                 //单个文件
  177.                 map.add(entry.getKey(), encodeMultipartFile((MultipartFile)value));
  178.  
  179.             } else if (isMultipartFileArray(value)){
  180.                 //多个文件
  181.                 encodeMultipartFiles(map, (String) entry.getKey(), Arrays.asList((MultipartFile[]) value));
  182.  
  183.             } else {
  184.                 //普通请求数据
  185.                 map.add(entry.getKey(), serializeObject(value));
  186.             }
  187.         }
  188.  
  189.         encodeRequest(map, multipartHeaders, template);
  190.     }
  191.  
  192.     /**
  193.      * 对请求进行编码
  194.      * @param value
  195.      * @param requestHeaders
  196.      * @param template
  197.      */
  198.     private void encodeRequest(Object value, HttpHeaders requestHeaders, RequestTemplate template){
  199.         ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
  200.         HttpOutputMessage dummyRequest = new HttpOutputMessageImpl(outputStream, requestHeaders);
  201.  
  202.         try {
  203.             Class<?> requestType = value.getClass();
  204.             MediaType requestContentType = requestHeaders.getContentType();
  205.             for (HttpMessageConverter<?> messageConverter : converters){
  206.                 if (messageConverter.canWrite(requestType, requestContentType)){
  207.                     ((HttpMessageConverter<Object>) messageConverter).write(value, requestContentType, dummyRequest);
  208.                     break;
  209.                 }
  210.             }
  211.         } catch (IOException e) {
  212.             throw new EncodeException("无法对请求进行编码:", e);
  213.         }
  214.  
  215.         HttpHeaders headers = dummyRequest.getHeaders();
  216.         if (headers != null){
  217.             for (Entry<String, List<String>> entry : headers.entrySet()){
  218.                 template.header(entry.getKey(), entry.getValue());
  219.             }
  220.         }
  221.  
  222.         /*
  223.         请使用模板输出流。。。如果文件太大，这将导致问题，因为整个请求都将在内存中。
  224.          */
  225.         template.body(outputStream.toByteArray(), UTF_8);
  226.     }
  227.  
  228.     /**
  229.      * 序列化对象
  230.      * @param obj
  231.      * @return
  232.      */
  233.     private HttpEntity<?> serializeObject(Object obj){
  234.         HttpHeaders jsonPartHeaders = new HttpHeaders();
  235.         Object content;
  236.         if (obj instanceof JdkSerializable){
  237.             //需要jdk则使用jdk编码
  238.             jsonPartHeaders.setContentType(MediaType.APPLICATION_OCTET_STREAM);
  239.             content = SerializationUtils.serialize(obj);
  240.         }else {
  241.             //否则默认使用json
  242.             if (obj instanceof String){
  243.                content = obj;
  244.             }else {
  245.                 jsonPartHeaders.setContentType(MediaType.APPLICATION_JSON);
  246.                 content = JSON.toJSONString(obj);
  247.             }
  248.         }
  249.  
  250.         return new HttpEntity<>(content, jsonPartHeaders);
  251.     }
  252.  
  253.     /**
  254.      * 编码MultipartFile文件，将其转换为HttpEntity，同时设置 Content-type 为 application/octet-stream
  255.      * @param map 当前请求 map.
  256.      * @param name 数组字段的名称
  257.      * @param fileList 要处理的文件
  258.      */
  259.     private void encodeMultipartFiles(LinkedMultiValueMap<Object, Object> map, String name, List<? extends MultipartFile> fileList){
  260.         HttpHeaders filePartHeaders = new HttpHeaders();
  261.         //设置 Content-type
  262.         filePartHeaders.setContentType(MediaType.APPLICATION_OCTET_STREAM);
  263.         try {
  264.             for (MultipartFile file : fileList){
  265.                 Resource multipartFileResource = new MultipartFileResource(file.getInputStream(), file.getOriginalFilename(), file.getSize());
  266.                 map.add(name, new HttpEntity<>(multipartFileResource, filePartHeaders));
  267.             }
  268.         } catch (IOException e) {
  269.             throw new EncodeException("无法对请求进行编码:", e);
  270.         }
  271.     }
  272.  
  273.     /**
  274.      * 编码MultipartFile文件，将其转换为HttpEntity，同时设置 Content-type 为 application/octet-stream
  275.      * @param file 要编码的文件
  276.      * @return
  277.      */
  278.     private HttpEntity<?> encodeMultipartFile(MultipartFile file){
  279.         HttpHeaders filePartHeaders = new HttpHeaders();
  280.         //设置 Content-type
  281.         filePartHeaders.setContentType(MediaType.APPLICATION_OCTET_STREAM);
  282.         try {
  283.             Resource multipartFileResource = new MultipartFileResource(file.getInputStream(), file.getOriginalFilename(), file.getSize());
  284.             return new HttpEntity<>(multipartFileResource, filePartHeaders);
  285.         } catch (IOException e) {
  286.             throw new EncodeException("无法对请求进行编码:", e);
  287.         }
  288.     }
  289.  
  290.     /**
  291.      * 判断是否多个 MultipartFile
  292.      * @param object
  293.      * @return
  294.      */
  295.     private boolean isMultipartFileArray(Object object){
  296.         return object != null && object.getClass().isArray() && MultipartFile.class.isAssignableFrom(object.getClass().getComponentType());
  297.     }
  298.  
  299.     /**
  300.      * 判断是否MultipartFile文件
  301.      * @param object 要判断的对象
  302.      * @return
  303.      */
  304.     private boolean isMultipartFile(Object object){
  305.         return object instanceof MultipartFile;
  306.     }
  307.  
  308.  
  309. }

具体实现代码段

  1.  /**
  2.      * 序列化对象
  3.      * @param obj
  4.      * @return
  5.      */
  6.     private HttpEntity<?> serializeObject(Object obj){
  7.         HttpHeaders jsonPartHeaders = new HttpHeaders();
  8.         Object content;
  9.         if (obj instanceof JdkSerializable){
  10.             //需要jdk则使用jdk编码
  11.             jsonPartHeaders.setContentType(MediaType.APPLICATION_OCTET_STREAM);
  12.             content = SerializationUtils.serialize(obj);
  13.         }else {
  14.             //否则默认使用json
  15.             if (obj instanceof String){
  16.                content = obj;
  17.             }else {
  18.                 jsonPartHeaders.setContentType(MediaType.APPLICATION_JSON);
  19.                 content = JSON.toJSONString(obj);
  20.             }
  21.         }
  22.  
  23.         return new HttpEntity<>(content, jsonPartHeaders);
  24.     }
  1. package cn.ssq.http.model;
  2.  
  3. import java.io.Serializable;
  4.  
  5. /**
  6.  * jdk序列化对象,用于标记需要jdk序列化传输的对象
  7.  * @author liufuhao
  8.  * @date 2021/10/05
  9.  */
  10. public interface JdkSerializable extends Serializable {
  11. }

我们需要重新封装QueryWrapper的DTO对象并实现自定义的JdkSerializable接口

  1. package cn.ssq.dto;
  2.  
  3. import cn.ssq.http.model.JdkSerializable;
  4. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  5.  
  6. /**
  7.  * mybatis-plus查询条件传输类
  8.  */
  9. public class QueryWrapperDTO<T> extends QueryWrapper<T> implements JdkSerializable {
  10.  
  11. }

服务端代码(接受方)

springmvc默认没有jdk反序列化对象转化实现,所以我们需要自己去实现jdk的反序列化

  1. package cn.ssq.http.converter;
  2.  
  3. import cn.ssq.http.model.JdkSerializable;
  4. import org.springframework.amqp.utils.SerializationUtils;
  5. import org.springframework.http.HttpInputMessage;
  6. import org.springframework.http.HttpOutputMessage;
  7. import org.springframework.http.MediaType;
  8. import org.springframework.http.converter.AbstractHttpMessageConverter;
  9. import org.springframework.http.converter.HttpMessageNotReadableException;
  10. import org.springframework.remoting.rmi.CodebaseAwareObjectInputStream;
  11. import org.springframework.util.ClassUtils;
  12. import org.springframework.util.StreamUtils;
  13.  
  14. import java.io.*;
  15. import java.util.LinkedHashSet;
  16. import java.util.Properties;
  17. import java.util.Set;
  18.  
  19. /**
  20.  * jdk序列化转化器
  21.  * @author liufuhao
  22.  * @date 2021/10/05
  23.  */
  24. public class JdkSerializableHttpMessageConverter extends AbstractHttpMessageConverter<Object> {
  25.     private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();
  26.     private final Set<String> whiteListPatterns = new LinkedHashSet();
  27.  
  28.  
  29.     public JdkSerializableHttpMessageConverter() {
  30.         super(new MediaType[]{new MediaType("application", "octet-stream"), MediaType.ALL});
  31.     }
  32.  
  33.     /**
  34.      * 判断是否支持转化
  35.      * @param clazz
  36.      * @return
  37.      */
  38.     public boolean supports(Class<?> clazz) {
  39.         Class<?>[] interfaces = clazz.getInterfaces();
  40.         for (Class<?> anInterface : interfaces) {
  41.             if (anInterface.equals(JdkSerializable.class)){
  42.                 return true;
  43.             }
  44.         }
  45.         return false;
  46.     }
  47.  
  48.     @Override
  49.     public Object readInternal(Class<?> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
  50.         long contentLength = inputMessage.getHeaders().getContentLength();
  51.         ByteArrayOutputStream bos = new ByteArrayOutputStream(contentLength >= 0L ? (int)contentLength : 4096);
  52.         StreamUtils.copy(inputMessage.getBody(), bos);
  53.         //使用jdk序列化,需要使用jdk反序列化,原理:读取class池中class对象的并构造实例对象
  54.         Object deserialize = SerializationUtils.deserialize(this.createObjectInputStream(new ByteArrayInputStream(bos.toByteArray()), null));
  55.         return deserialize;
  56.     }
  57.  
  58.     @Override
  59.     protected void writeInternal(Object obj, HttpOutputMessage outputMessage) throws IOException {
  60.         OutputStream os = outputMessage.getBody();
  61.         Properties properties = new Properties();
  62.         properties.store(os, String.valueOf(SerializationUtils.serialize(obj)));
  63.     }
  64.  
  65.  
  66.     /**
  67.      * 获取构建对象流
  68.      * @param is
  69.      * @param codebaseUrl
  70.      * @return
  71.      * @throws IOException
  72.      */
  73.     protected ObjectInputStream createObjectInputStream(InputStream is, String codebaseUrl) throws IOException {
  74.         return new CodebaseAwareObjectInputStream(is, this.beanClassLoader, codebaseUrl) {
  75.             //根据路径解析获取class对象
  76.             protected Class<?> resolveClass(ObjectStreamClass classDesc) throws IOException, ClassNotFoundException {
  77.                 Class<?> clazz = super.resolveClass(classDesc);
  78.                 return clazz;
  79.             }
  80.         };
  81.     }
  82.  
  83. }
  1. package cn.ssq.http.config;
  2.  
  3. import cn.ssq.http.converter.JdkSerializableHttpMessageConverter;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.http.converter.HttpMessageConverter;
  6. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  7.  
  8. import java.util.List;
  9.  
  10. /**
  11.  * mvc配置
  12.  * @author liufuhao
  13.  * @date 2021/10/05
  14.  */
  15. @Configuration
  16. public class MyWebConfig implements WebMvcConfigurer {
  17.     /**
  18.      * 新增反序列化解析器,解析微服务参数
  19.      * @param converters
  20.      */
  21.     @Override
  22.     public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
  23.  
  24.         converters.add(new JdkSerializableHttpMessageConverter());
  25.     }
  26. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/302824
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号