Feign 动态设定服务器名称 与 调用接口

1. 新增编码器（由于使用了动态的Feign，所以不能像正常使用Feign一样指定configuration配置编码器）

 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;
         }

     }

 }

2. 配置文件中配置编码器

feign.client.config.default.encoder=完整包名.FeignSpringFormEncoder

　　

3. 新增FeignClientUtil类

import org.springframework.beans.BeansException;
import org.springframework.cloud.openfeign.FeignClientBuilder;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;

@Component
public class FeignClientUtils implements ApplicationContextAware {

    private static ApplicationContext applicationContext = null;
   private static final Map<String, Object> BEAN_CACHE = new ConcurrentHashMap<>();

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        if (FeignClientUtils.applicationContext == null) {
            FeignClientUtils.applicationContext = applicationContext;
        }
    }

    public static <T> T build(String serverName, Class<T> targetClass) {
        return buildClient(serverName, targetClass);
    }

    @SuppressWarnings("unchecked")
    private static <T> T buildClient(String serverName, Class<T> targetClass) {
        T t = (T) BEAN_CACHE.get(serverName);
        if (Objects.isNull(t)) {
            FeignClientBuilder.Builder<T> builder = new FeignClientBuilder(applicationContext).forType(targetClass, serverName);

            t = builder.build();
            BEAN_CACHE.put(serverName, t);
        }
        return t;
    }
}

　　

4. 新增interface

import xxx.ApiResult;
import org.springframework.web.bind.annotation.*;

import java.util.Map;

public interface IFeignClientTemplate {

    @GetMapping(value = "/{url}", headers = {"Content-Type: application/json"})
    ApiResult get(@PathVariable("url") String url, @RequestParam Map<String, Object> params);

    @PostMapping(value = "/{url}", headers = {"Content-Type: application/json"}, consumes = "application/json")
    ApiResult post(@PathVariable("url") String url, Map<String, Object> params);

    @PostMapping(value = "/{url}")
    ApiResult postFile(@PathVariable("url") String url, Map<String, ?> params);
}

　　

5. 使用实例

String serviceName = "xxx"; // 注册在nacos的服务名称
String url = "xxx"; // 请求的url的接口
DynamicFeignClient client = FeignClientUtils.build(serviceName, DynamicFeignClient.class);
ApiResult result  = client.get(url,new HashMap<>());

　　

PS：过程中遇到了一些问题，也使用了RequestLine注解，最后都调整与解决了，编码器是必要的，不然无法转换为指定的DTO

如果有人知道怎么在这种情况下使用Configuration配置编码解码注解，也请不吝赐教（试了几个都不行，在build client中指定也不行，没有对应方法）

target values must be absolute.

java.lang.IllegalStateException: Method has too many Body parameters: public abstract java.lang.String xxx.IFeignClientTemplate.get(java.lang.String,java.lang.Object)

feign.FeignException$NotFound: status 404 reading IFeignClientTemplate#get(String)

status 405 reading IFeignClientTemplate#get(String,HashMap)

No serializer found for class java.io.FileDescriptor and no properties discovered to create BeanSerializer (to avoid exception, disable SerializationFeature.FAIL_ON_EMPTY_BEANS)

等报错