一个更方便使用的upload类

package net.java2000.tools;

import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletInputStream;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

/** *//**
* <p>
* Title: Java 程序
* </p>
* <p>
* Description: 通用的请求处理程序，能够处理上传方式
* </p>
*    
* <pre>
*    一般使用方法如下
*     <%
*     指定编码方式
*     request.setCharacterEncoding("GBK");
*     // 为文件上传做准备，该类读取接口与 request 相同
*     net.java2000.tools.Upload upload = new net.java2000.tools.Upload(request);
*     // 解析
*     upload.parse();
*     %>
*     ...
*     <%
*     //使用标准方法读取参数
*     String name = upload.getParameter("Name");
*     String[] names = upload.getParameterValues("nameMultiSelected");
*     <br/>
*     // 读取上传信息，比如上传照片
*     <form method="POST" name="form1" enctype="multipart/form-data" action="" onsubmit="return check();">
*     <input type="file" name="photo" size="8" value="更新照片">
*     </form>
*     // 读取表单值,也就是照片的实际信息,请注意，该方法名包含Org,和前面的不同
*     // 由于上传信息经常是二进制内容，所以不能采用编码后的字符串，应采用和流完全对应的字符串
*     String photo = upload.getParameterOrg("photo");    // 此方法读取原始信息，没有进行任何编码，即ISO-8859-1 格式
*     // 如果转化为字节数组为
*     byte[] bytes = photo.getBytes("iso-8859-1");
*     // 读取照片的类型
*     String contentType = upload.getContentType("photo");
*     // 读取照片文件名，不包含路径
*     String filename = upload.getFilename("photo");
*     %>
*     请在尽可能前的地方使用，特别是<b>不要</b>再使用了
*     request.getParameter("XXX");
*     后面使用，因为这时候的输入流已经被系统使用了。
* </pre>
*    
* <p>
* Copyright: Copyright (c) 2002
* </p>
* <p>
* Company:
* </p>
*    
* @author    
* @version 1.0
*/
public class Upload implements HttpServletRequest ...{

    private HttpServletRequest request = null;

    public Upload(HttpServletRequest request) ...{
        this.request = request;
    }

    public Object getAttribute(String name) ...{
        return request.getAttribute(name);
    }

    public java.util.Enumeration getAttributeNames() ...{
        return request.getAttributeNames();
    }

    public java.lang.String getCharacterEncoding() ...{
        return request.getCharacterEncoding();
    }

    public void setCharacterEncoding(String env) throws java.io.UnsupportedEncodingException ...{
        request.setCharacterEncoding(env);
    }

    public int getContentLength() ...{
        return request.getContentLength();
    }

    public int getLocalPort() ...{
        return request.getLocalPort();
    }

    public String getLocalAddr() ...{
        return request.getLocalAddr();
    }

    public String getLocalName() ...{
        return request.getLocalName();
    }

    public int getRemotePort() ...{
        return request.getRemotePort();
    }

    public java.lang.String getContentType() ...{
        return request.getContentType();
    }

    public ServletInputStream getInputStream() throws java.io.IOException ...{
        return request.getInputStream();
    }

    public java.util.Map getParameterMap() ...{
        return request.getParameterMap();
    }

    public java.lang.String getProtocol() ...{
        return request.getProtocol();
    }

    public java.lang.String getScheme() ...{
        return request.getScheme();
    }

    public java.lang.String getServerName() ...{
        return request.getServerName();
    }

    public int getServerPort() ...{
        return request.getServerPort();
    }

    public java.io.BufferedReader getReader() throws java.io.IOException ...{
        return request.getReader();
    }

    public java.lang.String getRemoteAddr() ...{
        return request.getRemoteAddr();
    }

    public java.lang.String getRemoteHost() ...{
        return request.getRemoteHost();
    }

    public void setAttribute(java.lang.String name, Object o) ...{
        request.setAttribute(name, o);
    }

    public void removeAttribute(java.lang.String name) ...{
        request.removeAttribute(name);
    }

    public java.util.Locale getLocale() ...{
        return request.getLocale();
    }

    public java.util.Enumeration getLocales() ...{
        return request.getLocales();
    }

