feign实现文件上传下载

已于 2023-07-11 10:51:20 修改
阅读量879 收藏 2
点赞数 1
分类专栏： 知识共享 文章标签： java spring cloud
于 2023-07-11 10:34:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lizx1018/article/details/131654926
版权 
 /**
     * 附件上传
     */
    @PostMapping("/upload")
    @ApiOperation("附件上传")
    public ResultEntity<FileAttachmentRespVO> upload(@RequestParam("file") MultipartFile file, @RequestParam(value = "type", required = false) Integer type) {
        return ResultEntity.success(contractService.upload(file, type));
    }

/**
     * 附件下载
     */
    @GetMapping("/download")
    @ApiOperation("附件下载")
    public ResultEntity<Void> download(@RequestParam String downloadFileName, HttpServletResponse response) {
        contractService.download(downloadFileName, response);
        return ResultEntity.success();
    }






public FileAttachmentRespVO upload(MultipartFile file, Integer type) {
        // 校验文件后缀
        String originalFilename = file.getOriginalFilename();
        if (!originalFilename.contains(".")) {
            throw new BusinessRuntimeException(ResultCodeEnum.FILE_NOT_SUFFIX);
        }
        
        //校验上传文件大小
        double fileSize = (double) file.getSize() / 1048576;
        if (type != null){
            switch (type) {
                case 1:
                    if (fileSize > 10) {
                        throw new BusinessRuntimeException(ResultCodeEnum.DEFAULT_CHECK_FAILURE, "上传单个文件不能大于10M");
                    }
                    break;
            }
        }else {
            if (fileSize > 200) {
                throw new BusinessRuntimeException(ResultCodeEnum.DEFAULT_CHECK_FAILURE, "上传单个文件不能大于200M");
            }
        }

        ResultEntity<FileUploadInfoDTO> result = fileRemoteClient.fileUpload(file);
        return ResultEntityUtil.toVoData(result, FileAttachmentRespVO.class);
    }


 public void download(String downloadFileName, HttpServletResponse response) {
        Response remoteResponse = fileRemoteClient.download(downloadFileName, DownloadTypeEnum.ATACHMENT.getEnumValue());
        //原文件名称
        Collection<String> collection = remoteResponse.headers().get("fileName");
        String fileName = "";
        Optional<String> first = collection.stream().findFirst();
        if (first.isPresent()) {
            fileName = first.get();
        }
        try (InputStream inputStream = remoteResponse.body().asInputStream();
             ServletOutputStream outputStream = response.getOutputStream()) {
            response.addHeader("Content-Disposition", "attachment; filename=" + fileName);
            byte[] b = new byte[1024];
            int len;
            //从输入流中读取一定数量的字节，并将其存储在缓冲区字节数组中，读到末尾返回-1
            while ((len = inputStream.read(b)) > 0) {
                outputStream.write(b, 0, len);
            }
        } catch (IOException e) {
            log.info(EnvConstant.DOWNLOAD_FAILED + e);
        }
    }


@Getter
@AllArgsConstructor
/**
 * 文件下载方式枚举
 */
public enum DownloadTypeEnum implements CommonEnum {

    ON_LINE(1, "在线预览"),
    ATACHMENT(2, "附件下载")
    ;

    private final Integer enumValue;
    private final String enumText;

}



/**
 * 文件服务feign客户端
 *
 * @author LZX
 * @version 1.0
 * @since 2022/07/08 上午10:45
 */
@FeignClient(name = "${feign-service.file.name}",
        url = "${feign-service.file.url}",
        contextId = "file"
)
@Component
public interface FileRemoteClient extends FileRemote {

    @GetMapping(value = "file/downloadv2")
    @ApiOperation("文件下载")
    Response download(@RequestParam(value = "fileName") String fileName, @RequestParam(value = "type") Integer type);
}




public interface FileRemote {

