apache fileupload源码分析

文件上传格式

先来看下含有文件上传时的表单提交是怎样的格式

<form action="/upload/request" method="POST" enctype="multipart/form-data" id="requestForm">
    <input type="file" name="myFile">
    <input type="text" name="user">
    <input type="text" name="password">
    <input type="submit" value="提交">
</form>

form表单提交内容如下

从上面可以看到，含有文件上传的格式是这样组织的。

  • 文件类型字段

    ------WebKitFormBoundaryCvop2jTxU5F6lj6G（分隔符）
Content-Disposition: form-data; name="myFile"; filename="资产型号规格模板1.xlsx"
Content-Type: application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
（换行）
（文件内容）
  • 其他类型字段 
    ------WebKitFormBoundaryCvop2jTxU5F6lj6G（分隔符）
Content-Disposition: form-data; name="user"
（换行）
lg
  • 结束 
    ------WebKitFormBoundaryCvop2jTxU5F6lj6G--（分隔符加上--）

对于上面的文件内容，chrome浏览器是不显示的，换成firefox可以看到，如下图所示

同时我们还可以注意到，不同的浏览器，分隔符是不一样的，在请求头

Content-Type:multipart/form-data; boundary=----WebKitFormBoundaryCvop2jTxU5F6lj6G

中指明了分隔符的内容。

更加详细的上传格式还是参看 rfc文档

文件上传注意点：

  • 一定是post提交，如果换成get提交，则浏览器默认仅仅把文件名作为属性值来上传，不会上传文件内容，如下

  • form表单中一定不要忘了添加 
    enctype="multipart/form-data"

    否则的话，浏览器则不是按照上述的格式来来传递数据的。

上述两点才能保证浏览器正常的进行文件上传。

apache fileupload的解析

参见官方文档： 官方文档

有了上述文件上传的组织格式，我们就需要合理的设计后台的解析方式，下面来看下apache fileupload的使用。先来看下整体的流程图 

Servlets and Portlets

apache fileupload分Servlets and Portlets两种情形来处理。Servlet我们很熟悉，而Portlets我也没用过，可自行去搜索。

判断request是否是Multipart

对于HttpServletRequest来说，另一个不再说明，自行查看源码，判断规则如下：

  • 是否是post请求
  • contentType是否以multipart/开头

见源码：

public static final boolean isMultipartContent(
        HttpServletRequest request) {
    if (!POST_METHOD.equalsIgnoreCase(request.getMethod())) {
        return false;
    }
    return FileUploadBase.isMultipartContent(new ServletRequestContext(request));
}
public static final boolean isMultipartContent(RequestContext ctx) {
    String contentType = ctx.getContentType();
    if (contentType == null) {
        return false;
    }
    if (contentType.toLowerCase(Locale.ENGLISH).startsWith(MULTIPART)) {
        return true;
    }
    return false;
}

对request封装成RequestContext

servlet的输入参数为HttpServletRequest，Portlets的输入参数为ActionRequest，数据来源不同，为了统一方便后面的数据处理，引入了RequestContext接口，来统一一下目标数据的获取。

接口RequestContext的实现类：

  • ServletRequestContext
  • PortletRequestContext

此时RequestContext就作为了数据源，不再与HttpServletRequest和ActionRequest打交道。

上述的实现过程是由FileUpload的子类ServletFileUpload和PortletFileUpload分别完成包装的。

父类FileUpload的子类：

  • ServletFileUpload
  • PortletFileUpload

源码展示如下：

  • ServletFileUpload类

    public List<FileItem> parseRequest(HttpServletRequest request)
    throws FileUploadException {
    return parseRequest(new ServletRequestContext(request));
}
  • PortletFileUpload类 
    public List<FileItem> parseRequest(ActionRequest request)
    throws FileUploadException {
    return parseRequest(new PortletRequestContext(request));
}

上述的parseRequest便完成了整个request的解析过程，内容如下：

