`

struts2文件上传（转）

StrutsApacheWebJSP应用服务器 
阅读更多

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>  
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<html>
<head>
    <title>Struts2 File Upload</title>
</head>
<body>
    <form action="fileUpload.action" method="POST" enctype="multipart/form-data">
        文件标题：<input type="text" name="title" size="50"/><br/>
        选择文件：<input type="file" name="upload" size="50"/><br/>
       <input type="submit" value=" 上传 "/>       
    </form>
</body>
</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. }  
package org.qiujy.web.struts2;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import org.apache.struts2.ServletActionContext;
import com.opensymphony.xwork2.ActionSupport;
/**
 *处理文件上传的Action类
 *@authorqiujy
 *@version1.0
 */
publicclass FileUploadAction extends ActionSupport {
    privatestaticfinalintBUFFER_SIZE = 16 * 1024;
    // 文件标题
    private String title;
    // 上传文件域对象
    private File upload;
    // 上传文件名
    private String uploadFileName;
    // 上传文件类型
    private String uploadContentType;
    // 保存文件的目录路径(通过依赖注入)
    private String savePath;
    //以下省略getter和setter......
    //自己封装的一个把源文件对象复制成目标文件对象
    privatestaticvoid copy(File src, File dst) {
        InputStream in = null;
        OutputStream out = null;
        try {
            in = new BufferedInputStream(new FileInputStream(src), BUFFER_SIZE);
            out = new BufferedOutputStream(new FileOutputStream(dst),
                    BUFFER_SIZE);
            byte[] buffer = newbyte[BUFFER_SIZE];
            int len = 0;
            while ((len = in.read(buffer)) > 0) {
                out.write(buffer, 0, len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (null != in) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != out) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    @Override
    public String execute() throws Exception {
        //根据服务器的文件保存地址和原文件名创建目录文件全路径
        String dstPath = ServletActionContext.getServletContext()
                                .getRealPath(this.getSavePath())
                                + "\\" + this.getUploadFileName();
       
        System.out.println("上传的文件的类型："+ this.getUploadContentType());
       
        File dstFile = new File(dstPath);
        copy(this.upload, dstFile);
        returnSUCCESS;
    }
}

上面这个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>  
                
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
        "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
    <package name ="fileUploadDemo" extends ="struts-default">
        <action name ="fileUpload"
class ="org.qiujy.web.struts2.FileUploadAction">
<!-- 动态设置Action中的savePath属性的值 -->
            <param name="savePath">/upload</param>
            <result name ="success">/showupload.jsp</result>
        </action >
    </package >
</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>  
                
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
        "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
    <constant name="struts.custom.i18n.resources" value="messages"/>
    <package name="fileUploadDemo" extends="struts-default">
        <action name="fileUpload"
            class="org.qiujy.web.struts2.FileUploadAction">
            <interceptor-ref name="fileUpload">
              <!-- 配置允许上传的文件类型，多个用","分隔 -->
              <param name="allowedTypes">
    　　　　　　image/bmp,image/png,image/gif,image/jpeg,image/jpg

,image/x-png, image/pjpeg
              </param>
              <!-- 配置允许上传的文件大小，单位字节 -->
              <param name="maximumSize">102400</param>
           </interceptor-ref>
           <interceptor-ref name="defaultStack" />
            <!-- 动态设置Action中的savePath属性的值 -->
            <param name="savePath">/upload</param>
            <result name="input">/index.jsp</result>
            <result name="success">/showupload.jsp</result>
        </action>
    </package>
</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>  
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<%@ taglib uri="/struts-tags" prefix="s" %>
<html>
<head>
    <title>多文件上传</title>
</head>
<body>
    <font color="red"><s:fielderror/></font>
    <form action="multiFileUpload.action" method="POST" enctype="multipart/form-data">
        文件标题：<input type="text" name="title" size="50" value="${param.title }"/><br/>
       <!-- 设置二个文件域,名字相同 -->
        选择第一个文件：<input type="file" name="upload" size="50"/><br/>
        选择第二个文件：<input type="file" name="upload" size="50"/><br/>
       <input type="submit" value=" 上传 "/>       
    </form>
</body>
</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. }  
package org.qiujy.web.struts2;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import org.apache.struts2.ServletActionContext;
import com.opensymphony.xwork2.ActionSupport;
/**
 *处理多文件上传的Action类
 *
 *@authorqiujy
 *@version1.0
 */
publicclass MultiFileUploadAction extends ActionSupport {
    privatestaticfinalintBUFFER_SIZE = 16 * 1024;
    // 文件标题
    private String title;
    // 用File数组来封装多个上传文件域对象
    private File[] upload;
    // 用String数组来封装多个上传文件名
    private String[] uploadFileName;
    // 用String数组来封装多个上传文件类型
    private String[] uploadContentType;
    // 保存文件的目录路径(通过依赖注入)
    private String savePath;
    //以下为所有属性的getter和setter。省略。。。
    // 自己封装的一个把源文件对象复制成目标文件对象
    privatestaticvoid copy(File src, File dst) {
        InputStream in = null;
        OutputStream out = null;
        try {
            in = new BufferedInputStream(new FileInputStream(src), BUFFER_SIZE);
            out = new BufferedOutputStream(new FileOutputStream(dst),
                    BUFFER_SIZE);
            byte[] buffer = newbyte[BUFFER_SIZE];
            int len = 0;
            while ((len = in.read(buffer)) > 0) {
                out.write(buffer, 0, len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (null != in) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != out) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    @Override
    public String execute() throws Exception {
        File[] srcFiles = this.getUpload();
        // 处理每个要上传的文件
        for (int i = 0; i < srcFiles.length; i++) {
            // 根据服务器的文件保存地址和原文件名创建目录文件全路径
            String dstPath = ServletActionContext.getServletContext()
                    .getRealPath(this.getSavePath())
                    + "\\" + this.getUploadFileName()[i];
            File dstFile = new File(dstPath);
            this.copy(srcFiles[i], dstFile);
        }
        returnSUCCESS;
    }
}

运行结果：
5.    Struts2的文件下载：
文件下载相对简单一些，一般只需在页面上提供一个超链接，该链接的href属性等于要下载文件的文件名就行了。但当文件名有中文时，就会导致失败；或者要在用户下载前进行权限判断，这时用Struts2提供的文件下载功能就能简单的解决这些问题。

分享到：
| 类设计原则
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    struts2文件上传下载源代码

    在Struts2中，文件上传和下载是常见的功能需求，特别是在处理用户交互和数据交换时。这篇博客文章提供的"struts2文件上传下载源代码"旨在帮助开发者理解和实现这些功能。 文件上传功能允许用户从他们的设备上传文件...

    struts2实现文件上传下载

    首先，我们需要了解Struts2中的文件上传机制。Struts2提供了`FileUploadInterceptor`拦截器来处理文件上传请求。在处理文件上传时，开发者需要在Action类中声明一个`List&lt;FileInfo&gt;`类型的字段，用于接收上传的文件...

    struts2文件上传jar

    这个压缩包包含了实现Struts2文件上传所需的全部jar包，这些库文件对于理解和实现文件上传功能至关重要。 首先，我们要了解Struts2文件上传的基本流程。当用户通过表单提交包含文件输入字段的请求时，Struts2框架会...

    Struts2多个文件上传

    在Struts2中，文件上传功能是一个常用特性，尤其在处理用户提交的多个文件时。本文将详细讲解如何使用Struts2进行多个文件的上传，重点是使用List集合进行上传。 首先，要实现Struts2的文件上传，必须引入必要的...

    struts2文件上传实例

    1. **.struts2配置**：在Struts2框架中，需要在`struts.xml`配置文件中添加相应的action配置，声明文件上传的处理方法。通常，你需要设置`&lt;result&gt;`类型为`stream`，以便处理上传的文件。 2. **Action类**：创建一...

    Struts2之struts2文件上传详解案例struts011

    在这个"Struts2之struts2文件上传详解案例struts011"中，我们将深入探讨如何实现这一功能。 首先，我们需要了解Struts2中的Action类，它是处理用户请求的核心组件。为了支持文件上传，我们需要创建一个继承自`org....

    struts2文件上传

    Struts2 文件上传是Web开发中的一个重要功能，它允许用户从他们的本地计算机向服务器传输文件。在Struts2框架中，文件上传是通过特定的拦截器实现的，这些拦截器处理了文件上传请求并提供了安全性和大小限制。下面将...

    struts2 文件上传

    struts2 文件上传 struts2上传标签file fileuploadstruts2 文件上传 struts2上传标签file fileuploadstruts2 文件上传 struts2上传标签file fileupload

    简单易懂的struts2文件上传

    在Struts2中，文件上传功能是一个常见的需求，例如用户可能需要上传图片、文档或其他类型的文件。本教程将深入浅出地讲解如何在Struts2中实现文件上传，并提供一个简单的实例来帮助理解。 1. **Struts2文件上传概述...

    struts2文件上传和下载

    在Struts2中，文件上传和下载是常见的功能需求，对于用户交互和数据交换至关重要。以下是对这些知识点的详细阐述： 1. **文件上传**: 在Struts2中，文件上传主要依赖于`Commons FileUpload`库，它是一个Apache提供...

    struts2文件上传例子.rar

    在“struts2文件上传例子.rar”这个项目中，开发者已经使用Struts2.0框架实现了一个简单的文件上传功能。MyEclipse 6.6是一个集成开发环境，支持Java EE项目开发，可以直接导入该项目进行运行和调试。 首先，我们...

    Struts2文件上传源码

    6. **源码分析**: 要深入理解Struts2的文件上传机制，你需要查看Struts2的源码，特别是`org.apache.struts2.dispatcher.multipart.JakartaMultiPartRequest`和`org.apache.struts2.components.Form`这两个类。...

    struts2文件上传下载

    在这个特定的项目中，我们关注的是"struts2文件上传下载"的功能，这涉及到用户通过Web界面上传文件到服务器，以及从服务器下载文件到用户的设备。 文件上传是Web应用中的常见需求，例如用户可能需要提交图片、文档...

    JavaEE Struts文件上传

    2. **添加Struts2插件**：Struts2的文件上传功能依赖于`struts2-convention-plugin`和`struts2-core`等库。在`struts.xml`配置文件中，需要启用Multipart解析器，例如添加`&lt;constant name="struts.multipart.parser...

    Struts2文件上传程序示例

    Struts2文件上传程序是一个典型的企业级Web应用开发中的功能，它允许用户通过网页将本地文件上传到服务器。Struts2作为一款强大的MVC（Model-View-Controller）框架，提供了丰富的功能支持，包括文件上传。这个示例...

    Struts2文件上传与下载

    Struts2是一个强大的Java web框架，它为开发者提供了丰富的功能，包括处理用户表单提交、进行文件上传和下载。在Web应用中，文件上传和下载是常见的需求，例如用户上传头像、下载文档等。Struts2通过其Action类和...

    struts2 文件上传功能

    Struts 2是通过Commons FileUpload文件上传。Commons FileUpload通过将HTTP的数据保存到临时文件夹，然后Struts使用fileUpload拦截器将文件绑定到Action的实例中。从而我们就能够以本地文件方式的操作浏览器上传的...

    struts2 文件上传 测试通过版

    在Struts2中，文件上传功能是常见的需求，特别是在处理用户提交表单时，比如上传图片、文档等。本文将详细讲解如何在Struts2中实现文件上传功能，并探讨相关知识点。 1. **Struts2 Action类配置**： 在Struts2中，...

Magicbox
Global site tag (gtag.js) - Google Analytics