    /**
     * 文件上传
     */
    @PostMapping(value = "file/upload", produces = MediaType.APPLICATION_JSON_UTF8_VALUE, consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    @ApiOperation("文件上传")
    ResultEntity<FileUploadInfoDTO> fileUpload(@RequestPart MultipartFile file);

/**
     * 文件下载
     */
    @GetMapping(value = "file/download")
    @ApiOperation("文件下载")
    @Deprecated
    void download(@RequestParam(value = "fileName") String fileName,@RequestParam(value = "type") Integer type, HttpServletResponse response);

}




/**
 * @author Lizx
 * @date 2022/06/30
 * @what 描述：文件上传相关
 */
@Api(tags = "【公共 文件接口】 FileController", value = "【公共 文件接口】 FileController")
@RestController
@Slf4j
public class FileController implements FileRemote {

    @Autowired
    private FileService fileService;

    @Override
    public ResultEntity<FileUploadInfoDTO> fileUpload(MultipartFile file) {
        if (file.isEmpty() || file.getSize() == 0) {
            return (ResultEntity<FileUploadInfoDTO>) ResultEntity.failed(ResultCodeEnum.FILE_NOT_NULL, ResultCodeEnum.FILE_NOT_NULL.getMsg(), null);
        }
        return fileService.upload(file);
    }

    /**
     * (value = "file")
     * 文件下载
     *
     * @param fileName
     * @param type
     */

    public void download(String fileName, Integer type) {
        int i = 1;
    }


    @Override
    @GetMapping(value = {"file/download", "file/downloadv2"})
    public void download(String fileName, Integer type, HttpServletResponse response) {
        String bucket = fileService.getDbBucket(fileName);
        DownloadResult downloadResult = fileService.download(bucket, fileName);
        if (!downloadResult.getResult()) {
            throw new BusinessRuntimeException(ResultCodeEnum.FILE_NOT_EXIST);
        }

        if (DownloadTypeEnum.ON_LINE.getEnumValue().equals(type)) {
            // 按照在线预览方式下载
            FileUtils.toOnline(downloadResult, response);
        }
        if (DownloadTypeEnum.ATACHMENT.getEnumValue().equals(type)) {
            // 按照附件方式下载
            String name = fileService.getFileOldName(fileName);
            toAttachment(downloadResult, response, name);
        }
    }

    public void toAttachment(DownloadResult downloadResult, HttpServletResponse response, String name) {
        InputStream inputStream = downloadResult.getInputStream();
        response.reset();
        response.setContentType("application/octet-stream");
        if (StringUtils.isEmpty(name)) {
            name = downloadResult.getFileName();
        }

        try {
            response.setHeader("fileName", URLEncoder.encode(name, "UTF-8"));
            response.addHeader("Content-Disposition", "attachment; filename=" + URLEncoder.encode(name, "UTF-8"));
            ServletOutputStream outputStream = response.getOutputStream();
            byte[] b = new byte[1024];

            int len;
            while ((len = inputStream.read(b)) > 0) {
                outputStream.write(b, 0, len);
            }

            inputStream.close();
            outputStream.flush();
        } catch (IOException var7) {
            log.error("download result to attachment error !", var7);
        }

    }
}






/**
 * @author Lizx
 * @date 2022/06/30
 * @what 描述：
 */
@Slf4j
@Service
public class FileService {

    @Resource
    AmazonS3Service amazonS3Service;
    @Autowired
    private FileSpInfoDao fileSpInfoDao;
    @Autowired
    private FileUploadDao fileUploadDao;
    @Resource
    private FileEnvConfig fileEnvConfig;