public List<FileItem> parseRequest(RequestContext ctx)
        throws FileUploadException {
    List<FileItem> items = new ArrayList<FileItem>();
    boolean successful = false;
    try {
        FileItemIterator iter = getItemIterator(ctx);
        FileItemFactory fac = getFileItemFactory();
        if (fac == null) {
            throw new NullPointerException("No FileItemFactory has been set.");
        }
        while (iter.hasNext()) {
            final FileItemStream item = iter.next();
            // Don't use getName() here to prevent an InvalidFileNameException.
            final String fileName = ((FileItemIteratorImpl.FileItemStreamImpl) item).name;
            FileItem fileItem = fac.createItem(item.getFieldName(), item.getContentType(),
                                               item.isFormField(), fileName);
            items.add(fileItem);
            try {
                Streams.copy(item.openStream(), fileItem.getOutputStream(), true);
            } catch (FileUploadIOException e) {
                throw (FileUploadException) e.getCause();
            } catch (IOException e) {
                throw new IOFileUploadException(format("Processing of %s request failed. %s",
                                                       MULTIPART_FORM_DATA, e.getMessage()), e);
            }
            final FileItemHeaders fih = item.getHeaders();
            fileItem.setHeaders(fih);
        }
        successful = true;
        return items;
    } catch (FileUploadIOException e) {
        throw (FileUploadException) e.getCause();
    } catch (IOException e) {
        throw new FileUploadException(e.getMessage(), e);
    } finally {
        if (!successful) {
            for (FileItem fileItem : items) {
                try {
                    fileItem.delete();
                } catch (Throwable e) {
                    // ignore it
                }
            }
        }
    }
}

分以下两个大步骤：

  • 根据RequestContext数据源得到解析后的数据集合 FileItemIterator
  • 遍历FileItemIterator中的每个item，类型为FileItemStreamImpl，使用FileItemFactory工厂类来将每个FileItemStreamImpl转化成最终的FileItem

由RequestContext数据源得到解析后的数据集合 FileItemIterator

  • FileItemIterator内容如下：

    public interface FileItemIterator {
    boolean hasNext() throws FileUploadException, IOException;
    FileItemStream next() throws FileUploadException, IOException;
}

    这就是一个轮询器，可以假想成FileItemStream的集合，实际上不是，后面会进行介绍

  • FileItemStream则是之前上传文件格式内容 
    ------WebKitFormBoundary77tsMdWQBKrQOSsV
Content-Disposition: form-data; name="user"

lg

    或者

    ------WebKitFormBoundary77tsMdWQBKrQOSsV
Content-Disposition: form-data; name="myFile"; filename="萌芽.jpg"
Content-Type: image/jpeg

(文件内容)

    的封装，代码如下

    public interface FileItemStream extends FileItemHeadersSupport {
    /*流中包含了数值或者文件的内容*/
    InputStream openStream() throws IOException;
    String getContentType();
    /*用来存放文件名，不是文件字段则为null*/
    String getName();
    /*对应input标签中的name属性*/
    String getFieldName();
    /*标识该字段是否是一般的form字段还是文件字段*/
    boolean isFormField();
}

然后我们来具体看下由RequestContext如何解析成一个FileItemIterator的：

public FileItemIterator getItemIterator(RequestContext ctx)
throws FileUploadException, IOException {
    try {
        return new FileItemIteratorImpl(ctx);
    } catch (FileUploadIOException e) {
        // unwrap encapsulated SizeException
        throw (FileUploadException) e.getCause();
    }
}

new了一个FileItemIteratorImpl，来看下具体的过程：