    public boolean isSecure() ...{
        return request.isSecure();
    }

    public RequestDispatcher getRequestDispatcher(String path) ...{
        return request.getRequestDispatcher(path);
    }

    public java.lang.String getRealPath(String path) ...{
        return request.getRealPath(path);
    }

    public java.lang.String getAuthType() ...{
        return request.getAuthType();
    }

    public Cookie[] getCookies() ...{
        return request.getCookies();
    }

    public long getDateHeader(java.lang.String name) ...{
        return request.getDateHeader(name);
    }

    public java.lang.String getHeader(java.lang.String name) ...{
        return request.getHeader(name);
    }

    public java.util.Enumeration getHeaders(java.lang.String name) ...{
        return request.getHeaders(name);
    }

    public java.util.Enumeration getHeaderNames() ...{
        return request.getHeaderNames();
    }

    public int getIntHeader(java.lang.String name) ...{
        return request.getIntHeader(name);
    }

    public java.lang.String getPathInfo() ...{
        return request.getPathInfo();
    }

    public java.lang.String getPathTranslated() ...{
        return request.getPathTranslated();
    }

    public java.lang.String getContextPath() ...{
        return request.getContextPath();
    }

    public java.lang.String getQueryString() ...{
        return request.getQueryString();
    }

    public java.lang.String getRemoteUser() ...{
        return request.getRemoteUser();
    }

    public boolean isUserInRole(java.lang.String role) ...{
        return request.isUserInRole(role);
    }

    public java.security.Principal getUserPrincipal() ...{
        return request.getUserPrincipal();
    }

    public java.lang.String getRequestedSessionId() ...{
        return request.getRequestedSessionId();
    }

    public java.lang.String getRequestURI() ...{
        return request.getRequestURI();
    }

    public java.lang.StringBuffer getRequestURL() ...{
        return request.getRequestURL();
    }

    public java.lang.String getServletPath() ...{
        return request.getServletPath();
    }

    public HttpSession getSession() ...{
        return request.getSession();
    }

    public HttpSession getSession(boolean create) ...{
        return request.getSession(create);
    }

    public boolean isRequestedSessionIdValid() ...{
        return request.isRequestedSessionIdValid();
    }

    public boolean isRequestedSessionIdFromCookie() ...{
        return request.isRequestedSessionIdFromCookie();
    }

    public boolean isRequestedSessionIdFromURL() ...{
        return request.isRequestedSessionIdFromURL();
    }

    public boolean isRequestedSessionIdFromUrl() ...{
        return request.isRequestedSessionIdFromUrl();
    }

    // 保存名字/对象对应关系
    private Hashtable uploadHash = new Hashtable();;

    // 保存所有名字
    private Vector names = new Vector();;

    // 分割标志
    private String splitsign = null;

    // 结束标志
    private String endsign = null;

    // 数据总长度
    private int totlelength = 0;

    // 最大总容量,-1为不限制
    private int MAX = 1024 * 1024 * 100;

    // 单个最大容量，-1为不限制
    private int MAX_SIMPLE = 1024 * 1024 * 50;

    private boolean debug = false;

    public void setDebug(boolean debug) ...{
        this.debug = debug;
    }

    public boolean isDebug() ...{
        return this.debug;
    }

    // 保存所有数据
    // byte[] data;

    /** *//**
     * 设置总量的最大值
     *    
     * @param capacity 最大值，字节形式
     */
    public void setMaxCapacity(int capacity) ...{
        this.MAX = capacity;
        if (MAX < MAX_SIMPLE) ...{
            MAX_SIMPLE = MAX;
        }
    }

    /** *//**
     * 取的总量的最大值
     *    
     * @return 最大值的字节形式
     */
    public int getMaxCapacity() ...{
        return this.MAX;
    }

    /** *//**
     * 设置单个的最大值
     *    
     * @param capacity 单个最大值
     */
    public void setMaxCapacitySimple(int capacity) ...{
        this.MAX_SIMPLE = capacity;
        if (MAX < MAX_SIMPLE) ...{
            MAX = MAX_SIMPLE;
        }
    }

