文件上传原理实现

客户端浏览器是怎样上传数据的呢？服务器端如何接收上传的文件数据？

级别： 初级

王延成 (王延成), 作者/编者,

2004 年 9 月 01 日

文章主要描述http表单上传二进制数据流规范的简单实现

---

（一）关于Form表单上传文件规范

总结个人在对新技术、新事物的学习和解决问题的过程，深刻体会到多理解掌握技术基础理论知识再加上相应的实践，的确能帮助我们在解决某些问题的时候起到事半功倍的效果。

以前上传文件类似的功能都是采用第三方组件来做的，真的是基于接口编程了。不出问题还好，真要是出现问题解决起来太不舒服了，往往属于那种拆了西墙补东墙的策略。最近，在做文件上传时学习了一些 关于html>form上传数据的格式规范，依据人家定义的规范做了一些简单的工作。。。算是实现了个小轮子吧。

---

（二）实现

1、规则

1.1 上传数据块的分割规则

基于html form表单上传的数据都是以类似-----------------------------7da3c8e180752{0x130x10}这样的分割符来标记一块数据的起止，可不要忘记后面的两个换行符。关于换行符有三种，如下：

操作系统	换行符描述	原始标记	ascii码	十六进制
Window	Window的换行符是两个	//r//n	1310	0x0d0x0a
Unix	Unix的换行符是一个	//n	10	0x0a
Mac OS	Mac OS的换行符是一个	//r	13	0x0d
这块没有对Unix、MacOS上做测试，只在Window上测试了换行是两个(0x0d0x0a)

1.2 注意在后台从request中取得分割串少两个--，在看下面的原始数据你会发现流的最后是以--结束的。

1.3 上传的原始数据串，本来中文字符是乱码的。为了清晰一些使用字符集UTF-8转了下码。

-----------------------------7da3c8e180752
Content-Disposition: form-data; name="fileData1"; filename="C:/abcdef.log"
Content-Type: application/octet-stream

HelloWorld
HelloWorld

-----------------------------7da3c8e180752
Content-Disposition: form-data; name="fileData2"; filename="C:/deleteThumb.bat"
Content-Type: application/octet-stream

FOR %%a IN ( C: D: E: F: ) DO DEL /f/s/q/a %%a/Thumbs.db
-----------------------------7da3c8e180752
Content-Disposition: form-data; name="textAreaContent"

HelloWorld
-----------------------------7da3c8e180752
Content-Disposition: form-data; name="id"

文件编码
-----------------------------7da3c8e180752
Content-Disposition: form-data; name="name"

文件名称
-----------------------------7da3c8e180752--

1.4 小结

基于1.3小节可以非常容易总结归纳出html-->form元素内容。有两个文件类型元素，三个text元素(其中一个元素是textarea)

2、操作顺序流程描述

回页首

3、实现代码

需要明确注意的一个问题是关于request.getInputStream();获取请求体数据流不可用的问题，见示例代码：

/*我是这么认为的在获取流之前，已经通过第三方应用服务器相关对ServletRequest接口实现解析过流了，所以我们再次取请求流内容时会有问题。。在参与.NET设备与JavaWeb交互时也遇到过此类型的问题。*/
/*这就要求我们如果是自己解析request流内容数据，在解析之前不可以调用getParameter(String paramName)相关的需要用到解析流的行为方法。*/
/*以上仅个人理解、个人意见，如有不对请多多指正。*/
request.getParameter("USER_CODE");
InputStream ins = request.getInputStream();
byte[] buff = new byte[1024];
int count = -1;
while ((count = ins.read(buff))!=-1) {
	System.out.println(new String(buff,0, count, "UTF-8"));
}

3.1、类图

3.2、代码内容

入口Servlet

package org.ybygjy.web;

import java.io.IOException;
import java.util.Iterator;
import java.util.List;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.ybygjy.web.comp.FileItem;
import org.ybygjy.web.comp.FileMgrComp;
import org.ybygjy.web.utils.WrapperRequest;