FileItemIteratorImpl(RequestContext ctx)
            throws FileUploadException, IOException {
        if (ctx == null) {
            throw new NullPointerException("ctx parameter");
        }

        String contentType = ctx.getContentType();
        if ((null == contentType)
                || (!contentType.toLowerCase(Locale.ENGLISH).startsWith(MULTIPART))) {
            throw new InvalidContentTypeException(
                    format("the request doesn't contain a %s or %s stream, content type header is %s",
                           MULTIPART_FORM_DATA, MULTIPART_MIXED, contentType));
        }

        InputStream input = ctx.getInputStream();

        @SuppressWarnings("deprecation") // still has to be backward compatible
        final int contentLengthInt = ctx.getContentLength();

        final long requestSize = UploadContext.class.isAssignableFrom(ctx.getClass())
                                 // Inline conditional is OK here CHECKSTYLE:OFF
                                 ? ((UploadContext) ctx).contentLength()
                                 : contentLengthInt;
                                 // CHECKSTYLE:ON

        if (sizeMax >= 0) {
            if (requestSize != -1 && requestSize > sizeMax) {
                throw new SizeLimitExceededException(
                    format("the request was rejected because its size (%s) exceeds the configured maximum (%s)",
                            Long.valueOf(requestSize), Long.valueOf(sizeMax)),
                           requestSize, sizeMax);
            }
            input = new LimitedInputStream(input, sizeMax) {
                @Override
                protected void raiseError(long pSizeMax, long pCount)
                        throws IOException {
                    FileUploadException ex = new SizeLimitExceededException(
                    format("the request was rejected because its size (%s) exceeds the configured maximum (%s)",
                            Long.valueOf(pCount), Long.valueOf(pSizeMax)),
                           pCount, pSizeMax);
                    throw new FileUploadIOException(ex);
                }
            };
        }

        String charEncoding = headerEncoding;
        if (charEncoding == null) {
            charEncoding = ctx.getCharacterEncoding();
        }

        boundary = getBoundary(contentType);
        if (boundary == null) {
            throw new FileUploadException("the request was rejected because no multipart boundary was found");
        }

        notifier = new MultipartStream.ProgressNotifier(listener, requestSize);
        try {
            multi = new MultipartStream(input, boundary, notifier);
        } catch (IllegalArgumentException iae) {
            throw new InvalidContentTypeException(
                    format("The boundary specified in the %s header is too long", CONTENT_TYPE), iae);
        }
        multi.setHeaderEncoding(charEncoding);

        skipPreamble = true;
        findNextItem();
    }

要点：

  • contentType进行判断，是否以multipart开头
  • 判断整个请求流的数据大小是否超过sizeMax最大设置
  • 获取重要的分隔符boundary信息
  • 封装了request请求流的数据，包装为MultipartStream类型
  • 也可以设置通知器，来通知流的读取进度

这里可以看到FileItemIteratorImpl并不是FileItemStreamImpl的集合，其实是FileItemIteratorImpl内部包含了一个FileItemStreamImpl属性。FileItemIteratorImpl的一些重要属性和方法如下：

/*总的数据流*/
private final MultipartStream multi;
/*通知器*/
private final MultipartStream.ProgressNotifier notifier;
/*分隔符*/
private final byte[] boundary;
/*当前已解析到的FileItemStreamImpl对象*/
private FileItemStreamImpl currentItem;

public boolean hasNext() throws FileUploadException, IOException {
    if (eof) {
        return false;
    }
    if (itemValid) {
        return true;
    }
    try {
        return findNextItem();
    } catch (FileUploadIOException e) {
        // unwrap encapsulated SizeException
        throw (FileUploadException) e.getCause();
    }
}

public FileItemStream next() throws FileUploadException, IOException {
    if (eof  ||  (!itemValid && !hasNext())) {
        throw new NoSuchElementException();
    }
    itemValid = false;
    return currentItem;
}
  • findNextItem()方法就是创建新的FileItemStreamImpl来替代当前的FileItemStreamImpl，并更新起始位置。
  • 每次调用FileItemIteratorImpl的hasNext()方法，会创建一个新的FileItemStreamImpl赋值给FileItemStreamImpl属性
  • 每次调用FileItemIteratorImpl的next()方法，就会返回当前FileItemStreamImpl属性的值
  • 创建的每个FileItemStreamImpl都会共享FileItemIteratorImpl的MultipartStream总流，仅仅更新了要读取的起始位置

