java如何保存上传后的文件 （struts2与struts1）

于 2014-10-29 13:22:39 发布
阅读量1k 收藏
点赞数
分类专栏： JAVA开发 文章标签： 上传
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/yinxianluo/article/details/40584913
版权
本文介绍了Java中Struts2框架如何实现文件上传。首先，讲解了文件上传的原理，涉及表单enctype属性和multipart/form-data编码方式。接着，详细阐述了Struts2如何利用Apache的Common-FileUpload组件简化文件上传过程，并提供了相关的Action类和配置文件示例。此外，还提到了多文件上传的处理方法和注意事项。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.    文件上传的原理： 
表单元素的enctype属性指定的是表单数据的编码方式，该属性有3个值： 
1)      application/x-www-form-urlencoded：这是默认编码方式，它只处理表单域里的value属性值，采用这种编码方式的表单会将表单域的值处理成URL编码方式。 
2)      multipart/form-data：这种编码方式的表单会以二进制流的方式来处理表单数据，这种编码方式会把文件域指定文件的内容也封装到请求参数里。 
3)      text/plain：这种方式主要适用于直接通过表单发送邮件的方式。 
文件上传是web应用经常用到的一个知识。原理是，通过为表单元素设置enctype="multipart/form-data"属性，让表单提交的数据以二进制编码的方式提交，在接收此请求的Servlet中用二进制流来获取内容，就可以取得上传文件的内容，从而实现文件的上传。 
在Java领域中，有两个常用的文件上传项目：一个是Apache组织Jakarta的Common-FileUpload组件(http://commons.apache.org/fileupload/)，另一个是Oreilly组织的COS框架(http://www.servlets.com/cos/)。利用这两个框架都能很方便的实现文件的上传。 
2.    Struts2的文件上传： 
Struts2并未提供自己的请求解析器，也就是就Struts2不会自己去处理multipart/form-data的请求，它需要调用其他请求解析器，将HTTP请求中的表单域解析出来。但Struts2在原有的上传解析器基础上做了进一步封装，更进一步简化了文件上传。 
Struts2默认使用的是Jakarta的Common-FileUpload框架来上传文件，因此，要在web应用中增加两个Jar文件：commons-fileupload-1.2.jar和commons-io-1.3.1.jar。它在原上传框架上做了进一步封装，简化了文件上传的代码实现，取消了不同上传框架上的编程差异。 
如果要改成其它的文件上传框架，可以修改struts.multipart.parser常量的值为cos/pell，默认值是jakata。并在classpath中增加相应上传组件的类库。 
2.1.    步骤一：创建带上传表单域的页面                 

Java代码   收藏代码
  1. <%@ page language="java" contentType="text/html; charset=UTF-8"%>  
  2. <html>  
  3. <head>  
  4.     <title>Struts2 File Upload</title>  
  5. </head>  
  6. <body>  
  7.     <form action="fileUpload.action" method="POST" enctype="multipart/form-data">  
  8.         文件标题：<input type="text" name="title" size="50"/><br/>  
  9.         选择文件：<input type="file" name="upload" size="50"/><br/>  
  10.        <input type="submit" value=" 上传 "/>         
  11.     </form>  
  12. </body>  
  13. </html>  
此页面特殊之处只是把表单的enctype属性设置为multipart/form-data。 
2.2.    步骤二：创建处理上传请求的Action类 
                
Java代码   收藏代码
  1. package org.qiujy.web.struts2;  
  2. import java.io.BufferedInputStream;  
  3. import java.io.BufferedOutputStream;  
  4. import java.io.File;  
  5. import java.io.FileInputStream;  
  6. import java.io.FileOutputStream;  
  7. import java.io.InputStream;  
  8. import java.io.OutputStream;  
  9. import org.apache.struts2.ServletActionContext;  
  10. import com.opensymphony.xwork2.ActionSupport;  
  11. /** 
  12.  *处理文件上传的Action类 
  13.  *@authorqiujy 
  14.  *@version1.0 
  15.  */  
  16. publicclass FileUploadAction extends ActionSupport {  
  17.     privatestaticfinalintBUFFER_SIZE = 16 * 1024;  
  18.     // 文件标题  
  19.     private String title;  
  20.     // 上传文件域对象  
  21.     private File upload;  
  22.     // 上传文件名  
  23.     private String uploadFileName;  
  24.     // 上传文件类型  
  25.     private String uploadContentType;  
  26.     // 保存文件的目录路径(通过依赖注入)  
  27.     private String savePath;  
  28.     //以下省略getter和setter......  
  29.     //自己封装的一个把源文件对象复制成目标文件对象  
  30.     privatestaticvoid copy(File src, File dst) {  
  31.         InputStream in = null;  
  32.         OutputStream out = null;  
  33.         try {  
  34.             in = new BufferedInputStream(new FileInputStream(src), BUFFER_SIZE);  
  35.             out = new BufferedOutputStream(new FileOutputStream(dst),  
  36.                     BUFFER_SIZE);  
  37.             byte[] buffer = newbyte[BUFFER_SIZE];  
  38.             int len = 0;  
  39.             while ((len = in.read(buffer)) > 0) {  
  40.                 out.write(buffer, 0, len);  
  41.             }  
  42.         } catch (Exception e) {  
  43.             e.printStackTrace();  
  44.         } finally {  
  45.             if (null != in) {  
  46.                 try {  
  47.                     in.close();  
  48.                 } catch (IOException e) {  
  49.                     e.printStackTrace();  
  50.                 }  
  51.             }  
  52.             if (null != out) {  
  53.                 try {  
  54.                     out.close();  
  55.                 } catch (IOException e) {  
  56.                     e.printStackTrace();  
  57.                 }  
  58.             }  
  59.         }  
  60.     }  
  61.     @Override  
  62.     public String execute() throws Exception {  
  63.         //根据服务器的文件保存地址和原文件名创建目录文件全路径  
  64.         String dstPath = ServletActionContext.getServletContext()  
  65.                                 .getRealPath(this.getSavePath())  
  66.                                 + "\\" + this.getUploadFileName();  
  67.          
  68.         System.out.println("上传的文件的类型："+ this.getUploadContentType());  
  69.          
  70.         File dstFile = new File(dstPath);  
  71.         copy(this.upload, dstFile);  
  72.         returnSUCCESS;  
  73.     }  
  74. }  
上面这个Action类中，提供了title和upload两个属性来分别对应页面的两个表单域属性，用来封装表单域的请求参数。 
但是，值得注意的是，此Action中还有两个属性：uploadFileName和uploadContentType，这两个属性分别用于封装上传文件的文件名、文件类型。这是Struts2设计的独到之处：Strut2的Action类直接通过File类型属性直接封装了上传文件的文件内容，但这个File属性无法获取上传文件的文件名和文件类型，所以Struts2就直接将文件域中包含的上传文件名和文件类型的信息封装到uploadFileName和uploadContentType属性中，也就是说Struts2针对表单中名为xxx的文件域，在对应的Action类中使用3个属性来封装该文件域信息： 
l 类型为File的xxx属性：用来封装页面文件域对应的文件内容。 
l 类型为String的xxxFileName属性：用来封装该文件域对应的文件的文件名。 
l 类型为String的xxxContentType属性：用来封装该文件域应用的文件的文件类型。 
另外，在这个Action类中还有一个savePath属性，它的值是通过配置文件来动态设置的，这也是Strut2设计中的一个依赖注入特性的使用。 
2.3.    步骤三：配置 
struts.xml文件： 
Java代码   收藏代码
  1.                   
  2. <!DOCTYPE struts PUBLIC  
  3.         "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"  
  4.         "http://struts.apache.org/dtds/struts-2.0.dtd">  
  5. <struts>  
  6.     <package name ="fileUploadDemo" extends ="struts-default">  
  7.         <action name ="fileUpload"  
  8. class ="org.qiujy.web.struts2.FileUploadAction">  
  9. <!-- 动态设置Action中的savePath属性的值 -->  
  10.             <param name="savePath">/upload</param>  
  11.             <result name ="success">/showupload.jsp</result>  
  12.         </action >  
  13.     </package >  
  14. </struts>  
       在这个文件中跟以前配置唯一不同的是给action配置了一个<param …/>元素，用来为该Action的savePath属性动态注入值。 
web.xml中的配置跟以前的应用一样。说明一点：好多网络文章说Struts2上传时要在web.xml中配置一个名为ActionContextUp的过滤器，说是有一些莫名的错误，可是是我用了Struts2新版本2.0.9GA版，测了n次，没出现什么问题，所以没配置。 
2.4.    运行调试： 
运行前要在根目录下创建一个名为upload的文件夹，用来存放上传后的文件。 
上传结果： 
3.    文件类型及错误输出： 
Struts2提供了一个文件上传的拦截器(名为fileUpload)，通过配置这个拦截器能轻松地实现文件类型的过滤。 
在上例中，若要配置上传的文件只能是一些普通的图片文件格式：image/bmp、image/png、image/gif、image/jpeg、image/jpg等，则可在struts.xml文件中按如下方式配置： 
Java代码   收藏代码
  1.                   
  2. <!DOCTYPE struts PUBLIC  
  3.         "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"  
  4.         "http://struts.apache.org/dtds/struts-2.0.dtd">  
  5. <struts>  
  6.     <constant name="struts.custom.i18n.resources" value="messages"/>  
  7.     <package name="fileUploadDemo" extends="struts-default">  
  8.         <action name="fileUpload"  
  9.             class="org.qiujy.web.struts2.FileUploadAction">  
  10.             <interceptor-ref name="fileUpload">  
  11.               <!-- 配置允许上传的文件类型，多个用","分隔 -->  
  12.               <param name="allowedTypes">  
  13.     　　　　　　image/bmp,image/png,image/gif,image/jpeg,image/jpg  
  14.   
  15. ,image/x-png, image/pjpeg  
  16.               </param>  
  17.               <!-- 配置允许上传的文件大小，单位字节 -->  
  18.               <param name="maximumSize">102400</param>  
  19.            </interceptor-ref>  
  20.            <interceptor-ref name="defaultStack" />  
  21.             <!-- 动态设置Action中的savePath属性的值 -->  
  22.             <param name="savePath">/upload</param>  
  23.             <result name="input">/index.jsp</result>  
  24.             <result name="success">/showupload.jsp</result>  
  25.         </action>  
  26.     </package>  
  27. </struts>  
如果上传文件失败，系统返回到input对应的页面，要在input对应的页面输出文件过滤失败信息，可以在input对应的页面中增加 <s:fielderror/>来显示错误信息。 
运行调试： 
结果： 
         显然，这样的提示不太友好，应用使用国际化信息。在国际化资源文件中添加如下三句： 
                
#更改上传文件类型不允许的提示信息 
struts.messages.error.content.type.not.allowed=文件上传失败：你要上传的文件类型不允许 
#更改上传文件太大的提示信息 
struts.messages.error.file.too.large=文件上传失败：你要上传的文件太大 
#文件上传其它错误信息 
struts.messages.error.uploading=文件上传失败：发生内部错误 
         别忘了要用native2ascii.exe进行编码转换哦。再运行调试： 
另外，在控制台会看到一条消息： 
                
Unable to find 'struts.multipart.saveDir' property setting. Defaulting to javax.servlet.context.tempdir 
Removing file upload D:\tomcat6.0.13\work\Catalina\localhost\fileload_struts2\upload__4b616fd1_115a3d5d9dc__7fff_00000005.tmp
第一个说是找不以struts.multipart.saveDir，即没有指定临时文件夹，这个很好解决，只需指定一个struts.multipart.saveDir常量值为某个目录来解决。第二个说正在删除一个临时文件，这个临时文件是上传过程中产生的，属正常。 
4.    多文件上传： 
Struts2也可以很方便地实现多文件上传。 
         在输入表单域增加多个文件域：multifileupload.jsp 
                
Java代码   收藏代码
  1. <%@ page language="java" contentType="text/html; charset=UTF-8"%>  
  2. <%@ taglib uri="/struts-tags" prefix="s" %>  
  3. <html>  
  4. <head>  
  5.     <title>多文件上传</title>  
  6. </head>  
  7. <body>  
  8.     <font color="red"><s:fielderror/></font>  
  9.     <form action="multiFileUpload.action" method="POST" enctype="multipart/form-data">  
  10.         文件标题：<input type="text" name="title" size="50" value="${param.title }"/><br/>  
  11.        <!-- 设置二个文件域,名字相同 -->  
  12.         选择第一个文件：<input type="file" name="upload" size="50"/><br/>  
  13.         选择第二个文件：<input type="file" name="upload" size="50"/><br/>  
  14.        <input type="submit" value=" 上传 "/>         
  15.     </form>  
  16. </body>  
  17. </html>  
         在Action类中用数组来封装该多个文件域：MultiFileUploadAction.java 
                
Java代码   收藏代码
  1. package org.qiujy.web.struts2;  
  2. import java.io.BufferedInputStream;  
  3. import java.io.BufferedOutputStream;  
  4. import java.io.File;  
  5. import java.io.FileInputStream;  
  6. import java.io.FileOutputStream;  
  7. import java.io.IOException;  
  8. import java.io.InputStream;  
  9. import java.io.OutputStream;  
  10. import org.apache.struts2.ServletActionContext;  
  11. import com.opensymphony.xwork2.ActionSupport;  
  12. /** 
  13.  *处理多文件上传的Action类 
  14.  * 
  15.  *@authorqiujy 
  16.  *@version1.0 
  17.  */  
  18. publicclass MultiFileUploadAction extends ActionSupport {  
  19.     privatestaticfinalintBUFFER_SIZE = 16 * 1024;  
  20.     // 文件标题  
  21.     private String title;  
  22.     // 用File数组来封装多个上传文件域对象  
  23.     private File[] upload;  
  24.     // 用String数组来封装多个上传文件名  
  25.     private String[] uploadFileName;  
  26.     // 用String数组来封装多个上传文件类型  
  27.     private String[] uploadContentType;  
  28.     // 保存文件的目录路径(通过依赖注入)  
  29.     private String savePath;  
  30.     //以下为所有属性的getter和setter。省略。。。  
  31.     // 自己封装的一个把源文件对象复制成目标文件对象  
  32.     privatestaticvoid copy(File src, File dst) {  
  33.         InputStream in = null;  
  34.         OutputStream out = null;  
  35.         try {  
  36.             in = new BufferedInputStream(new FileInputStream(src), BUFFER_SIZE);  
  37.             out = new BufferedOutputStream(new FileOutputStream(dst),  
  38.                     BUFFER_SIZE);  
  39.             byte[] buffer = newbyte[BUFFER_SIZE];  
  40.             int len = 0;  
  41.             while ((len = in.read(buffer)) > 0) {  
  42.                 out.write(buffer, 0, len);  
  43.             }  
  44.         } catch (Exception e) {  
  45.             e.printStackTrace();  
  46.         } finally {  
  47.             if (null != in) {  
  48.                 try {  
  49.                     in.close();  
  50.                 } catch (IOException e) {  
  51.                     e.printStackTrace();  
  52.                 }  
  53.             }  
  54.             if (null != out) {  
  55.                 try {  
  56.                     out.close();  
  57.                 } catch (IOException e) {  
  58.                     e.printStackTrace();  
  59.                 }  
  60.             }  
  61.         }  
  62.     }  
  63.     @Override  
  64.     public String execute() throws Exception {  
  65.         File[] srcFiles = this.getUpload();  
  66.         // 处理每个要上传的文件  
  67.         for (int i = 0; i < srcFiles.length; i++) {  
  68.             // 根据服务器的文件保存地址和原文件名创建目录文件全路径  
  69.             String dstPath = ServletActionContext.getServletContext()  
  70.                     .getRealPath(this.getSavePath())  
  71.                     + "\\" + this.getUploadFileName()[i];  
  72.             File dstFile = new File(dstPath);  
  73.             this.copy(srcFiles[i], dstFile);  
  74.         }  
  75.         returnSUCCESS;  
  76.     }  
  77. }  
运行结果： 
5.    Struts2的文件下载： 
文件下载相对简单一些，一般只需在页面上提供一个超链接，该链接的href属性等于要下载文件的文件名就行了。但当文件名有中文时，就会导致失败；或者要在用户下载前进行权限判断，这时用Struts2提供的文件下载功能就能简单的解决这些问题。 





common-fileupload是jakarta项目组开发的一个功能很强大的上传文件组件

下面先介绍上传文件到服务器（多文件上传）：

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
import java.util.regex.*;
import org.apache.commons.fileupload.*;

public class upload extends HttpServlet {
  private static final String CONTENT_TYPE = "text/html; charset=GB2312";
  //Process the HTTP Post request
  public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    response.setContentType(CONTENT_TYPE);
    PrintWriter out=response.getWriter();
    try {
    DiskFileUpload fu = new DiskFileUpload();
 // 设置允许用户上传文件大小,单位:字节，这里设为2m
 fu.setSizeMax(2*1024*1024);
 // 设置最多只允许在内存中存储的数据,单位:字节
 fu.setSizeThreshold(4096);
 // 设置一旦文件大小超过getSizeThreshold()的值时数据存放在硬盘的目录
 fu.setRepositoryPath("c://windows//temp");
 //开始读取上传信息
 List fileItems = fu.parseRequest(request);
 // 依次处理每个上传的文件
   Iterator iter = fileItems.iterator();

//正则匹配，过滤路径取文件名
   String regExp=".+(.+)$";

//过滤掉的文件类型
String[] errorType={".exe",".com",".cgi",".asp"};
   Pattern p = Pattern.compile(regExp);
     while (iter.hasNext()) {
       FileItem item = (FileItem)iter.next();
       //忽略其他不是文件域的所有表单信息
       if (!item.isFormField()) {
           String name = item.getName();
           long size = item.getSize();
           if((name==null||name.equals("")) && size==0)
               continue;
       Matcher m = p.matcher(name);
       boolean result = m.find();
       if (result){
           for (int temp=0;temp<ERRORTYPE.LENGTH;TEMP++){
           if (m.group(1).endsWith(errorType[temp])){
                 throw new IOException(name+": wrong type");
           }
           }
           try{

         //保存上传的文件到指定的目录

         //在下文中上传文件至数据库时，将对这里改写
           item.write(new File("d://" + m.group(1)));

           out.print(name+"  "+size+"");
           }
           catch(Exception e){
             out.println(e);
           }

        }
       else
       {
         throw new IOException("fail to upload");
       }
       }
   }
}
 catch (IOException e){
   out.println(e);
 }
 catch (FileUploadException e){
      out.println(e);
 }
 
  }
}