    /** *//**
     * 读取单个最大值
     *    
     * @return 单个最大值
     */
    public int getMaxCapacitySimple() ...{
        return this.MAX_SIMPLE;
    }

    public static final int UPLOAD_OK = 0;

    public static final int UPLOAD_UNKNOW_ERROR = -1;

    public boolean isPost = false;

    public int parse() ...{
        return parse(this.request);
    }

    /** *//**
     * 解析输入流,生成需要的各种数值
     *    
     * @param request 输入流
     * @return 解析结果
     */
    public int parse(HttpServletRequest request) ...{
        this.request = request;
        if (request.getMethod().equals("POST")) ...{
            isPost = true;
        } else ...{
            isPost = false;
            return -1;
        }

        // Content-Type: multipart/form-data;
        // boundary=---------------------------7d5ea1c501bc
        // Content-Type: application/x-www-form-urlencoded

        // 本方法只处理 multipart/form-data
        String contentType = request.getContentType();
        if (contentType == null || !contentType.startsWith("multipart/form-data")) ...{
            isPost = false;
            return -1;
        }

        try ...{

            // 读取输入流
            ServletInputStream sis = request.getInputStream();

            // 流的长度
            int len = request.getContentLength();

            if ((MAX != -1) && (len > MAX)) ...{
                return -1;
            }

            // 保存一行数据
            byte[] b = new byte[65536];
            int a = 0;
            int k = 0;
            String s = "";

            // 读取分割标志
            a = sis.readLine(b, 0, b.length);

            splitsign = new String(b, 0, a);

            if (debug) ...{
                System.out.println(splitsign);
            }
            // 结束标志
            endsign = new String(splitsign.substring(0, splitsign.length() - 2) + "-- ");

            boolean isend;
            do ...{
                _upload up = new _upload(splitsign, endsign, MAX_SIMPLE);

                // 解析数据
                isend = up.parse(sis, this.debug);
                if ( != null) ...{

                    // 如果已经存在这个名字的对象，则进行重名处理
                    if (names.contains()) ...{
                        _upload upp = (_upload) uploadHash.get();

                        // 增加重名的对象
                        upp.add(up.getUpload(0));

                        up = null;
                    } else ...{
                        // 保存名字对应关系
                        uploadHash.put(, up);

                        // 保存名字列表
                        names.add();
                    }
                }
            } while (!isend);
            return UPLOAD_OK;
        } catch (Exception e) ...{
            return UPLOAD_UNKNOW_ERROR;
        }
    }

    public String getMethod() ...{
        return isPost ? "POST" : "GET";
    }

    public String getParameter(String name) ...{
        if (!isPost) ...{
            return request.getParameter(name);
        }
        String str = getParameterOrg(name);
        if (str == null) ...{
            return str;
        }
        try ...{
            return new String(str.getBytes("iso-8859-1"), this.getCharacterEncoding());
        } catch (Exception e) ...{
            return str;
        }
    }

    public String getParameterOrg(String name) ...{
        if (!isPost) ...{
            return request.getParameter(name);
        }

        return getParameterOrg(name, 0);
    }

    public String getParameterOrg(String name, int index) ...{
        if (name == null) ...{
            return null;
        }
        _upload up = (_upload) uploadHash.get(name);
        if (up == null) ...{
            return null;
        } else ...{
            return up.getValue(index);
        }
    }

    public Enumeration getParameterNames() ...{
        if (!isPost) ...{
            return request.getParameterNames();
        }

        return names.elements();
    }

    public String[] getParameterValues(String name) ...{
        if (!isPost) ...{
            return request.getParameterValues(name);
        }

        if (name == null) ...{
            return null;
        }
        _upload up = (_upload) uploadHash.get(name);
        if (up == null) ...{
            return null;
        } else ...{
            return up.getValues();
        }
    }

    public String getFilename(String name) ...{
        return getFilename(name, 0);
    }

    public String getFilename(String name, int index) ...{
        if (name == null) ...{
            return null;
        }
        _upload up = (_upload) uploadHash.get(name);
        if (up == null) ...{
            return null;
        } else ...{
            return up.getFilename(index);
        }
    }