遍历FileItemIterator，通过FileItemFactory工厂将每一个item转化成FileItem对象

其他应用其实就可以遍历FileItemIteratorImpl拿到每一项FileItemStreamImpl的解析数据了。只是这时候数据

  • 存储在内存中的
  • 每个FileItemStreamImpl都是共享一个总的流，不能被重复读取

我们想把这些文件数据存在临时文件中，就需要使用使用FileItemFactory来进行下转化成FileItem。每个FileItem才是相互独立的，而FileItemStreamImpl则不是，每个FileItem也是对应上传文件格式中的每一项，如下

InputStream getInputStream() throws IOException;
String getContentType();
String getName();
String getFieldName();
boolean isFormField();

FileItemFactory的实现类DiskFileItemFactory即将数据存储在硬盘上，代码如下：

public static final int DEFAULT_SIZE_THRESHOLD = 10240;
/*制定了临时文件的目录*/
private File repository;
/*当数据小于该阈值时存储到内存中，超过时存储到临时文件中*/
private int sizeThreshold = DEFAULT_SIZE_THRESHOLD;

public FileItem createItem(String fieldName, String contentType,
        boolean isFormField, String fileName) {
    DiskFileItem result = new DiskFileItem(fieldName, contentType,
            isFormField, fileName, sizeThreshold, repository);
    FileCleaningTracker tracker = getFileCleaningTracker();
    if (tracker != null) {
        tracker.track(result.getTempFile(), result);
    }
    return result;
}

我们从上面可以看到，其实FileItemFactory的createItem方法，并没有为FileItem的流赋值。再回顾下上文parseRequest方法的源代码，赋值发生在这里

FileItemIterator iter = getItemIterator(ctx);
FileItemFactory fac = getFileItemFactory();
if (fac == null) {
    throw new NullPointerException("No FileItemFactory has been set.");
}
while (iter.hasNext()) {
    final FileItemStream item = iter.next();
    // Don't use getName() here to prevent an InvalidFileNameException.
    final String fileName = ((FileItemIteratorImpl.FileItemStreamImpl) item).name;
    FileItem fileItem = fac.createItem(item.getFieldName(), item.getContentType(),
                                       item.isFormField(), fileName);
    items.add(fileItem);
    try {
        /*这里才是为每一个FileItem的流赋值*/
        Streams.copy(item.openStream(), fileItem.getOutputStream(), true);
    } catch (FileUploadIOException e) {
        throw (FileUploadException) e.getCause();
    } catch (IOException e) {
        throw new IOFileUploadException(format("Processing of %s request failed. %s",
                                               MULTIPART_FORM_DATA, e.getMessage()), e);
    }
    final FileItemHeaders fih = item.getHeaders();
    fileItem.setHeaders(fih);
}

上述FileItem的openStream()方法如下：

public OutputStream getOutputStream()
    throws IOException {
    if (dfos == null) {
        File outputFile = getTempFile();
        dfos = new DeferredFileOutputStream(sizeThreshold, outputFile);
    }
    return dfos;
}

protected File getTempFile() {
    if (tempFile == null) {
        File tempDir = repository;
        if (tempDir == null) {
            tempDir = new File(System.getProperty("java.io.tmpdir"));
        }

        String tempFileName = format("upload_%s_%s.tmp", UID, getUniqueId());

        tempFile = new File(tempDir, tempFileName);
    }
    return tempFile;
}

getTempFile()会根据FileItemFactory的临时文件目录配置repository，创建一个临时文件，用于上传文件。 
这里又用到了commons-io包中的DeferredFileOutputStream类。

  • 当数据数量小于sizeThreshold阈值时，存储在内存中
  • 当数据数量大于sizeThreshold阈值时，存储到传入的临时文件中