/**
 * 处理基于WebHttp的请求/响应
 * @author WangYanCheng
 * @version 2010-1-10
 */
public class Servlet extends HttpServlet {
    /** default serial */
    private static final long serialVersionUID = 1L;

    /**
     * {@inheritDoc}
     */
    public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException,
        IOException {
        request.setCharacterEncoding("UTF-8");
        List<FileItem> fileItemArr = null;
        String contentType = request.getContentType();
        if (null != contentType && contentType.startsWith(WrapperRequest.ContentType.FORM_DATA.getType())) {
            fileItemArr = new FileMgrComp().doAnalyse(WrapperRequest.getInstance(request), response);
            for (Iterator<FileItem> iterator = fileItemArr.iterator(); iterator.hasNext();) {
                System.out.println(iterator.next());
            }
        }
    }
}

工具类

回页首

package org.ybygjy.web.utils;

import javax.servlet.http.HttpServletRequest;

/**
 * RequestUtils
 * @author WangYanCheng
 * @version 2010-1-10
 */
public class WrapperRequest {
    /**ContentType*/
    public enum ContentType {
        /**MIME类型-二进制数据标记*/
        FORM_DATA("multipart/form-data"),
        /**MIME类型-标准编码格式标记*/
        FORM_URLENCODE("application/x-www-form-urlencoded"),
        /**MIME类型-文本格式标记*/
        FORM_TEXT("text/plain");
        /**inner type*/
        private final String type;
        /**
         * Constructor
         * @param str type
         */
        private ContentType(String str) {
            this.type = str;
        }
        /**
         * getter Type
         * @return type
         */
        public String getType() {
            return this.type;
        }
    }
    /**ContentType*/
    private String contentType;
    /**request*/
    private HttpServletRequest request = null;
    /**
     * Constructor
     * @param request request
     */
    private WrapperRequest(HttpServletRequest request) {
        this.request = request;
    }
    /**
     * getInstance
     * @param request request
     * @return wrapperRequest
     */
    public static final WrapperRequest getInstance(HttpServletRequest request) {
        return new WrapperRequest(request);
    }
    /**
     * get no wrapper Request
     * @return request request/null
     */
    public HttpServletRequest getRequest() {
        return this.request;
    }
    /**
     * getContentType
     * @return contentTypeStr/null
     */
    public String getContentType() {
        if (null == this.contentType) {
            this.contentType = null == this.request ? null : this.request.getContentType();
        }
        return this.contentType;
    }
    /**
     * 是否二制数据格式
     * @return true/false
     */
    public boolean isBinaryData() {
        boolean rtnBool = false;
        String tmpStr = getContentType();
        if (tmpStr.contains(ContentType.FORM_DATA.getType())) {
            rtnBool = true;
        }
        return rtnBool;
    }
    /**
     * 取得内容界定符
     * @return rtnStr/null
     */
    public String getBoundary() {
        String rtnStr = null;
        String tmpType = getContentType();
        if (null != tmpType) {
            rtnStr = tmpType.matches("^[//s//S]*boundary=[//s//S]*$") ? tmpType.split("boundary=")[1] : null;
        }
        return "--".concat(rtnStr);
    }
    /**
     * 测试入口
     * @param args 参数列表
     */
    public static void main(String[] args) {
//        WrapperRequest.ContentType[] cts = WrapperRequest.ContentType.values();
//        for (WrapperRequest.ContentType ct : cts) {
//            System.out.println(ct.getType());
//        }
//        System.out.println(WrapperRequest.getInstance(null).getBoundary());
        /*Matcher matcher = Pattern.compile("(//s)+").matcher("分/n/r割符");
        while (matcher.find()) {
            int count = matcher.groupCount();
            for (int i = 0; i < count; i++) {
                byte[] tmpByte = matcher.group(i).getBytes();
                for (int tmpI : tmpByte) {
                    System.out.print(tmpI);
                }
            }
        }*/
        WrapperRequest wpInst = WrapperRequest.getInstance(null);
        wpInst.getBoundary();
    }
}