    public String getFullFilename(String name) ...{
        return getFullFilename(name, 0);
    }

    public String getFullFilename(String name, int index) ...{
        if (name == null) ...{
            return null;
        }
        _upload up = (_upload) uploadHash.get(name);
        if (up == null) ...{
            return null;
        } else ...{
            return up.getFullFilename(index);
        }
    }

    public String getContentType(String name) ...{
        return getContentType(name, 0);
    }

    public String getContentType(String name, int index) ...{
        if (name == null) ...{
            return null;
        }
        _upload up = (_upload) uploadHash.get(name);
        if (up == null) ...{
            return null;
        } else ...{
            return up.getContentType(index);
        }
    }
}

class _upload ...{
    // 名称
    String name = null;

    // 保存名称和对象的关系
    Vector __uploadVector = null;

    // 分割标志
    private String splitsign = null;

    // 结束标志
    private String endsign = null;

    // 单个最大容量，-1为不限制
    private int MAX_SIMPLE = -1;

    _upload(String splitsign, String endsign, int max_simple) ...{
        this.splitsign = new String(splitsign);
        this.endsign = new String(endsign);
        __uploadVector = new Vector();
        MAX_SIMPLE = max_simple;
    }

    boolean parse(ServletInputStream sis, boolean debug) throws Exception ...{
        // 类型
        String Content_Type = null;

        // 数值
        String value = null;

        // 文件名
        String filename = null;

        // 保存数据的长度
        int filelength = 0;

        // 保存一行数据
        byte[] b = new byte[65536];

        int a = 0;
        int k = 0;
        String s = "";

        boolean isend = false;

        // -------------------- 读取分段头信息 --------------------
        while (true) ...{

            // 读取一行
            a = sis.readLine(b, 0, b.length);

            s = new String(b, 0, a, "ISO-8859-1");

            if (debug) ...{
                System.out.println(s);
            }
            // s = new String(b,0,a);

            // 判断是否为空行,如果是则跳出
            if (s.equals("") || s.equals(" ") || s.equals(" "))
                break;

            // 查找名字
            if ((k = s.indexOf("name=")) != -1) ...{
                s = s.substring(k + 6);
                k = s.indexOf(""");
                name = s.substring(0, k);
            }

            // 查找文件名
            if ((k = s.indexOf("filename=")) != -1) ...{
                s = s.substring(k + 10);
                k = s.indexOf(""");
                if (k == -1) ...{
                    filename = s.substring(0);
                } else ...{
                    filename = s.substring(0, k);
                }
            }

            // 查找类型
            if ((k = s.indexOf("Content-Type: ")) != -1) ...{
                Content_Type = s.substring(k + 14);
            }
        }

        // -------------------- 开始读取内数据 --------------------
        StringBuffer buff = new StringBuffer();
        boolean overflow = false;
        while (true) ...{

            // 读取一行
            a = sis.readLine(b, 0, b.length);
            if (a == -1)
                break;
            s = new String(b, 0, a, "ISO-8859-1");

            if (debug) ...{
                System.out.println(s);
            }
            // s = new String(b,0,a);
            // 是否到分割符/结束符
            if (s.equals(splitsign)) ...{
                break;
            } else if (s.equals(endsign)) ...{
                isend = true;
                break;
            }

            // 限制单个数据的最大值
            buff.append(s);
            if ((MAX_SIMPLE != -1) && (buff.length() > MAX_SIMPLE)) ...{
                buff.delete(MAX_SIMPLE, buff.length());
                overflow = true;
                break;
            }
        }

        // 去掉最后的换行回车
        if (!overflow && buff.length() >= 2) ...{
            buff.setLength(buff.length() - 2);
        }

        value = buff.toString();

        // 保存文件数据长度
        filelength = value.length();

        // 保存解析的对象
        __upload __up = new __upload(name, Content_Type, value, filename);

        __uploadVector.add(__up);

        return isend;
    }

    /** *//**
     * 增加一个重名的对象
     *    
     * @param _up 对象名
     */
    void add(__upload _up) ...{
        __uploadVector.add(_up);
    }