至此，FileItem都被创建出来了，整个过程就结束了。

时间： 2024-10-06 15:41:18

apache fileupload源码分析的相关文章

Apache Kafka源码分析 – Broker Server

1. Kafka.scala 在Kafka的main入口中startup KafkaServerStartable, 而KafkaServerStartable这是对KafkaServer的封装 1: val kafkaServerStartble = new KafkaServerStartable(serverConfig) 2: kafkaServerStartble.startup   1: package kafka.server 2: class KafkaServerStartab

Apache Kafka源码分析 - kafka controller

前面已经分析过kafka server的启动过程,以及server所能处理的所有的request,即KafkaApis  剩下的,其实关键就是controller,以及partition和replica的状态机  这里先看看controller在broker server的基础上,多做了哪些初始化和failover的工作   最关键的一句, private val controllerElector = new ZookeeperLeaderElector(controllerContext,

Apache Kafka源码分析 - autoLeaderRebalanceEnable

在broker的配置中,auto.leader.rebalance.enable (false) 那么这个leader是如何进行rebalance的? 首先在controller启动的时候会打开一个scheduler, if (config.autoLeaderRebalanceEnable) { //如果打开outoLeaderRebalance,需要把partiton leader由于dead而发生迁徙的,重新迁徙回去 info("starting the partition rebalan

Apache Kafka源码分析 – Controller

One of the brokers is elected as the controller for the whole cluster. It will be responsible for: Leadership change of a partition (each leader can independently update ISR) New topics; deleted topics Replica re-assignment After the controller makes

Apache Kafka源码分析 – Log Management

LogManager LogManager会管理broker上所有的logs(在一个log目录下),一个topic的一个partition对应于一个log(一个log子目录) 首先loadLogs会加载每个partition所对应的log对象, 然后提供createLog,getLog,deleteLog之类的管理接口 并且会创建些后台线程来进行,cleanup,flush,checkpoint生成之类的工作 Log Log只是对于LogSegments的封装,包含loadSegments,ap

Apache Kafka源码分析 - KafkaApis

kafka apis反映出kafka broker server可以提供哪些服务, broker server主要和producer,consumer,controller有交互,搞清这些api就清楚了broker server的所有行为   handleOffsetRequest 提供对offset的查询的需求,比如查询earliest,latest offset是什么,或before某个时间戳的offset是什么 try { // ensure leader exists // 确定是否是l

Apache Kafka源码分析 - ReplicaStateMachine

startup 在onControllerFailover中被调用, /** * Invoked on successful controller election. First registers a broker change listener since that triggers all * state transitions for replicas. Initializes the state of replicas for all partitions by reading fro

Apache Spark源码走读（六）Task运行期之函数调用关系分析 &amp;存储子系统分析

<一>Task运行期之函数调用关系分析 概要 本篇主要阐述在TaskRunner中执行的task其业务逻辑是如何被调用到的,另外试图讲清楚运行着的task其输入的数据从哪获取,处理的结果返回到哪里,如何返回. 准备 spark已经安装完毕 spark运行在local mode或local-cluster mode local-cluster mode local-cluster模式也称为伪分布式,可以使用如下指令运行 MASTER=local[1,2,1024] bin/spark-shell

Apache Spark源码走读（七）Standalone部署方式分析&amp;sql的解析与执行

<一>Standalone部署方式分析 楔子 在Spark源码走读系列之2中曾经提到Spark能以Standalone的方式来运行cluster,但没有对Application的提交与具体运行流程做详细的分析,本文就这些问题做一个比较详细的分析,并且对在standalone模式下如何实现HA进行讲解. 没有HA的Standalone运行模式 先从比较简单的说起,所谓的没有ha是指master节点没有ha. 组成cluster的两大元素即Master和Worker.slave worker可以有