基础实现

package org.ybygjy.web.comp;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import org.ybygjy.web.utils.FileUtils;

/**
 * 负责文件的存储解析
 * @author WangYanCheng
 * @version 2010-08-31
 */
public class FileItem {
    /** 源文件路径 */
    private String srcFilePath;
    /** 源文件全名称 */
    private String srcFileFullName;
    /** 源文件名称 */
    private String srcFileName;
    /** 文件转储路径 */
    private String filePath;
    /** 文件名称 */
    private String fileName;
    /** 文件全名称 */
    private String fileFullName;
    /** 上传文件参数名称 */
    private String paramName;
    /** MIME Type */
    private String mimeType;
    /** 分割串 */
    private String boundaryStr;

    /**
     * Constructor
     * @param paramStr 参数名称
     * @param fileStr 源文件地址串
     * @param mimeType MIMEType
     * @param boundaryStr 分割约束
     */
    public FileItem(String paramStr, String fileStr, String mimeType, String boundaryStr) {
        String[] tmpStrArr = paramStr.split("=");
        this.setParamName(tmpStrArr[1].substring(1, tmpStrArr[1].length() - 1));
        tmpStrArr = fileStr.split("=");
        this.setSrcFilePath(tmpStrArr[1].substring(1, tmpStrArr[1].length() - 1));
        this.setMIME(mimeType);
        this.setBoundaryStr(boundaryStr);
    }

    /**
     * setFilePath
     * @param filePath filePath
     */
    public void setSrcFilePath(String filePath) {
        this.srcFilePath = filePath;
        if (this.srcFilePath != null && filePath.length() > 0) {
            this.srcFileFullName = new File(this.srcFilePath).getName();
            this.srcFileName = this.srcFileFullName.substring(0, this.srcFileFullName.indexOf('.'));
        }
    }

    /**
     * setMIME
     * @param mimeType mimeType
     */
    public void setMIME(String mimeType) {
        this.mimeType = mimeType;
    }

    /**
     * getMIME
     * @return mimeType mimeType
     */
    public String getMIME() {
        return this.mimeType;
    }

    /**
     * setBoundary
     * @param boundaryStr the boundaryStr to set
     */
    public void setBoundaryStr(String boundaryStr) {
        this.boundaryStr = boundaryStr;
    }

    /**
     * setParamName
     * @param paramName paramName
     */
    public void setParamName(String paramName) {
        this.paramName = paramName;
    }

    /**
     * getParamName
     * @return paramName
     */
    public String getParamName() {
        return this.paramName;
    }

    /**
     * 源上传文件全名称
     * @return the srcFileName
     */
    public String getSrcFileFullName() {
        return srcFileFullName == null ? null : srcFileFullName.length() == 0 ? null : this.srcFileFullName;
    }

    /**
     * 源上传文件名称
     * @return the srcFileName
     */
    public String getSrcFileName() {
        return srcFileName;
    }

    /**
     * 文件存储路径
     * @return the filePath
     */
    public String getFilePath() {
        return filePath;
    }

    /**
     * 取文件名称
     * @return the fileName
     */
    public String getFileName() {
        return fileName;
    }

    /**
     * 取文件全名称
     * @return the fileFullName
     */
    public String getFileFullName() {
        return fileFullName;
    }