    /**
     * @param file
     * @param
     * @return
     * @author lizx
     * @date 2022/06/30
     * @what 描述: 文件上传
     */
    public ResultEntity upload(MultipartFile file) {

        String bucket = getBucket();

        String url = "";
        if (ServiceClientEnum.CONTRACT_CENTER == RequestHelper.getRequestServiceClient()) {
            url = fileEnvConfig.getContractEndpoint();
        }else if (ServiceClientEnum.DIRECT_ORDER == RequestHelper.getRequestServiceClient()) {
            url = fileEnvConfig.getOrderEndpoint();
        }else{
            throw new BusinessRuntimeException(ResultCodeEnum.DEFAULT_THIRD_SERVICE_ERROR,"未知服务异常");
        }

        long startTime = System.currentTimeMillis();
        String originalFilename = file.getOriginalFilename();
        String suffix = originalFilename.substring(originalFilename.lastIndexOf(".") + 1);
        String key = "";
        String urlStr = null;
        long fileSize = file.getSize();
        try {
            UploadResult upload = amazonS3Service.upload(bucket, file);
            if (!upload.getResult()) {
                return ResultEntity.failed(ResultCodeEnum.FILE_UPLOAD_FAILED,ResultCodeEnum.FILE_UPLOAD_FAILED.getMsg(),null);
            }
            key = upload.getFileName();

            urlStr = url + "/" + bucket + "/" + upload.getFileName();
        } catch (Exception e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        log.info("上传到S3耗时：{}", endTime - startTime);

        FileUploadInfoPO fileUploadInfoPO = new FileUploadInfoPO();

        fileUploadInfoPO.setTenantId(1);
        fileUploadInfoPO.setSpId(NumberConstants.INTEGER_1);
        // 附件类型
        fileUploadInfoPO.setFileName(key);
        fileUploadInfoPO.setFileOldName(originalFilename);
        fileUploadInfoPO.setFileSize(fileSize);
        fileUploadInfoPO.setFileExt(suffix);
        fileUploadInfoPO.setFileUrl(urlStr);
        fileUploadInfoPO.setIsDeleted(false);
        fileUploadInfoPO.setBucket(bucket);
        fileUploadInfoPO.setCreateTime(new Date());
        fileUploadInfoPO.setUpdateTime(new Date());

        fileUploadDao.addFileUpload(fileUploadInfoPO);
        FileUploadInfoDTO fileUploadInfoDTO = BeanUtils.copyProperties(fileUploadInfoPO, FileUploadInfoDTO.class);
        fileUploadInfoDTO.setFileName(originalFilename);
        fileUploadInfoDTO.setDownloadFileName(key);
        return ResultEntity.success(fileUploadInfoDTO);
    }



 public DownloadResult download(String defaultBucket, String fileName) {
        return amazonS3Service.download(defaultBucket, fileName);
    }


}



/**
 * @author Lizx
 * @date 2022/06/30
 * @what 描述：
 */
@Slf4j
@Service
public class AmazonS3Service {

    @Resource
    @Qualifier("contract")
    private AmazonS3 amazonS3Contract;

    @Resource(name = "order")
    private AmazonS3 amazonS3Order;


    public UploadResult upload(String bucket, MultipartFile multipartFile) {
        Assert.notNull(multipartFile,"file cannot be null");
        String fileExtName = "";
        if(multipartFile.getOriginalFilename() != null){
            String [] nameArr = multipartFile.getOriginalFilename().split("\\.");
            if(nameArr.length > 1){
                fileExtName = nameArr[nameArr.length-1];
            }
        }
        String fileName = genFileName(fileExtName);
        return uploadOne(bucket,fileName,multipartFile);
    }




