[Calling Third-party API - OpenFeign] 5 Feign Spring Cloud upload、download File

/**
 * @author vincent
 */
@RestController
@Slf4j
@RequestMapping(value = "/file")
public class ServerUpDownloadFileController {

    private final static String PATH = "/Users/vincent/IDEA_Project/my_project/calling-third-party-api/src/main/java/com/vincent/callingthirdpartyapi/open_feign/spring_cloud_open_feign";

    @PostMapping(value = "/upload")
    public ResponseDto<String> upload(@RequestParam("file") MultipartFile file) throws IOException {
        log.info("Upload Method Params MultipartFile file: {}...", file);
        String name = file.getOriginalFilename();
        log.info("File name: {}...", name);
        file.transferTo(Paths.get(PATH).resolve("upload_file.txt"));
        return ResponseDto.success(name + " upload success...");
    }

    /**
     * Spring 提供的类：FileSystemResource
     *
     * @param fileName 文件名
     * @param response 响应
     * @return FileSystemResource
     * @throws UnsupportedEncodingException 异常
     */
    @GetMapping(value = "/download")
    public FileSystemResource download(@RequestParam("fileName") String fileName, HttpServletResponse response) throws UnsupportedEncodingException {
        log.info("Download Method Params String fileName: {}...", fileName);
        Path filePath = Paths.get(PATH).resolve(fileName);
        response.setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_OCTET_STREAM_VALUE);
        response.setHeader(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=" + URLEncoder.encode("download_file.txt", StandardCharsets.UTF_8.toString()));
        return new FileSystemResource(filePath);
    }

    @GetMapping(value = "/download2")
    public void download2(@RequestParam("fileName") String fileName, HttpServletResponse response) throws Exception {
        log.info("Download2 Method Params String fileName: {}...", fileName);
        Path filePath = Paths.get(PATH).resolve(fileName);
        response.setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_OCTET_STREAM_VALUE);
        response.setHeader(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=" + URLEncoder.encode("fileName.txt", "UTF-8"));
//        IOUtils.copy(Files.newInputStream(filePath), response.getOutputStream());//这个写法和下面的写法是一个意思
        response.getOutputStream().write(Files.readAllBytes(filePath));
    }
}

/**
 * @author vincent
 */
public class ClassUtils {
    public static <T> Class<T> getGenericBySuperClass(Class<?> clazz) {
        // getGenericSuperclass: 获取父类的泛型
        Type genericSuperclass = clazz.getGenericSuperclass();
        return getGenericType(genericSuperclass);
    }

    public static <T> Class<T> getGenericByInterface(Class<?> clazz) {
        /*
         * getGenericInterfaces: 获取父接口的泛型
         * 例: 父接口 -> interface A<T>
         *     子实现类 -> class B implements A<T>
         *     Class<B> clazz = B.class
         *     clazz.getGenericInterfaces(): 获取 A 接口的泛型（因为接口是多实现的, 所以该方法返回的是 Type[] ）
         */
        Type[] genericInterfaces = clazz.getGenericInterfaces();
        if (ArrayUtils.isEmpty(genericInterfaces)) {
            return null;
        }

        Type genericInterface = genericInterfaces[0];
        return getGenericType(genericInterface);
    }

    @SuppressWarnings("unchecked")
    private static <T> Class<T> getGenericType(Type genericSuperclass) {
        // ParameterizedType 是一个接口，这个类可以用来检验泛型是否被参数化
        if (!(genericSuperclass instanceof ParameterizedType)) {
            return null;
        }

        ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
        //  .getActualTypeArguments(): 获取这个泛型, 实例化后的具体类型
        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
        if (ArrayUtils.isEmpty(actualTypeArguments)) {
            return null;
        }

        Type actualTypeArgument = actualTypeArguments[0];
        if (!(actualTypeArgument instanceof Class)) {
            return null;
        }
        return (Class<T>) actualTypeArgument;
    }
}

/**
 * @author vincent
 * 熔断器工厂
 */
public interface DefaultFallbackFactory<T> extends FallbackFactory<T> {

    Map<Class<?>, Function<Throwable, Object>> wrapperException();

    static ResponseDto<?> simpleFailResponseDto(Throwable cause) {
        ResponseDto<?> responseDto = new ResponseDto<>();
        responseDto.setStatus(-100);
        responseDto.setMsg(cause.getClass().getName() + ": detailMessage[ " + Optional.ofNullable(cause.getMessage()).orElse("") + " ]");
        return responseDto;
    }

    @Override
    default T create(Throwable cause) {
        return simpleFailClient(cause);
    }

    @SuppressWarnings("unchecked")
    default T simpleFailClient(Throwable cause) {
        Class<Object> clazz = ClassUtils.getGenericByInterface(this.getClass());
        Map<Class<?>, Function<Throwable, Object>> map = Optional.ofNullable(wrapperException()).orElse(Collections.emptyMap());
        // 动态代理 cglib, 这里是动态生成 T 的实现类
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback((InvocationHandler) (o, method, objects) -> {
            Class<?> returnType = method.getReturnType();
            if (map.containsKey(returnType)) {
                return map.get(returnType).apply(cause);
            }
            return new RuntimeException(cause);
        });
        return (T) enhancer.create();
    }
}

@Slf4j
@Configuration
public class CircuitBreakerConfig {
    @Bean
    MyCircuitBreaker myCircuitBreaker() {
        return new MyCircuitBreaker();
    }

