业务中需要调用别人提供的接口进行文件上传，但别人的接口只能上传MultipartFile类型的文件（吐槽一下，也不知道是哪个二货设计的这种接口）。所以需要在我们的业务代码中将File转化为MultipartFile。提供两种方法给大家。

一、使用MockMultipartFile类进行转换

这个方法比较简单，代码如下：

import java.io.File;
import java.io.FileInputStream;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.mock.web.MockMultipartFile;
import org.apache.http.entity.ContentType;
File pdfFile = new File("D://test.pdf");
FileInputStream fileInputStream = new FileInputStream(pdfFile);
MultipartFile multipartFile = new MockMultipartFile(pdfFile.getName(), pdfFile.getName(),
					ContentType.APPLICATION_OCTET_STREAM.toString(), fileInputStream);
看上去很简捷，也很舒服，但需要注意，使用MockMultipartFile需要引入spring-test的依赖：版本要跟随你的spring版本定
 
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.0.8.RELEASE</version>
</dependency>
 
但有的项目中没有引这个jar包，而且也不允许自己引入其他jar包，并且，导入这个jar包可能会带来jar包冲突的问题。这时候就没办法了吗？并不，接下来看方法二。
 
二、自己实现MultipartFile接口
 
接口要求传MultipartFile类型，但MultipartFile是个接口，我们无法构造，也就无法传递，方法一其实就是使用了MultipartFile的一个实现类来进行传递的，很不幸，在Spring框架中，MultipartFile的实现类可不多，查看继承关系：
 
看上去还不少哈，其实能用的也就这个MockMultipartFile，第一个是我自己实现的，第二个是个内部类，第三个了不得，里面有FileItem这么个类，又要依赖于别的jar包，所以都不方便，只有这个MockMultipartFile，我们点进去，干干净净，就他了，为了少引一个jar包，我们就模仿MockMultipartFile自己实现MultipartFile。
 
有同学说，是不是实现挺麻烦呢，不，一点也不，步骤如下：
 
新建一个类，随便叫啥名字都可以，比如，我的类叫MultipartFileDto，去实现MultipartFile接口。然后找到MockMultipartFile类的源码，拷贝到自己这个类里面，然后，就没有然后了，完事。当然你懒直接拷贝我的代码就可以了。
 
MultipartFileDto的代码如下：
 
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
 * @Author: szz
 * @Date: 2019/1/16 下午4:33
 * @Version 1.0
 * 负责将InputStream转换MultipartFile,可以少引一个jar包,本来用的是spring-test-4.3.9中的MockMultipartFile,直接提取出来使用