    public UploadResult uploadOne(String bucket, String fileName, MultipartFile multipartFile) {
        Assert.notNull(bucket,"bucket can not be null");
        ObjectMetadata objectMetadata = new ObjectMetadata();
        objectMetadata.setContentType(multipartFile.getContentType());
        objectMetadata.setContentLength(multipartFile.getSize());
        try {
            if (ServiceClientEnum.CONTRACT_CENTER == RequestHelper.getRequestServiceClient()) {
                amazonS3Contract.putObject(new PutObjectRequest(bucket, fileName, multipartFile.getInputStream(), objectMetadata)
                        .withCannedAcl(CannedAccessControlList.PublicRead));
            }else if (ServiceClientEnum.DIRECT_ORDER == RequestHelper.getRequestServiceClient()) {
                amazonS3Order.putObject(new PutObjectRequest(bucket, fileName, multipartFile.getInputStream(), objectMetadata)
                        .withCannedAcl(CannedAccessControlList.PublicRead));
            }else{
                throw new BusinessRuntimeException(ResultCodeEnum.DEFAULT_THIRD_SERVICE_ERROR,"未知服务异常");

            }
        }catch (Exception e){
            log.error("ironhide upload failed, type:aws,reason:{}",e);
            return new UploadResult(false,e.getMessage());
        }
        UploadResult uploadResult = new UploadResult(true,bucket,fileName);
        uploadResult.setOriginalFilename(multipartFile.getOriginalFilename());
        uploadResult.setFileSize(multipartFile.getSize());
        return uploadResult;
    }


    protected String genFileName(String fileExtName) {
        if(fileExtName == null){
            fileExtName = "";
        }
        //生成一个文件名
        return UUID.randomUUID().toString().replaceAll("-", "")
                + RandomStringUtils.randomAlphanumeric(4)
                + "." + fileExtName;
    }



    public DownloadResult download(String bucket, String fileName) {
        Assert.notNull(bucket,"bucket can not be null");
        DownloadResult downloadResult = new DownloadResult();
        try {

            downloadResult.setResult(true);
            downloadResult.setBucket(bucket);
            downloadResult.setFileName(fileName);

            if (ServiceClientEnum.CONTRACT_CENTER == RequestHelper.getRequestServiceClient()) {
                S3Object s3Object = amazonS3Contract.getObject(bucket,fileName);
                downloadResult.setInputStream(s3Object.getObjectContent());
            }else if (ServiceClientEnum.DIRECT_ORDER == RequestHelper.getRequestServiceClient()) {
                S3Object s3Object = amazonS3Order.getObject(bucket,fileName);
                downloadResult.setInputStream(s3Object.getObjectContent());
            }else{
                throw new BusinessRuntimeException(ResultCodeEnum.DEFAULT_THIRD_SERVICE_ERROR,"未知服务异常");
            }

        }catch (Exception e){
            log.error("ironhide download failed, type:aws,reason:{}",e);
            downloadResult.setResult(false);
            return downloadResult;
        }
        return downloadResult;
    }


}





/**
 * @Author: lzx
 * @Date: 2022/11/11 16:21
 * @What: 描述：
 */
@Getter
@Setter
@Configuration
public class AmazonS3Configure {

    @Resource
    private FileEnvConfig fileEnvConfig;

    /**
     * 初始化生成AmazonS3 客户端配置
     * @return
     */
    @Bean(name = "contract")
    public AmazonS3 s3clientContract() {

        AwsClientBuilder.EndpointConfiguration endpointConfig =
                new AwsClientBuilder.EndpointConfiguration(fileEnvConfig.getContractEndpoint(),  Region.getRegion(Regions.CN_NORTH_1).getName());

        AWSCredentials awsCredentials = new BasicAWSCredentials(fileEnvConfig.getContractAccessKey(),fileEnvConfig.getContractSecretKey());
        AWSCredentialsProvider awsCredentialsProvider = new AWSStaticCredentialsProvider(awsCredentials);
        ClientConfiguration clientConfig = new ClientConfiguration();
        clientConfig.setProtocol(Protocol.HTTP);

        AmazonS3 S3client = AmazonS3Client.builder()
                .withEndpointConfiguration(endpointConfig)
                .withClientConfiguration(clientConfig)
                .withCredentials(awsCredentialsProvider)
                .disableChunkedEncoding()
                .withPathStyleAccessEnabled(true)
                .withForceGlobalBucketAccessEnabled(true)
                .build();
        return  S3client;
    }

