File upload reference: http://blog.didispace.com/spring-cloud-starter-dalston-2-4/

File download reference: https://blog.csdn.net/aaronsimon/article/details/82710979

My spring boot and spring cloud versions are:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.1.RELEASE</version>
    <relativePath/>
</parent>

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
</properties>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Finchley.M9</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

To download the config to be configured from the feign file of the service Caller:

import feign.codec.Encoder;
import feign.form.spring.SpringFormEncoder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FeignMultipartSupportConfig {
    @Bean
    public Encoder feignFormEncoder() {
        return new SpringFormEncoder();
    }
}　　

The corresponding feign pom.xml needs to be imported

     <!--feign upload file-->
        <dependency>
            <groupId>io.github.openfeign.form</groupId>
            <artifactId>feign-form</artifactId>
            <version>3.0.3</version>
        </dependency>
        <dependency>
            <groupId>io.github.openfeign.form</groupId>
            <artifactId>feign-form-spring</artifactId>
            <version>3.0.3</version>
        </dependency>
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.3</version>
        </dependency>　　

Service caller controller:

import com.yft.common.annotation.Log;
import com.yft.sys.modules.test.fileclient.FileTestClient;
import feign.Response;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.io.InputStream;

/**
 * feign Example of fuse
 *
 * @author oKong
 */
@RestController
@Slf4j
public class FileController {

    @Autowired
    FileTestClient fileTestClient;

    @Log("File upload test")
    @PostMapping("/upload")
    public Object upload(MultipartFile file) {
        log.info("Use feign Call service, file upload");
        return fileTestClient.upload(file);
    }

    @Log("File download test")
    @RequestMapping(value = "/download", method = RequestMethod.GET)
    public ResponseEntity<byte[]> downFile() {
        log.info("Use feign Call service file download");

        ResponseEntity<byte[]> result = null;
        InputStream inputStream = null;
        try {
            // feign File download
            Response response = fileTestClient.download();
            Response.Body body = response.body();
            inputStream = body.asInputStream();
            byte[] b = new byte[inputStream.available()];
            inputStream.read(b);
            HttpHeaders heads = new HttpHeaders();
            heads.add(HttpHeaders.CONTENT_DISPOSITION, "attachment;filename=lr.xls");
            heads.add(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);

            result = new ResponseEntity<byte[]>(b, heads, HttpStatus.OK);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return result;
    }
}

Write method of feign client of service caller (file upload is mainly the configuration in the first step above, and file download is mainly the response of feign returned):

import com.yft.sys.modules.ClientUrl;
import com.yft.sys.modules.test.fileclient.impl.FileTestClientFallbackFactory;
import feign.Response;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.multipart.MultipartFile;

/**
 * @author lr
 */
@FeignClient(name = ClientUrl.SYSTEM_NAME, fallbackFactory = FileTestClientFallbackFactory.class)
@Component
public interface FileTestClient {

    /**
     * Upload file test
     *
     * @return
     */
    @PostMapping(value = ClientUrl.PRE_REQUEST_RUL + "/file/upload", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    Object upload(MultipartFile file);

    /**
     * Download File Test
     */
    @RequestMapping(value = ClientUrl.PRE_REQUEST_RUL + "/file/download", method = RequestMethod.GET)
    Response download();

}

Service caller feign client exception class:

import com.yft.sys.modules.test.fileclient.FileTestClient;
import feign.Response;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

/**
 * @author lr
 */
@Slf4j
@Component
public class FileTestClientFallbackFactory implements FallbackFactory<FileTestClient> {
    @Override
    public FileTestClient create(Throwable cause) {

        return new FileTestClient() {
            @Override
            public Object upload(MultipartFile file) {
                log.error("fallback; file upload reason was: " + cause.getMessage());
                return null;
            }

            @Override
            public Response download() {
                log.error("fallback; file download reason was: " + cause.getMessage());
                return null;
            }
        };
    }
}

The service provider is the same as the original, no difference

   @PostMapping(value = "upload", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    public R upload(MultipartFile file) {
        try {
            String fileName = file.getOriginalFilename();
            fileName = FileUtils.renameToUUID(fileName);
            String resPath = FileUtils.saveFile(file.getBytes(), filePath, fileName);
//            fileService.save(new FileDO() {{
//                setCreateDate(new Date());
//                setUrl("http://localhost:8004" + filePre + "/"+resPath);
//                setType(1);
//            }});
            return R.ok().put("resPath", resPath);
        } catch (IOException e) {
            e.printStackTrace();
            return R.error("File upload failed");
        }
    }

    @GetMapping("/download")
    public void downLoad(HttpServletResponse response) throws IOException {
　　　　//Here is a sign to download excel files. Download something by yourself
　　　　
        /*First, we define a nested List. The elements of the List are also a List. A List in the inner layer represents a row of data,
        Each row has four cells, and the final list object represents multiple rows of data.*/

        List<String> row1 = CollUtil.newArrayList("aa", "bb", "cc", "dd");
        List<String> row2 = CollUtil.newArrayList("aa1", "bb1", "cc1", "dd1");
        List<String> row3 = CollUtil.newArrayList("aa2", "bb2", "cc2", "dd2");
        List<String> row4 = CollUtil.newArrayList("aa3", "bb3", "cc3", "dd3");
        List<String> row5 = CollUtil.newArrayList("aa4", "bb4", "cc4", "dd4");

        List<List<String>> rows = CollUtil.newArrayList(row1, row2, row3, row4, row5);
        // Then we create the ExcelWriter object and write out the data:

        // Create writer through tool class, and create xls format by default
        ExcelWriter writer = ExcelUtil.getWriter();
        // Write out content at once, using the default style
        writer.write(rows);
        //Out is OutputStream, the target stream to be written out

        //response is the HttpServletResponse object
        response.setContentType("application/vnd.ms-excel;charset=utf-8");
        //test.xls is the file name of the pop-up download dialog box. It cannot be Chinese. Please code the Chinese by yourself
        response.setHeader("Content-Disposition", "attachment;filename=test.xls");
        ServletOutputStream out = response.getOutputStream();

        writer.flush(out);
        // Close writer and free memory
        writer.close();

    }

File upload configuration yml

#Upload file configuration
app:
  filePath: D:/uploaded_files/
  pre: /files

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Value("${app.filePath}")
    String filePath;

    @Value("${app.pre}")
    String pre;

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler(pre + "/**").addResourceLocations("file:///" + filePath);
    }

}

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.UUID;

public class FileUtils {
    public static String saveFile(byte[] file, String filePath, String fileName) {
        int random = (int) (Math.random() * 100 + 1);
        int random1 = (int) (Math.random() * 100 + 1);
        filePath = filePath + random + File.separator + random1 + File.separator;
        File targetFile = new File(filePath);
        if (!targetFile.exists()) {
            targetFile.mkdirs();
        }
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(filePath + fileName);
            FileChannel fileChannel = fileOutputStream.getChannel();
            ByteBuffer buf = ByteBuffer.wrap(file);
            while (fileChannel.write(buf) != 0) {
            }
        } catch (Exception e) {

        } finally {
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        //url
        return random + "/" + random1 + "/" + fileName;
    }

    public static boolean deleteFile(String fileName) {
        File file = new File(fileName);
        // If the file corresponding to the file path exists and is a file, delete it directly
        if (file.exists() && file.isFile()) {
            if (file.delete()) {
                return true;
            } else {
                return false;
            }
        } else {
            return false;
        }
    }

    public static String renameToUUID(String fileName) {
        return UUID.randomUUID() + "." + fileName.substring(fileName.lastIndexOf(".") + 1);
    }
}