    /** *//**
     * 得到对象
     *    
     * @param index 索引
     * @return 对象
     */
    __upload getUpload(int index) ...{
        if ((index >= 0) && (__uploadVector.size() > index)) ...{
            return (__upload) __uploadVector.elementAt(index);
        } else ...{
            return null;
        }
    }

    /** *//**
     * 读取值
     *    
     * @param index 索引
     * @return 第一个的值
     */
    String getValue(int index) ...{
        __upload _up = getUpload(index);
        if (_up == null) ...{
            return null;
        } else ...{
            return _up.value;
        }
    }

    /** *//**
     * 读取文件名
     *    
     * @param index 索引
     * @return 文件名
     */
    String getFilename(int index) ...{
        __upload _up = getUpload(index);
        if (_up == null) ...{
            return null;
        } else ...{
            return _up.filename;
        }
    }

    /** *//**
     * 读取文件长度
     *    
     * @param index 索引
     * @return 文件长度
     */
    int getFileLength(int index) ...{
        __upload _up = getUpload(index);
        if (_up == null) ...{
            return -1;
        } else if (_up.value == null) ...{
            return -1;
        } else ...{
            return _up.value.length();
        }
    }

    /** *//**
     * 读取文件全名
     *    
     * @param index 索引
     * @return 文件全名
     */
    String getFullFilename(int index) ...{
        __upload _up = getUpload(index);
        if (_up == null) ...{
            return null;
        } else ...{
            return _up.fullfilename;
        }
    }

    /** *//**
     * 读取第一个类型
     *    
     * @param index 索引
     * @return 第一个的类型
     */
    String getContentType(int index) ...{
        __upload _up = getUpload(index);
        if (_up == null) ...{
            return null;
        } else ...{
            return _up.Content_Type;
        }
    }

    /** *//**
     * 读取所有的值
     *    
     * @return 值数组
     */
    String[] getValues() ...{
        Vector v = new Vector();
        for (int i = 0; i < __uploadVector.size(); i++) ...{

            v.add(((__upload) __uploadVector.elementAt(i)).value);
        }
        return (String[]) v.toArray(new String[0]);
    }
}

class __upload ...{

    // 名称
    String name = null;

    // 类型
    String Content_Type = null;

    // 数值
    String value = null;

    // 文件名
    String filename = null;

    // 文件全名
    String fullfilename = null;

    __upload(String name, String Content_Type, String value, String fullfilename) ...{
        this.name = new String(name);
        if (Content_Type != null)
            this.Content_Type = new String(Content_Type.trim());
        if (fullfilename != null) ...{
            this.fullfilename = new String(fullfilename.trim());

            int index = fullfilename.lastIndexOf("\");
            this.filename = fullfilename.substring(index + 1).trim();
        }
        if (value != null)
            this.value = value;
    }
}

使用方法

request.setCharacterEncoding("UTF-8");    
    // 为文件上传做准备，该类读取接口与 request 相同    
    net.java2000.tools.Upload upload = new net.java2000.tools.Upload(request);    
    upload.setCharacterEncoding("UTF-8");    
    upload.setMaxCapacity(10 * 1024 * 1024);    
    upload.setMaxCapacitySimple(10 * 1024 * 1024);    
    // 解析    
    upload.parse();    

            // 读取普通参数
    String name = upload.getParameter("name"); // 普通读取参数，单选    
    String[] deleteaids = upload.getParameterValues("deleteaid[]"); // 读取多选普通参数    

    // 读取附件的方法    
    String pName= "myp_w_upload_1";    
    String filename = upload.getFilename(pName); // 读取文件名    
    String fullFilename = upload.getFullFilename(pName); // 读取文件全名，包括路径    
    String contentType = upload.getContentType(pName);    
    byte[] content = upload.getParameterOrg(pName).getBytes("iso-8859-1"); // 特殊的方法，对于二进制的内容，需要调用这个方法    

    // 如果有重名的，则需要在调用方法后面加上顺序号，比如    

    String filename2 = upload.getFilename(pName, 2); // 读取第二个附件的文件名    
    String contentType2 = upload.getContentType(pName,2);    
    byte[] content2 = upload.getParameterOrg(pName,2).getBytes("iso-8859-1");