    /**
     * 初始化生成AmazonS3 客户端配置
     * @return
     */
    @Bean(name = "order")
    public AmazonS3 s3clientOrder() {

        AwsClientBuilder.EndpointConfiguration endpointConfig =
                new AwsClientBuilder.EndpointConfiguration(fileEnvConfig.getOrderEndpoint(),  Region.getRegion(Regions.CN_NORTH_1).getName());

        AWSCredentials awsCredentials = new BasicAWSCredentials(fileEnvConfig.getOrderAccessKey(),fileEnvConfig.getOrderSecretKey());
        AWSCredentialsProvider awsCredentialsProvider = new AWSStaticCredentialsProvider(awsCredentials);
        ClientConfiguration clientConfig = new ClientConfiguration();
        clientConfig.setProtocol(Protocol.HTTP);

        AmazonS3 S3client = AmazonS3Client.builder()
                .withEndpointConfiguration(endpointConfig)
                .withClientConfiguration(clientConfig)
                .withCredentials(awsCredentialsProvider)
                .disableChunkedEncoding()
                .withPathStyleAccessEnabled(true)
                .withForceGlobalBucketAccessEnabled(true)
                .build();
        return  S3client;
    }




}






s3:
  contract:
    # 对象存储服务器端点地址
    serviceEndpoint: http://lzx.com:8080
    # 访问授权 s3必填
    accessKey: 3X66RXHSY8CHSGAJ
    secretKey: SCSXjskcfsXsjwf//7HXSu8hx7Xshr7J
    defaultBucket: contract-tst
    region: us-east-1
  order:
    serviceEndpoint: http://lzx.com:8080
    accessKey: Snhv7shdkHskr8sJ
    secretKey: u8hx7Xshr7JSCsXsjwf//7HXSSXjskcn
    defaultBucket: order-tst
    region: us-east-1
 

feign-service:
  file:
    name: lzx-file-service
    url:

lizx1018
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Feign实现跨服务文件上传下载
08-26
Feign实现跨服务文件上传下载 Feign是一种基于Java的声明式RESTful服务调用客户端，提供了简洁、灵活、可扩展的API调用方式。今天，我们将详细介绍Feign实现跨服务文件上传下载的相关知识点。 Feign实现跨服务文件...
使用Feign实现微服务间文件下载
08-26
在下面的示例中，我们使用Feign上传文件接口来实现文件下载。 其次，我们需要在服务消费者端使用Feign来调用服务提供者端的文件下载接口。在下面的示例中，我们使用Feign来调用服务提供者端的文件下载接口，并使用...
工具篇--Spring-Cloud--feign 通过feign 接口完成文件的下载
拽着尾巴的鱼儿的博客
12-28 2265
通常在spring-boot 项目中，对于文件的下载都是直接调用到对应的服务中，而不是通过feign 接口获取文件；有时我们在对接外部接口时，因为权限等问题，不能直接暴露文件服务，会有一个专门对外的服务进行对接，但是我们又要利用现有的文件服务逻辑，此时可以考虑使用feign 完成文件的获取。本文通过feign 接口完成文件的下载。
fegin接口下载文件
liaoxiaolin520的博客
05-13 3089
服务提供端这里结合的是minio文件服务器： controller，这里一定是void，不要指定返回内容 @RequestMapping("/file") @RestController public class FileSystemController { @Autowired private FileSystemService fileSystemService; @GetMapping("/download") public void getDownloadI
Feign实现文件传输
最新发布
qq_40617729的博客
05-15 771
Feign解决文件传输问题
Spring上传和下载以及Feign调用时操作
qq_33642970的博客
02-20 1972
SpringMVC上传和下载文件/跨服务上传和下载
Feign实现文件上传下载
HongYu012的博客
02-18 3364
Feign框架对于文件上传消息体格式并没有做原生支持，需要集成模块feign-form来实现。 独立使用Feign 添加模块依赖： <!-- Feign框架核心 --> <dependency> <groupId>io.github.openfeign</groupId> <artifactId>feign-core</artifactId> <version>11.1</versi..
通过 Feign 进行文件上传
a_tzluy的博客
10-30 5852
转载来源：https://www.cnblogs.com/zjdxr-up/p/13466696.html 项目为spring cloud 项目，项目中对各部分能力业务进行了拆分，将公共的服务能力放在一个模块当中，通过 Feign 的方式 进行调用，feign 调用的本质还是http内部通信请求，实现模块之间的调用。 通过feign进行文件上传时，feign 侧示例代码如下： @FeignClient public interface UploadClient { @PostMapping(value
FeignClient调用内部服务下载文件正确打开方式
m18030221734_1的博客
12-22 438
正确调用一：因为这个返回的保存JSON格式的text文件，所以可以这么转换成实体。FeignClient接口正确定义。controller层。service接口层。文件服务器提供的接口。
SpringCloud使用Feign文件上传、下载
08-26
SpringCloud提供了Feign来帮助我们实现文件上传和下载功能。在本文中，我们将详细介绍如何使用SpringCloud和Feign来实现文件上传和下载功能。 首先，让我们来看一下服务提供方的Java代码。这里，我们使用了`@...
使用Feign扩展包实现微服务间文件上传
08-26
4. 调用Feign接口实现文件的跨服务传输。 遵循以上步骤，就可以有效地在Spring Cloud环境中使用Feign进行文件的上传操作。注意，这只是一个基本示例，实际开发中还需要考虑异常处理、安全性、性能优化等多个方面的...
12.Spring Cloud中使用Feign
05-21
Spring Cloud中使用Feign，将feign框架整合到Spring Cloud之中，实现负载均衡等低耦合客户端
微服务springcloud之feign使用demo
08-13
Feign是一个声明式的Web Service客户端，它能够让Web Service客户端的编写变得更加容易（你只需创建一个接口，并在接口上添加相应注解即可）。除了Feign自带的注解外它还支持JAX-RS注解，SpringCloud又为Feign增加了对SpringMVC注解的支持，同时为了能够使用和Spring Web中默认使用的相同的httpMessageConverter，SpringCloud集成了Ribbon和Eureka，用来在使用Feign时能够为其提供一个负载均衡的HTTP客户端，大神必备神器，导入即用，无需更改配置！
spring cloud feign实现远程调用服务传输文件的方法
08-27
主要介绍了spring cloud feign实现远程调用服务传输文件的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
使用Spring Cloud Feign上传文件的示例
08-28
本篇文章主要介绍了使用Spring Cloud Feign上传文件的示例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring Cloud Feign的文件上传实现的示例代码
08-27
这篇文章将介绍如何使用 Spring Cloud Feign 实现文件上传的示例代码。 服务提供方（接收文件） 在服务提供方，我们可以使用 Spring MVC 的方式来实现文件上传。例如，我们可以创建一个 UploadController，如下所...
Feign远程调用上传和下载文件
爱码猿的博客
02-29 705
在项目中我们通常会将一些基础功能封装在system服务中，然后其他服务统一调用system服务提供的服务。例如文件上传和下载接口，为了统一管理文件我们会把文件上传和下载功能统一封装在system服务内，其他服务调用system对外提供的上传下载接口。
SpringBoot集成OpenFeign实现文件下载
万般皆苦，唯有自渡
07-31 3250
本文介绍了如何在SpringBoot中集成Openfeign, 并以文件下载为案例，介绍了如何使用openfeign，以及使用openfeign下载文件时的注意事项。
feign技巧 - form方式传值(上传文件)
夫礼者的专栏
02-14 2392
feign技巧 - form方式传值
通过实现 Feign 的 RequestInterceptor
08-19
- *3* [通过Feign 扩展 实现Feign 文件上传](https://download.csdn.net/download/AaronSimon/12016390)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值