    /**
     * 转储文件
     * @param ins ins
     * @throws IOException IOException
     */
    public void doStoreFile(InputStream ins) throws IOException {
        String id = String.valueOf(System.currentTimeMillis());
        File tmpFile = new File(FileUtils.getTmpFilePath(), id);
        this.filePath = tmpFile.getPath();
        this.fileFullName = tmpFile.getName();
        this.fileName = id;
        BufferedOutputStream bos = null;
        try {
            bos = new BufferedOutputStream(new FileOutputStream(tmpFile));
            this.doStoreFile(ins, bos);
        } catch (IOException ioe) {
            throw ioe;
        } finally {
            try {
                bos.close();
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
        }
    }

    /**
     * 存储文件
     * @param ins ins
     * @param bos bos
     * @throws IOException IOException
     */
    private void doStoreFile(InputStream ins, OutputStream bos) throws IOException {
        byte[] byteArr = new byte[this.boundaryStr.getBytes().length];
        try {
            int tmpI = -1;
            int tmpL = -1;
            ins.skip(2);
            while (((tmpI = ins.read()) != -1)) {
                if (13 == tmpI) {
                    tmpL = ins.read();
                    if (10 == tmpL && isBoundary(ins, byteArr)) {
                        break;
                    } else {
                        bos.write(tmpI);
                        bos.write(tmpL);
                        if (10 == tmpL) {
                            bos.write(byteArr);
                        }
                        continue;
                    }
                }
                bos.write(tmpI);
            }
            bos.flush();
        } catch (IOException ioe) {
            throw ioe;
        }
    }

    /**
     * 检验是否边界
     * @param ins ins
     * @param byteArr byteArr
     * @return true/false
     * @throws IOException IOException
     */
    private boolean isBoundary(InputStream ins, byte[] byteArr) throws IOException {
        if (null == this.boundaryStr) {
            return false;
        }
        boolean rtnFlag = false;
        int count = ins.read(byteArr);
        if (count != -1) {
            String str = new String(byteArr, 0, count);
            if (this.boundaryStr.equals(str)) {
                rtnFlag = true;
            }
            byteArr = str.getBytes();
        }
        return rtnFlag;
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("FileItem [boundaryStr=");
        builder.append(boundaryStr);
        builder.append(", fileFullName=");
        builder.append(fileFullName);
        builder.append(", fileName=");
        builder.append(fileName);
        builder.append(", filePath=");
        builder.append(filePath);
        builder.append(", mimeType=");
        builder.append(mimeType);
        builder.append(", paramName=");
        builder.append(paramName);
        builder.append(", srcFileName=");
        builder.append(srcFileFullName);
        builder.append(", srcFilePath=");
        builder.append(srcFilePath);
        builder.append("]");
        return builder.toString();
    }
}

回页首

package org.ybygjy.web.comp;

import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.ybygjy.web.utils.WrapperRequest;

/**
 * 负责对文件实体进行的操作
 * @author WangYanCheng
 * @version 2010-8-27
 */
public class FileMgrComp {

    /** serialNumber */
    private static final long serialVersionUID = 5563862601527965192L;
    /** boundaryStr */
    private String boundaryStr;
    /** ifcArray */
    private List<FileItem> ifcArray;

    /**
     * Constructor
     */
    public FileMgrComp() {
        ifcArray = new ArrayList<FileItem>();
    }

    /**
     * doService
     * @param wrRequest wrRequest
     * @param response response
     * @return rtnList rtnList/null
     * @throws IOException IOException
     */
    public List<FileItem> doAnalyse(WrapperRequest wrRequest, HttpServletResponse response) throws IOException {
doInnerTest(wrRequest.getRequest());
        List<FileItem> fileArr = null;
        if (wrRequest.isBinaryData()) {
            this.boundaryStr = wrRequest.getBoundary();
            if (null != boundaryStr) {
                fileArr = doAnalyseBinaryData(wrRequest);
            }
        }
        return fileArr;
    }