现在介绍上传文件到服务器，下面只写出相关代码：

以sql2000为例，表结构如下：

字段名：name    filecode

类型： varchar     image

数据库插入代码为：PreparedStatement pstmt=conn.prepareStatement("insert into test values(?,?)");

代码如下：

。。。。。。

      try{
        这段代码如果不去掉，将一同写入到服务器中
        //item.write(new File("d://" + m.group(1)));
             
        int byteread=0;
        //读取输入流，也就是上传的文件内容
        InputStream inStream=item.getInputStream();              
pstmt.setString(1,m.group(1));
        pstmt.setBinaryStream(2,inStream,(int)size);
        pstmt.executeUpdate();
        inStream.close();

        out.println(name+"  "+size+" ");
        }

。。。。。。

这样就实现了上传文件至数据库



String realpath = ServletActionContext.getServletContext().getRealPath("/upload") ;//获取服务器路径
        String[] targetFileName = uploadFileName;
        for (int i = 0; i < upload.length; i++) {
           File target = new File(realpath, targetFileName[i]);
              FileUtils.copyFile(upload[i], target); 
              //这是一个文件复制类copyFile()里面就是IO操作，如果你不用这个类也可以自己写一个IO复制文件的类    
         } 

其中private File[] upload;// 实际上传文件

    private String[] uploadContentType; // 文件的内容类型

    private String[] uploadFileName; // 上传文件名

这三个参数必须这样命名，因为文件上传控件默认是封装了这3个参数的，且在action里面他们应有get，set方法




public static synchronized void upload(HttpServletRequest request) {
path = request.getRealPath(request.getContextPath());
try {
DefaultFileItemFactory factory = new DefaultFileItemFactory();
DiskFileUpload up = new DiskFileUpload(factory);
List<FileItem> ls = up.parseRequest(request);
for (FileItem fileItem : ls) {
if (fileItem.isFormField()) {
String FieldName = fileItem.getFieldName();
// getName()返回的是文件名字 普通域没有文件 返回NULL
// String Name = fileItem.getName();
String Content = fileItem.getString("utf-8");
request.setAttribute(FieldName, Content);
} else {

String nm = fileItem.getName().substring(
fileItem.getName().lastIndexOf("\\") + 1);
File mkr = new File(path, nm);
if (mkr.createNewFile()) {
path = path + File.separator + nm;
fileItem.write(mkr);// 非常方便的方法
}
}
}
} catch (Exception e) {
e.printStackTrace();
}

}



评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值