    @SuppressWarnings("rawtypes")
    @Bean
    CircuitBreakerFactory circuitBreakerFactory(MyCircuitBreaker myCircuitBreaker) {
        return new CircuitBreakerFactory() {
            @Override
            public CircuitBreaker create(String id) {
                log.info("Creating a circuit breaker with id [" + id + "]");
                return myCircuitBreaker;
            }

            @Override
            protected ConfigBuilder configBuilder(String id) {
                return Object::new;
            }

            @Override
            public void configureDefault(Function defaultConfiguration) {

            }
        };
    }

    static class MyCircuitBreaker implements CircuitBreaker {

        AtomicBoolean runWasCalled = new AtomicBoolean();

        @Override
        public <T> T run(Supplier<T> toRun) {
            try {
                this.runWasCalled.set(true);
                return toRun.get();
            }
            catch (Throwable throwable) {
                throw new NoFallbackAvailableException("No fallback available.", throwable);
            }
        }

        @Override
        public <T> T run(Supplier<T> toRun, Function<Throwable, T> fallback) {
            try {
                return run(toRun);
            }
            catch (Throwable throwable) {
                return fallback.apply(throwable);
            }
        }

        public void clear() {
            this.runWasCalled.set(false);
        }
    }
}

@Configuration
public class FeignConfig {
    /**
     * doNotCloseAfterDecode(): 该构造方法的作用为，当响应返回的 response 进行解码器解析后，对其不进行关闭。
     * 这里主要用于文件下载时，以流的形式成功返回后，防止流的关闭。
     * 如果不设置该值，在调用第三方的下载接口时，会抛出 java.io.IOException: stream is closed 异常。
     *
     * @return Feign.Builder
     */
    @Bean
    public Feign.Builder doNotCloseAfterDecode() {
        return Feign.builder().doNotCloseAfterDecode();
    }

    @Autowired
    private ObjectFactory<HttpMessageConverters> messageConverters;

    /**
     * 编码器: 支持以下三种请求格式
     * 1. application/json
     * 2. application/x-www-form-urlencoded
     * 3. multipart/form-data
     *
     * @return Encoder
     */
    @Bean
    public Encoder feignFormEncoder() {
        return new SpringFormEncoder(new SpringEncoder(messageConverters));
    }

    /**
     * 解码器: 支持两种响应格式
     * 1. 返回值类型为 InputStream（主要用于文件下载）
     * 2. 其余返回值类型，以 json 数据格式进行解析
     *
     * @return Decoder
     */
    @Bean
    public Decoder feignFormDecoder() {
        return (response, type) -> {
            if (type == InputStream.class) {
                return response.body().asInputStream();
            }
            return new JacksonDecoder().decode(response, type);
        };
    }
}

/**
 * @author vincent
 */
@FeignClient(name = "UpDownloadFileApiClient", url = "http://localhost:8080/file",
        configuration = FeignConfig.class,
        fallbackFactory = UpDownloadFileApiClient.UpDownloadFileApiClientFactory.class
)
public interface UpDownloadFileApiClient {
    @PostMapping(value = "/upload", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    ResponseDto<String> upload(@RequestPart("file") MultipartFile file);

    @GetMapping(value = "/download")
    InputStream download(@RequestParam("fileName") String fileName);

    @GetMapping(value = "/download2")
    InputStream download2(@RequestParam("fileName") String fileName);


    @Component
    class UpDownloadFileApiClientFactory implements DefaultFallbackFactory<UpDownloadFileApiClient> {
        private static final Map<Class<?>, Function<Throwable, Object>> WRAPPER_EXCEPTION = ImmutableMap.of(
                // 如果返回类型是 InputStream, 在 http 调用失败的情况下抛出 RuntimeException(e)
                InputStream.class, e -> {
                    throw new RuntimeException(e);
                },
                // 如果返回类型是 ResponseDto, 在 http 调用失败的情况下返回 simpleFailResponseDto(cause)
                ResponseDto.class, DefaultFallbackFactory::simpleFailResponseDto
        );

        @Override
        public Map<Class<?>, Function<Throwable, Object>> wrapperException() {
            return WRAPPER_EXCEPTION;
        }
    }
}

@SpringBootTest(classes = CallingThirdPartyApiApplicationTests.class,
        webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
        value = {"feign.circuitbreaker.enabled=true"}
)
@Slf4j
public class CloudFeignUpDownloadFileTest {
    private final static String PATH = "/Users/vincent/IDEA_Project/my_project/calling-third-party-api/src/test/java/com/vincent/callingthirdpartyapi/open_feign/spring_cloud_open_feign";

    @Autowired
    private UpDownloadFileApiClient upDownloadFileApiClient;

    @Test
    public void uploadTest() throws IOException {
        String name = "upload_test_file.txt";
        Path filePath = Paths.get(PATH).resolve(name);
        String originalFileName = "upload_test_file.txt";
        String contentType = "application/octet-stream";
        byte[] content = Files.readAllBytes(filePath);
        MultipartFile multipartFile = new MockMultipartFile(name, originalFileName, contentType, content);
        ResponseDto<String> responseDto = upDownloadFileApiClient.upload(multipartFile);
        log.info(new ObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(responseDto));
    }

    @Test
    public void downloadTest() throws IOException {
        Path path = Paths.get(PATH);
        InputStream inputStream = upDownloadFileApiClient.download("upload_file.txt");
        IOUtils.copy(inputStream, Files.newOutputStream(path.resolve("down_file.txt")));

        InputStream inputStream2 = upDownloadFileApiClient.download("upload_file.txt");
        IOUtils.copy(inputStream2, Files.newOutputStream(path.resolve("down_file2.txt")));
    }
}

InputStream inputStream = new URL("http://example.com/my-file-path.txt").openStream();
IOUtils.copy(inpuStream, Files.newOutputStream(Paths.get("/Users/username/Documents").resolve("file_name.txt")));