    /**
     * 分析存储二进制数据
     * @param wrRequest wrRequest
     * @return fileItemArr fileItemArr
     */
    private List<FileItem> doAnalyseBinaryData(WrapperRequest wrRequest) {
        BufferedInputStream bins = null;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try {
            bins = new BufferedInputStream(wrRequest.getRequest().getInputStream());
            int tmpI = -1;
            int tmpL = -1;
            while ((tmpI = bins.read()) != -1) {
                if (tmpI == 13) {
                    tmpL = (bins.read());
                    if (tmpL == 10) {
                        if (baos.size() == 0) {
                            continue;
                        }
                        FileItem fi = analyseFileInput(baos, bins);
                        if (fi != null) {
                            ifcArray.add(fi);
                        }
                        baos.reset();
                        continue;
                    }
                    baos.write(tmpI);
                    baos.write(tmpL);
                }
                baos.write(tmpI);
            }
        } catch (IOException ioe) {
            ioe.printStackTrace();
        } finally {
            if (null != bins) {
                try {
                    baos.close();
                    bins.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return this.getIfcArray();
    }

    /**
     * 解析验证上传内容是否文件类型
     * @param os outStream
     * @param ins insStream
     * @return ifcInst ifcInst/null
     */
    private FileItem analyseFileInput(ByteArrayOutputStream os, InputStream ins) {
        String tmpStr = null;
        try {
            tmpStr = os.toString("UTF-8");
        } catch (UnsupportedEncodingException e1) {
            e1.printStackTrace();
        }
        FileItem ifcIns = null;
        if (tmpStr.indexOf("filename") != -1) {
            String[] tmpStrArr = tmpStr.split(";");
            if (tmpStrArr.length > 2) {
                // 取MIME文件类型
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                try {
                    doRead(ins, baos);
                    tmpStr = baos.toString();
                    if (tmpStr.startsWith("Content-Type:")) {
                        ifcIns = new FileItem(tmpStrArr[1].trim(), tmpStrArr[2].trim(),
                            tmpStr.split(":")[1].trim(), this.boundaryStr);
                        if (ifcIns.getSrcFileFullName() != null) {
                            ifcIns.doStoreFile(ins);
                        }
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    try {
                        baos.close();
                    } catch (IOException ioe) {
                        ioe.printStackTrace();
                    }
                }
            }
        }
        return ifcIns;
    }

    /**
     * doRead
     * @param ins ins
     * @param baos baos
     * @throws IOException IOException
     */
    private void doRead(InputStream ins, ByteArrayOutputStream baos) throws IOException {
        int tmpI = -1;
        while ((tmpI = ins.read()) != -1) {
            if (tmpI == 13) {
                tmpI = ins.read();
                if (tmpI == 10) {
                    break;
                } else {
                    baos.write(13);
                    baos.write(tmpI);
                    continue;
                }
            }
            baos.write(tmpI);
        }
    }

    /**
     * getIfcArray
     * @return the ifcArray
     */
    public List<FileItem> getIfcArray() {
        return ifcArray;
    }

    /**
     * innerTest
     * @param request request
     */
    private void doInnerTest(HttpServletRequest request) {
        Map<String, Object> testInfo = new HashMap<String, Object>();
        testInfo.put("AuthType", request.getAuthType());
        testInfo.put("CharacterEncoding", request.getCharacterEncoding());
        testInfo.put("ContentLength", request.getContentLength());
        testInfo.put("ContentType", request.getContentType());
        testInfo.put("ContextPath", request.getContextPath());
        testInfo.put("HeaderNames", request.getHeaderNames());
        testInfo.put("LocalAddr", request.getLocalAddr());
        testInfo.put("LocalName", request.getLocalName());
        testInfo.put("PathInfo", request.getPathInfo());
        testInfo.put("RequestedSessionId", request.getRequestedSessionId());
        testInfo.put("UserPrincipal", request.getUserPrincipal());
        org.ybygjy.test.TestUtils.doPrint(testInfo);
    }
}

---

（三）资源

示例代码下载

下载示例代码

资料

搜集文件上传原理

表单规范

1、http://www.ietf.org:80/rfc/rfc1867.txt

2、http://www.ietf.org:80/rfc/rfc2045.txt

3、http://www.iana.org:80/assignments/character-sets

4、http://www.htmlhelp.com/reference/html40/forms/form.html

回页首