feign No serializer found for class java.io.FileDescriptor and no properties discovered to create Be

矫情吗；* 2023-05-22 15:27 126阅读 0赞

> No serializer found for class java.io.FileDescriptor and no properties discovered to create BeanSerializer (to avoid exception, disable SerializationFeature.FAIL\_ON\_EMPTY\_BEANS) (through reference chain: org.springframework.util.LinkedMultiValueMap\[“media\[file\]”\]->java.util.LinkedList\[0\]->java.io.FileInputStream\[“fd”\]) feign远程上传文件报错

*  feign服务端代码：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxNDI0ODI1_size_16_color_FFFFFF_t_70]
    
     *  feign客户端调用远程代码：  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxNDI0ODI1_size_16_color_FFFFFF_t_70 1]
 *  远程调用配置：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxNDI0ODI1_size_16_color_FFFFFF_t_70 2]
 *  这样的配置普通数据接口调用没问题，传输图片报错，经排查：改成红框1的配置  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxNDI0ODI1_size_16_color_FFFFFF_t_70 3]
 *  还需要添加这两个类  
    ![在这里插入图片描述][20200418105703926.png]
 *  FeignSpringFormEncoder
    
        package com.kingdom.kdum.event.config.feign.decode;
        
         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;
         
         /** * A custom {@link Encoder} that supports Multipart requests. It uses * {@link HttpMessageConverter}s like {@link RestTemplate} does. * * @author Pierantonio Cangianiello */
         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() { 
             }
         
             /** * {@inheritDoc } */
             @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<String, ?>) object, multipartHeaders, template);
                 } else { 
                     final HttpHeaders jsonHeaders = new HttpHeaders();
                     jsonHeaders.setContentType(MediaType.APPLICATION_JSON);
                     encodeRequest(object, jsonHeaders, template);
                 }
             }
         
             /** * Encodes the request as a multipart form. It can detect a single {@link MultipartFile}, an * array of {@link MultipartFile}s, or POJOs (that are converted to JSON). * * @param formMap * @param template * @throws EncodeException */
             private void encodeMultipartFormRequest(Map<String, ?> formMap, HttpHeaders multipartHeaders, RequestTemplate template) throws EncodeException { 
                 if (formMap == null) { 
                     throw new EncodeException("Cannot encode request with null form.");
                 }
                 LinkedMultiValueMap<String, Object> map = new LinkedMultiValueMap<>();
                 for (Entry<String, ?> entry : formMap.entrySet()) { 
                     Object value = entry.getValue();
                     if (isMultipartFile(value)) { 
                         map.add(entry.getKey(), encodeMultipartFile((MultipartFile) value));
                     } else if (isMultipartFileArray(value)) { 
                         encodeMultipartFiles(map, entry.getKey(), Arrays.asList((MultipartFile[]) value));
                     } else { 
                         map.add(entry.getKey(), encodeJsonObject(value));
                     }
                 }
                 encodeRequest(map, multipartHeaders, template);
             }
         
             private boolean isMultipartFile(Object object) { 
                 return object instanceof MultipartFile;
             }
         
             private boolean isMultipartFileArray(Object o) { 
                 return o != null && o.getClass().isArray() && MultipartFile.class.isAssignableFrom(o.getClass().getComponentType());
             }
         
             /** * Wraps a single {@link MultipartFile} into a {@link HttpEntity} and sets the * {@code Content-type} header to {@code application/octet-stream} * * @param file * @return */
             private HttpEntity<?> encodeMultipartFile(MultipartFile file) { 
                 HttpHeaders filePartHeaders = new HttpHeaders();
                 filePartHeaders.setContentType(MediaType.APPLICATION_OCTET_STREAM);
                 try { 
                     Resource multipartFileResource = new MultipartFileResource(file.getOriginalFilename(), file.getSize(), file.getInputStream());
                     return new HttpEntity<>(multipartFileResource, filePartHeaders);
                 } catch (IOException ex) { 
                     throw new EncodeException("Cannot encode request.", ex);
                 }
             }
         
             /** * Fills the request map with {@link HttpEntity}s containing the given {@link MultipartFile}s. * Sets the {@code Content-type} header to {@code application/octet-stream} for each file. * * @param map current request map. * @param name the name of the array field in the multipart form. * @param files */
             private void encodeMultipartFiles(LinkedMultiValueMap<String, Object> map, String name, List<? extends MultipartFile> files) { 
                 HttpHeaders filePartHeaders = new HttpHeaders();
                 filePartHeaders.setContentType(MediaType.APPLICATION_OCTET_STREAM);
                 try { 
                     for (MultipartFile file : files) { 
                         Resource multipartFileResource = new MultipartFileResource(file.getOriginalFilename(), file.getSize(), file.getInputStream());
                         map.add(name, new HttpEntity<>(multipartFileResource, filePartHeaders));
                     }
                 } catch (IOException ex) { 
                     throw new EncodeException("Cannot encode request.", ex);
                 }
             }
         
             /** * Wraps an object into a {@link HttpEntity} and sets the {@code Content-type} header to * {@code application/json} * * @param o * @return */
             private HttpEntity<?> encodeJsonObject(Object o) { 
                 HttpHeaders jsonPartHeaders = new HttpHeaders();
                 jsonPartHeaders.setContentType(MediaType.APPLICATION_JSON);
                 return new HttpEntity<>(o, jsonPartHeaders);
             }
         
             /** * Calls the conversion chain actually used by * {@link RestTemplate}, filling the body of the request * template. * * @param value * @param requestHeaders * @param template * @throws EncodeException */
             private void encodeRequest(Object value, HttpHeaders requestHeaders, RequestTemplate template) throws EncodeException { 
                 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 ex) { 
                     throw new EncodeException("Cannot encode request.", ex);
                 }
                 HttpHeaders headers = dummyRequest.getHeaders();
                 if (headers != null) { 
                     for (Entry<String, List<String>> entry : headers.entrySet()) { 
                         template.header(entry.getKey(), entry.getValue());
                     }
                 }
                 /* we should use a template output stream... this will cause issues if files are too big, since the whole request will be in memory. */
                 template.body(outputStream.toByteArray(), UTF_8);
             }
         
             /** * Minimal implementation of {@link HttpOutputMessage}. It's needed to * provide the request body output stream to * {@link HttpMessageConverter}s */
             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;
                 }
         
             }
         
             /** * Heuristic check for multipart requests. * * @param type * @return * @see feign.Types */
             static boolean isFormRequest(Type type) { 
                 return MAP_STRING_WILDCARD.equals(type);
             }
         
             /** * Dummy resource class. Wraps file content and its original name. */
             static class MultipartFileResource extends InputStreamResource { 
         
                 private final String filename;
                 private final long size;
         
                 public MultipartFileResource(String filename, long size, InputStream inputStream) { 
                     super(inputStream);
                     this.size = size;
                     this.filename = filename;
                 }
         
                 @Override
                 public String getFilename() { 
                     return this.filename;
                 }
         
                 @Override
                 public InputStream getInputStream() throws IOException, IllegalStateException { 
                     return super.getInputStream(); //To change body of generated methods, choose Tools | Templates.
                 }
         
                 @Override
                 public long contentLength() throws IOException { 
                     return size;
                 }
         
             }
         
         }
 *  ListDecoder
    
        package com.kingdom.kdum.event.config.feign.decode;
        
          import com.fasterxml.jackson.core.type.TypeReference;
          import com.fasterxml.jackson.databind.DeserializationFeature;
          import com.fasterxml.jackson.databind.Module;
          import com.fasterxml.jackson.databind.ObjectMapper;
          import com.fasterxml.jackson.databind.RuntimeJsonMappingException;
          import feign.Response;
          import feign.Util;
          import feign.codec.Decoder;
          
          import java.io.BufferedReader;
          import java.io.IOException;
          import java.io.Reader;
          import java.lang.reflect.Type;
          import java.util.Collections;
          import java.util.List;
          
          public class ListDecoder implements Decoder { 
          
              private final ObjectMapper mapper;
          
              public ListDecoder() { 
                  this(Collections.<Module>emptyList());
              }
          
              public ListDecoder(Iterable<Module> modules) { 
                  this(new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
                          .registerModules(modules));
              }
          
              public ListDecoder(ObjectMapper mapper) { 
                  this.mapper = mapper;
              }
          
              @Override
              public Object decode(Response response, Type type) throws IOException { 
                  if (response.status() == 404) return Util.emptyValueOf(type);
                  if (response.body() == null) return null;
                  Reader reader = response.body().asReader();
                  if (!reader.markSupported()) { 
                      reader = new BufferedReader(reader, 1);
                  }
                  try { 
                      reader.mark(1);
                      if (reader.read() == -1) { 
                          return null;
                      }
                      reader.reset();
                      return mapper.readValue(reader, new TypeReference<List>(){ });
                  } catch (RuntimeJsonMappingException e) { 
                      if (e.getCause() != null && e.getCause() instanceof IOException) { 
                          throw IOException.class.cast(e.getCause());
                      }
                      throw e;
                  }
              }
          }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxNDI0ODI1_size_16_color_FFFFFF_t_70]: /images/20230521/ba3fc1dd08b44698b685ca919eba8652.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxNDI0ODI1_size_16_color_FFFFFF_t_70 1]: /images/20230521/aae44b5813bd459b9c28943e4adea0e0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxNDI0ODI1_size_16_color_FFFFFF_t_70 2]: /images/20230521/07bc05e6cd99490f9027872c58155199.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMxNDI0ODI1_size_16_color_FFFFFF_t_70 3]: /images/20230521/3326ddffeefb4093aac0208f46857e95.png
[20200418105703926.png]: /images/20230521/7a12968a3a004ac8bdae718ed264f361.png