public class MultipartFileDto implements MultipartFile {
    private final String name;
    private String originalFilename;
    private String contentType;
    private final byte[] content;
     * Create a new MultipartFileDto with the given content.
     * @param name the name of the file
     * @param content the content of the file
    public MultipartFileDto(String name, byte[] content) {
        this(name, "", null, content);
     * Create a new MultipartFileDto with the given content.
     * @param name the name of the file
     * @param contentStream the content of the file as stream
     * @throws IOException if reading from the stream failed
    public MultipartFileDto(String name, InputStream contentStream) throws IOException {
        this(name, "", null, FileCopyUtils.copyToByteArray(contentStream));
     * Create a new MultipartFileDto with the given content.
     * @param name the name of the file
     * @param originalFilename the original filename (as on the client's machine)
     * @param contentType the content type (if known)
     * @param content the content of the file
    public MultipartFileDto(String name, String originalFilename, String contentType, byte[] content) {
        this.name = name;
        this.originalFilename = (originalFilename != null ? originalFilename : "");
        this.contentType = contentType;
        this.content = (content != null ? content : new byte[0]);
     * Create a new MultipartFileDto with the given content.
     * @param name the name of the file
     * @param originalFilename the original filename (as on the client's machine)
     * @param contentType the content type (if known)
     * @param contentStream the content of the file as stream
     * @throws IOException if reading from the stream failed
    public MultipartFileDto(String name, String originalFilename, String contentType, InputStream contentStream)
            throws IOException {
        this(name, originalFilename, contentType, FileCopyUtils.copyToByteArray(contentStream));
    @Override
    public String getName() {
        return this.name;
    @Override
    public String getOriginalFilename() {
        return this.originalFilename;
    @Override
    public String getContentType() {
        return this.contentType;
    @Override
    public boolean isEmpty() {
        return (this.content.length == 0);
    @Override
    public long getSize() {
        return this.content.length;
    @Override
    public byte[] getBytes() throws IOException {
        return this.content;
    @Override
    public InputStream getInputStream() throws IOException {
        return new ByteArrayInputStream(this.content);
    @Override
    public void transferTo(File dest) throws IOException, IllegalStateException {
        FileCopyUtils.copy(this.content, dest);
他的使用方式跟MockMultipartFile一模一样，我就是直接拷贝的嘛。直接new出来就完事了。
 
MultipartFile multipartFile = new MultipartFileDto("temp.jpg","temp.jpg",httpEntity.getContentType().getValue(), inputStream);
三、一个非常坑的地方
 
我是使用的Feign的方式进行上传，feign的接口如下：
 
大家看红框的地方，我已经指定了上传文件的key为file，接下来进行调用，代码如下：
 
我使用了 public MultipartFileDto(String name, String originalFilename, String contentType, byte[] content) 这个构造方法，第一个参数name我开始写的就是realFIle的文件名，结果老是报远程服务找不到，经过我司老司机的一顿调试，发现，我们在接口的定义的@RequestPart("file") MultipartFile file中的@RequestPart("file")是无效的，这里定义的file不是请求参数的key，相当于匹配不到对应的方法，所以会报服务找不到。
 
而MultipartFileDto构造方法中的第一个参数name才是请求参数的key，接口中要求第一个参数是file，所以构造方法中的第一个参数写死为"file"，这样再去调用就没问题了。
 
接口设计者应该考虑到接口的通用性，把接收参数设计成MultipartFile看似是一种MVC的方式，其实却是非常不好的，我们来对比一下阿里云的OSS和腾讯云的COS接口设计，大家一看便知。以Java的SDK为例：
 
1.阿里云的文件上传SDK
 
https://help.aliyun.com/document_detail/61872.html?spm=5176.8465980.0.0.44781450Rethay
 
阿里云的上传做的极为丰富，我们只拿简单上传来对照，简单上传分为：
 
流式上传：使用ossClient.putObject上传数据流到OSS。分文上传字符串、上传Byte数组、上传网络流、上传文件流。
 
// 上传字符串。
String content = "Hello OSS";
ossClient.putObject("<yourBucketName>", "<yourObjectName>", new ByteArrayInputStream(content.getBytes()));
// 上传Byte数组。
byte[] content = "Hello OSS".getBytes();
ossClient.putObject("<yourBucketName>", "<yourObjectName>", new ByteArrayInputStream(content));
// 上传网络流。
InputStream inputStream = new URL("https://www.aliyun.com/").openStream();
ossClient.putObject("<yourBucketName>", "<yourObjectName>", inputStream);
// 上传文件流。
InputStream inputStream = new FileInputStream("<yourlocalFile>");
ossClient.putObject("<yourBucketName>", "<yourObjectName>", inputStream);
 
// 上传文件。<yourLocalFile>由本地文件路径加文件名包括后缀组成，例如/users/local/myfile.txt。
ossClient.putObject("<yourBucketName>", "<yourObjectName>", new File("<yourLocalFile>"));
2.腾讯云的文件上传SDK
 
我司用的就是腾讯云的对象存储，不得不再次吐槽一下。
 
https://cloud.tencent.com/document/product/436/6474
 
腾讯云上传做的很简陋，接下来看看API，跟上传相关的就一个PUT Object，只能传File格式。
 
    // 指定要上传的文件
    File localFile = new File("exampleobject");
    // 指定要上传到的存储桶
    String bucketName = "examplebucket-1250000000";
    // 指定要上传到 COS 上对象键
    String key = "exampleobject";
    PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, key, localFile);
    PutObjectResult putObjectResult = cosClient.putObject(putObjectRequest);
 
不解释，高下立判！
 
我的微信公众号：架构真经（id：gentoo666），分享Java干货，高并发编程，热门技术教程，微服务及分布式技术，架构设计，区块链技术，人工智能，大数据，Java面试题，以及前沿热门资讯等。每日更新哦！
 
参考资料：
 
https://blog.csdn.net/hui008/article/details/81703342
 
                    业务中需要调用别人提供的接口进行文件上传，但别人的接口只能上传MultipartFile类型的文件（吐槽一下，也不知道是哪个二货设计的这种接口）。所以需要在我们的业务代码中将File转化为MultipartFile。提供两种方法给大家。一、使用MockMultipartFile类进行转换这个方法比较简单，代码如下：import java.io.File;import java.io...
				
可以看到MultipartFile是个接口
转成MultipartFile格式则需要转成实现MultipartFile接口的实现类即可，如下选择转成用MockMultipartFile实现
首先：需要先引入依赖包
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-test</artifactId>
	<version>5.3.9</
				
参考：https://blog.csdn.net/weixin_39973810/article/details/90696781
MutipartFile是spring里面定义的接口，它封装了用户在上传图片时所包含的所有信息，但是有些时候我们要将file转换成MutipartFile，才能在保持原有代码逻辑的情况下方便代码的调整，但是file不能直接转换成MutipartFile，现在就要教大家如何将file转换成MutipartFile。
maven:
<!-- https://mvnrepo
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
</dependency>
下面是具体代码：
package com.leiyuke.fil
* @throws Exception
public static File multipartFileToFile(MultipartFile file) throws Exception {
    File toFile = null;
    if (file.equals("") || file.getSize() <= 0) {
        file = null;
    } else {
				
在做 jsp 上传图片时，把 java 代码直接改成 jsp，上传时产生 如下异常: 2012-12-31 8:59:21 org.apache.catalina.core.StandardWrapperValve invoke 严重: Servlet.service() for servlet jsp threw exception java.io.IOException: Stream closed … 百思不得其解，翻出 jsp 转成 servlet 后的代码。如下(很很的醒目一下)：  代码如下: … }catch(Exception e){ e.printStackTrace(); 
				
开发场景:
文件上传接口的接收参数类型为MultipartFile,而我需要对数据库进行铺基础数据,就需要遍历本地文件夹,这样获取的是File类型的文件,所以需要对File进行类型转换,直接强转类型运行时会报错。需要使用流进行转换。
类型转换代码:
//需要导的jar包
import java.io.File;
import java.io.FileInputStream;
import ...
Java中的File对象可以通过以下方式转换为MultipartFile对象：
1. 创建一个MultipartFile对象，使用File对象的名称和内容类型作为参数。
MultipartFile multipartFile = new MockMultipartFile(file.getName(), file.getName(),
                ContentType.APPLICATION_OCTET_STREAM.toString(), new FileInputStream(file));
2. 使用Spring的MultipartFile对象的实现类CommonsMultipartFile，调用其构造函数，将File对象作为参数。
MultipartFile multipartFile = new CommonsMultipartFile(fileItem);
其中，fileItem是org.apache.commons.fileupload.FileItem对象，可以通过以下方式获取：
DiskFileItemFactory factory = new DiskFileItemFactory();
ServletFileUpload upload = new ServletFileUpload(factory);
List<FileItem> items = upload.parseRequest(request);
FileItem fileItem = items.get();
以上是两种常见的将Java中的File对象转换为MultipartFile对象的方法。   
### 回答2：
Java中的File类代表文件和目录路径名的抽象表示，而MultipartFile是Spring框架中的一个接口，用于表示上传的文件和相关的信息。
在将Java File对象转换为MultipartFile时，可以使用Spring框架中的MultipartFile类的实现类CommonsMultipartFile来实现。
具体实现方式如下：
1. 导入相关依赖包
在pom.xml文件中添加以下依赖：
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.5</version>
</dependency>
2. 创建File对象
使用Java File类的构造函数创建一个文件对象，例如：
File file = new File("D:/test.txt");
3. 将File对象转换为MultipartFile对象
使用CommonsMultipartFile类的构造函数将File转换为MultipartFile对象：
MultipartFile multipartFile = new CommonsMultipartFile(fileItem);
在转换时需要将File对象转换为FileItem对象，可以使用以下代码获取：
FileItem fileItem = new DiskFileItem("mainFile", Files.probeContentType(file.toPath()), false, file.getName(), (int) file.length(), file.getParentFile());
完整的代码如下：
File file = new File("D:/test.txt");
FileItem fileItem = new DiskFileItem("mainFile", Files.probeContentType(file.toPath()), false, file.getName(), (int) file.length(), file.getParentFile());
try {
    FileInputStream inputStream = new FileInputStream(file);
    OutputStream outputStream = fileItem.getOutputStream();
    IOUtils.copy(inputStream, outputStream);
    multipartFile = new CommonsMultipartFile(fileItem);
} catch (Exception e) {
    e.printStackTrace();
上述代码中的IOUtils.copy方法用于将FileInputStream中的文件内容复制到FileItem的OutputStream中。
4. 使用MultipartFile对象进行上传
有了MultipartFile对象之后，可以直接将其上传到服务器，例如：
@PostMapping("/uploadFile")
public String uploadFile(@RequestParam("file") MultipartFile file) {
    // ... do something
    return "success";
以上就是Java File对象转换为MultipartFile对象的具体实现方法，希望对你有所帮助。   
### 回答3：
Java中的文件(File)和Spring框架中的MultipartFile是不同的类型，文件只是一组二进制数据，而Multipartfile是客户端上传的文件的封装，包含了文件名、文件类型和文件内容。
如果需要将一个Java中的文件转成Multipartfile，需要借助于Spring的MultipartFile类提供的构造函数。具体的实现可以参考以下代码：
File file = new File("path/to/file");
String fileName = file.getName();
String contentType = Files.probeContentType(file.toPath());
byte[] content = Files.readAllBytes(file.toPath());
// 使用MultipartFile的构造函数将文件封装成MultipartFile类型
MultipartFile multipartFile = new MockMultipartFile(fileName, fileName, contentType, content);
这里使用Java 7的“Files”类读取文件的内容，并使用MockMultipartFile类来构造MultipartFile对象。MockMultipartFile类是Spring框架提供的，可以用于测试等场景下模拟文件上传，但实际使用中可以根据具体需求选择其他MultipartFile类的实现。
需要注意的是，上述代码中的MultipartFile对象是通过构造函数创建的，而不是从客户端上传的文件中直接获取的。如果需要在代码中处理客户端上传的文件，可以通过使用Springframework的MultipartHttpServletRequest来实现，具体可参考Spring官方文档。