下面就分两部分简单介绍beanutils、dbutils在基于JDBC API数据库存取操作中的运用。第一部分显介绍beanutils在JDBC数据库存取操作中的运用，第二部分介绍dbutils在JDBC数据库存取操作中的运用，最后看看他们的优缺点，谈谈本人在项目运用过程中对他们的一点心得体会，仅供参考，其中有错误的地方希望大虾不吝赐教，大家多多交流共同进步。

    一、Jakarta Commons beanutils

    Beanutils是操作Bean的锐利武器，其提过的BeanUtils工具类可以简单方便的读取或设置Bean的属性，利用Dyna系列，还可以在运行期创建Bean，符合懒人的习惯，正如LazyDynaBean，LazyDynaClass一样，呵呵。这些用法已经有很多文章提及，也可以参考apache的官方文档。

    对于直接利用JDBC API访问数据库时（这里针对的是返回结果集ResultSet的查询select），大多数都是采用两种方式，一种是取出返回的结果集的数据存于Map中，另一种方式是Bean里。针对第二种方式，Beanutils里提供了ResultSetDynaClass结合DynaBean以及RowSetDynaClass结合DynaBean来简化操作。下面用以个简单的例子展示一下beanutils的这两个类在JDBC数据库操作中的运用。

    请在本机建立数据库publish，我用的是MySQL，在publish数据库中建立表book,脚本如下：

CREATE TABLE book(

  id int(11) NOT NULL auto_increment,

  title varchar(50) character set latin1 NOT NULL,

  authors varchar(50) character set latin1 default NULL,

  PRIMARY KEY  (id)

)

    然后用你喜欢的编辑器建立一个类BeanutilsJDBCTest，我们先用ResultSetDynaClass来处理，然后再用RowSetDynaClass来实现同样的类，之后看看他们之间有什么不同，用ResultSetDynaClass处理的源代码如下所示:

    然后用你喜欢的编辑器建立一个类BeanutilsJDBCTest，我们先用ResultSetDynaClass来处理，然后再用RowSetDynaClass来实现同样的类，之后看看他们之间有什么不同，用ResultSetDynaClass处理的源代码如下所示:

package cn.qtone.test;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.Statement;

import java.util.Iterator;

import org.apache.commons.beanutils.DynaBean;

import org.apache.commons.beanutils.PropertyUtils;

import org.apache.commons.beanutils.ResultSetDynaClass;

public class BeanutilsJDBCTest{

       public static void main(String[] args) {

              Connection con = null;

              Statement st = null;

              ResultSet rs = null;

              try {

                     Class.forName("com.mysql.jdbc.Driver");

                     String url = "jdbc:mysql://127.0.0.1:3306/publish?useUnicode=true&characterEncoding=GBK";

                     con = DriverManager.getConnection(url, "root", "hyys");

                     st = con.createStatement();

                     rs = st.executeQuery("select * from book");

                     ResultSetDynaClass rsDynaClass = new ResultSetDynaClass(rs);

                     Iterator itr = rsDynaClass.iterator();

                     System.out.println("title-------------authors");

                     while (itr.hasNext()) {

                            DynaBean dBean = (DynaBean) itr.next();

                            System.out.println(PropertyUtils.getSimpleProperty(dBean,"title")

                                          + "-------------"+ PropertyUtils.getSimpleProperty(dBean, "authors"));

                     }

              } catch (Exception e) {

                     e.printStackTrace();

              } finally {

                     try {

                            if (rs != null) {

                                   rs.close();

                            }

                            if (st != null) {

                                   st.close();

                            }

                            if (con != null) {

                                   con.close();

                            }

                     } catch (Exception e) {

                            e.printStackTrace();

                     }

              }

       }

}

    用RowSetDynaClass处理的源代码如下所示:

package cn.qtone.test;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.Statement;

import java.util.Iterator;

import java.util.List;

import org.apache.commons.beanutils.DynaBean;

import org.apache.commons.beanutils.PropertyUtils;

import org.apache.commons.beanutils.RowSetDynaClass;

public class BeanutilsJDBCTest{

       public static void main(String[] args) {

              List rsDynaClass = rsTest();

              System.out.println("title ------------- authors ");

              Iterator itr = rsDynaClass.iterator();

              while (itr.hasNext()) {

                     DynaBean dBean = (DynaBean) itr.next();

                     try {

                            System.out.println(PropertyUtils.getSimpleProperty(dBean,"name")

                                          + "-------------"+ PropertyUtils.getSimpleProperty(dBean, "mobile"));

                     } catch (Exception e) {

                            // TODO 自动生成 catch 块

                            e.printStackTrace();

                    }

              }

       }

       private static List rsTest() {

              Connection con = null;

              Statement st = null;

              ResultSet rs = null;

              try {

                     Class.forName("com.mysql.jdbc.Driver");

                     String url = "jdbc:mysql://127.0.0.1:3306/publish?useUnicode=true&characterEncoding=GBK";

                     con = DriverManager.getConnection(url, "root", "hyys");

                     st = con.createStatement();

                     rs = st.executeQuery("select * from book");

                     RowSetDynaClass rsdc = new RowSetDynaClass(rs);

                     return rsdc.getRows();

              } catch (Exception e) {

                     e.printStackTrace();

              } finally {

                     try {

                            if (rs != null) {

                                   rs.close();

                            }

                            if (st != null) {

                                   st.close();

                            }

                            if (con != null) {

                                   con.close();

                            }

                     } catch (Exception e) {

                            e.printStackTrace();

                     }

              }

              return null;

       }

}

    这两个方法输出的结果应该是一样的。但是很显然第二种方式比第一种方式要好，它把数据访问部分抽取出来放到一个方法中，显得简单清晰。

    其实在利用ResultSetDynaClass时，必须在ResultSet等数据库资源关闭之前，处理好那些数据，你不能在资源关闭之后使用DynaBean，否则就会抛出异常，异常就是说不能在ResultSet之后存取数据（具体的异常名我也忘了），当然你也可以采用以前的方式一个一个的把数据放到Map里，如果你一定要那样做，建议还是别用Beanutils，因为这没带给你什么好处。总之利用ResultSetDynaClass你的程序的扩展性非常部好。

    从第二中方式可以看出，利用RowSetDynaClass可以很好的解决上述ResultSetDynaClass遇到的问题，RowSetDynaClass的getRows()方法，把每一行封装在一个DynaBean对象里，然后，把说有的行放到一个List里，之后你就可以对返回的List里的每一个DynaBean进行处理，此外对于DynaBean你还可以采用标准的get/set方式处理，当然你也可以用PropertyUtils. getSimpleProperty(Object bean, String name)进行处理。

    从上面的分析中，你应该可以决定你应该使用ResultSetDynaClass还是RowSetDynaClass了。

    虽然现在出现了很多ORM框架，可是还是有很多朋友也许还在使用JDBC，就像我现在一样，除了学习的时候在使用Hibernate、Spring类似这些优秀的框架，工作时一直都在使用JDBC。本文就简单介绍一下利用Jakarta Commons旗下beanutils、dbutils简化JDBC数据库操作，以抛砖引玉，希望对像我一样在使用JDBC的朋友有所帮助。

    下面就分两部分简单介绍beanutils、dbutils在基于JDBC API数据库存取操作中的运用。第一部分显介绍beanutils在JDBC数据库存取操作中的运用，第二部分介绍dbutils在JDBC数据库存取操作中的运用，最后看看他们的优缺点，谈谈本人在项目运用过程中对他们的一点心得体会，仅供参考，其中有错误的地方希望大虾不吝赐教，大家多多交流共同进步。

    一、Jakarta Commons beanutils

    Beanutils是操作Bean的锐利武器，其提过的BeanUtils工具类可以简单方便的读取或设置Bean的属性，利用Dyna系列，还可以在运行期创建Bean，符合懒人的习惯，正如LazyDynaBean，LazyDynaClass一样，呵呵。这些用法已经有很多文章提及，也可以参考apache的官方文档。

    对于直接利用JDBC API访问数据库时（这里针对的是返回结果集ResultSet的查询select），大多数都是采用两种方式，一种是取出返回的结果集的数据存于Map中，另一种方式是Bean里。针对第二种方式，Beanutils里提供了ResultSetDynaClass结合DynaBean以及RowSetDynaClass结合DynaBean来简化操作。下面用以个简单的例子展示一下beanutils的这两个类在JDBC数据库操作中的运用。

    请在本机建立数据库publish，我用的是MySQL，在publish数据库中建立表book,脚本如下：

CREATE TABLE book(
  id int(11) NOT NULL auto_increment,
  title varchar(50) character set latin1 NOT NULL,
  authors varchar(50) character set latin1 default NULL,
  PRIMARY KEY  (id)
)

    然后用你喜欢的编辑器建立一个类BeanutilsJDBCTest，我们先用ResultSetDynaClass来处理，然后再用RowSetDynaClass来实现同样的类，之后看看他们之间有什么不同，用ResultSetDynaClass处理的源代码如下所示:

    然后用你喜欢的编辑器建立一个类BeanutilsJDBCTest，我们先用ResultSetDynaClass来处理，然后再用RowSetDynaClass来实现同样的类，之后看看他们之间有什么不同，用ResultSetDynaClass处理的源代码如下所示:

package cn.qtone.test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Iterator;
import org.apache.commons.beanutils.DynaBean;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.beanutils.ResultSetDynaClass;
public class BeanutilsJDBCTest{
       public static void main(String[] args) {
              Connection con = null;
              Statement st = null;
              ResultSet rs = null;
              try {
                     Class.forName("com.mysql.jdbc.Driver");
                     String url = "jdbc:mysql://127.0.0.1:3306/publish?useUnicode=true&characterEncoding=GBK";
                     con = DriverManager.getConnection(url, "root", "hyys");
                     st = con.createStatement();
                     rs = st.executeQuery("select * from book");
                     ResultSetDynaClass rsDynaClass = new ResultSetDynaClass(rs);
                     Iterator itr = rsDynaClass.iterator();
                     System.out.println("title-------------authors");
                     while (itr.hasNext()) {
                            DynaBean dBean = (DynaBean) itr.next();
                            System.out.println(PropertyUtils.getSimpleProperty(dBean,"title")
                                          + "-------------"+ PropertyUtils.getSimpleProperty(dBean, "authors"));
                     }
              } catch (Exception e) {
                     e.printStackTrace();
              } finally {
                     try {
                            if (rs != null) {
                                   rs.close();
                            }
                            if (st != null) {
                                   st.close();
                            }
                            if (con != null) {
                                   con.close();
                            }
                     } catch (Exception e) {
                            e.printStackTrace();
                     }
              }
       }
}

    用RowSetDynaClass处理的源代码如下所示:

package cn.qtone.test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Iterator;
import java.util.List;
import org.apache.commons.beanutils.DynaBean;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.beanutils.RowSetDynaClass;
public class BeanutilsJDBCTest{
       public static void main(String[] args) {
              List rsDynaClass = rsTest();
              System.out.println("title ------------- authors ");
              Iterator itr = rsDynaClass.iterator();
              while (itr.hasNext()) {
                     DynaBean dBean = (DynaBean) itr.next();
                     try {
                            System.out.println(PropertyUtils.getSimpleProperty(dBean,"name")
                                          + "-------------"+ PropertyUtils.getSimpleProperty(dBean, "mobile"));
                     } catch (Exception e) {
                            // TODO 自动生成 catch 块
                            e.printStackTrace();
                     }
              }
       }
       private static List rsTest() {
              Connection con = null;
              Statement st = null;
              ResultSet rs = null;
              try {
                     Class.forName("com.mysql.jdbc.Driver");
                     String url = "jdbc:mysql://127.0.0.1:3306/publish?useUnicode=true&characterEncoding=GBK";
                     con = DriverManager.getConnection(url, "root", "hyys");
                     st = con.createStatement();
                     rs = st.executeQuery("select * from book");
                     RowSetDynaClass rsdc = new RowSetDynaClass(rs);
                     return rsdc.getRows();
              } catch (Exception e) {
                     e.printStackTrace();
              } finally {
                     try {
                            if (rs != null) {
                                   rs.close();
                            }
                            if (st != null) {
                                   st.close();
                            }
                            if (con != null) {
                                   con.close();
                            }
                     } catch (Exception e) {
                            e.printStackTrace();
                     }
              }
              return null;
       }
}

    这两个方法输出的结果应该是一样的。但是很显然第二种方式比第一种方式要好，它把数据访问部分抽取出来放到一个方法中，显得简单清晰。

    其实在利用ResultSetDynaClass时，必须在ResultSet等数据库资源关闭之前，处理好那些数据，你不能在资源关闭之后使用DynaBean，否则就会抛出异常，异常就是说不能在ResultSet之后存取数据（具体的异常名我也忘了），当然你也可以采用以前的方式一个一个的把数据放到Map里，如果你一定要那样做，建议还是别用Beanutils，因为这没带给你什么好处。总之利用ResultSetDynaClass你的程序的扩展性非常部好。

    从第二中方式可以看出，利用RowSetDynaClass可以很好的解决上述ResultSetDynaClass遇到的问题，RowSetDynaClass的getRows()方法，把每一行封装在一个DynaBean对象里，然后，把说有的行放到一个List里，之后你就可以对返回的List里的每一个DynaBean进行处理，此外对于DynaBean你还可以采用标准的get/set方式处理，当然你也可以用PropertyUtils. getSimpleProperty(Object bean, String name)进行处理。

    从上面的分析中，你应该可以决定你应该使用ResultSetDynaClass还是RowSetDynaClass了。

    未完待续……

public ActionForward execute(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response) {
  String strFileName = "测试文件.rar";
  File file = new File("具体路径" + strFileName);//
  if(file.exists()){
   try{
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
    byte[] buffer = new byte[1024];
    strFileName = java.net.URLEncoder.encode(strFileName, "UTF-8");//处理中文文件名的问题
    strFileName = new String(strFileName.getBytes("UTF-8"),"GBK");//处理中文文件名的问题
    response.reset();
    response.setCharacterEncoding("UTF-8");
    response.setContentType("application/x-rar-compressed");//不同类型的文件对应不同的MIME类型
    response.setHeader("Content-Disposition","attachment; filename=" + strFileName);
    OutputStream os = response.getOutputStream();
    while(bis.read(buffer) > 0){
     os.write(buffer);
    }
    bis.close();
    os.close();
   }
   catch(Exception e){
    ......
   }
  }
  return mapping.getInputForward();
 }

在Struts中的实现和在ASP.NET的实现类似，这段代码就是将服务器上的文件以流的方式发送到客户端浏览器，如果要是在线打开的方式的话还应将response.setHeader("Content-Disposition","attachment; filename=" + strFileName);改写为response.setHeader("Content-Disposition","inline; filename=" + strFileName);

jsp文件上传大多采用采用开源项目来简化处理，这里列出常用的两个jar包的实现，并进行比较，说明他们的优缺点和应该注意的问题。

Commons FileUpload，可以在http://jakarta.apache.org/commons/fileupload/下载，这个包需要Commons IO的支持，可以在http://jakarta.apache.org/commons/io/下载

com.oreilly.servlet，可以在http://www.servlets.com/cos/下载
Commons FileUpload提供三种文件上传处理方式，DiskFileUpload、ServletFileUpload和PortletFileUpload三种方式，其中DiskFileUpload已经在javadoc下已经被标记为过期的方法，建议用ServletFileUpload代替，而PortletFileUpload需要配合portlet-api来使用，所以这里我们只介绍ServletFileUpload，并且这个也是最常用的。

com.oreilly.servlet也提供了三种文件上传的处理方式，MultipartWrapper、MultipartRequest和MultipartParser三种方式，其中MultipartWrapper和MultipartRequest的用法基本相同，并且没有MultipartRequest提供的操作多，所以这里介绍MultipartRequest，MultipartParser和前两者有些不同，可以用来处理某些特殊情况，例如表单中有两个同名的文件上传选择框。

我们暂时称三面三种文件上传方式分别为：ServletFileUpload方式（MultipartTestServlet）、MultipartRequest方式（MultipartTestServlet2）、MultipartParser方式（MultipartTestServlet3）

代码如下：
test.html

<%@ page language="java" import="java.util.*" contentType="text/html;charset=gbk" pageEncoding="gbk"%>
<html>
   <body>
     <form action="MultipartTestServlet" enctype="multipart/form-data" method="post">
      <input type="text" name="username" /><br />
      <input type="file" name="myfile" /><br/>
      <input type="file" name="myfile" /><br/>
      <input type="submit" />
     </form>
     <br/><br/><br/><br/>
     <form action="MultipartTestServlet2" enctype="multipart/form-data" method="post">
      <input type="text" name="username" /><br />
      <input type="file" name="myfile" /><br/>
      <input type="file" name="myfile" /><br/>
      <input type="submit" />
     </form>
     <br/><br/><br/><br/>
     <form action="MultipartTestServlet3" enctype="multipart/form-data" method="post">
      <input type="text" name="username" /><br />
      <input type="file" name="myfile" /><br/>
      <input type="file" name="myfile" /><br/>
      <input type="submit" />
     </form>
   </body>
</html>
MultipartTestServlet.java

package com.bug.servlet;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
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.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUpload;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.RequestContext;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.fileupload.servlet.ServletRequestContext;

public class MultipartTestServlet extends HttpServlet {

public MultipartTestServlet() {
   super();
}

public void doPost(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {

   request.setCharacterEncoding("gbk");
   RequestContext requestContext = new ServletRequestContext(request);
  
   if(FileUpload.isMultipartContent(requestContext)){
   
    DiskFileItemFactory factory = new DiskFileItemFactory();
    factory.setRepository(new File("c:/tmp/"));
    ServletFileUpload upload = new ServletFileUpload(factory);
    //upload.setHeaderEncoding("gbk");
    upload.setSizeMax(2000000);
    List items = new ArrayList();
     try {
      items = upload.parseRequest(request);
     } catch (FileUploadException e1) {
      System.out.println("文件上传发生错误" + e1.getMessage());
     }

    Iterator it = items.iterator();
    while(it.hasNext()){
     FileItem fileItem = (FileItem) it.next();
     if(fileItem.isFormField()){      
      System.out.println(fileItem.getFieldName() + "    " + fileItem.getName() + "    " + new String(fileItem.getString().getBytes("iso8859-1"), "gbk"));
     }else{
      System.out.println(fileItem.getFieldName() + "    " +
         fileItem.getName() + "    " +
         fileItem.isInMemory() + "     " +
         fileItem.getContentType() + "    " +
         fileItem.getSize());
     
      if(fileItem.getName()!=null && fileItem.getSize()!=0){
       File fullFile = new File(fileItem.getName());
       File newFile = new File("c:/temp/" + fullFile.getName());
       try {
        fileItem.write(newFile);
       } catch (Exception e) {
        e.printStackTrace();
       }
      }else{
       System.out.println("文件没有选择 或 文件内容为空");
      }
     }
     
    }
   }
}

}

MultipartTestServlet2.java

package com.bug.servlet;

import java.io.IOException;
import java.util.Enumeration;

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

import com.oreilly.servlet.MultipartRequest;
import com.oreilly.servlet.multipart.DefaultFileRenamePolicy;

public class MultipartTestServlet2 extends HttpServlet {

public MultipartTestServlet2() {
   super();
}

public void doPost(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {

   //request.setCharacterEncoding("gbk");   不起作用
   System.out.println("start ");
   MultipartRequest multi = new MultipartRequest(request, "c:/tmp/", 2*1024*1024, "gbk", new DefaultFileRenamePolicy());
   System.out.println("start ");
   Enumeration filesName = multi.getFileNames();
   Enumeration paramsName = multi.getParameterNames();
   while(paramsName.hasMoreElements()){
    String paramName = (String) paramsName.nextElement();
    System.out.println(multi.getParameter(paramName));
   }
   while(filesName.hasMoreElements()){
    String fileName = (String) filesName.nextElement();
    System.out.println(multi.getFilesystemName(fileName) + "   " +
           multi.getOriginalFileName(fileName) + "   " +
           multi.getContentType(fileName) + "   ");
    if(multi.getFilesystemName(fileName)!=null && !multi.getFilesystemName(fileName).equals(""))
     System.out.println(multi.getFile(fileName).toURI());
   }
}

}

MultipartTestServlet3.java

package com.bug.servlet;

import java.io.File;
import java.io.IOException;

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

import com.oreilly.servlet.multipart.FilePart;
import com.oreilly.servlet.multipart.MultipartParser;
import com.oreilly.servlet.multipart.ParamPart;
import com.oreilly.servlet.multipart.Part;

public class MultipartTestServlet3 extends HttpServlet {

public MultipartTestServlet3() {
   super();
}

public void doPost(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {

       MultipartParser mp = new MultipartParser(request, 2*1024*1024, false, false, "gbk");
       Part part;
       while ((part = mp.readNextPart()) != null) {
         String name = part.getName();
         if (part.isParam()) {
           ParamPart paramPart = (ParamPart) part;
           String value = paramPart.getStringValue();
           System.out.println("param: name=" + name + "; value=" + value);
         }
         else if (part.isFile()) {
           // it's a file part
           FilePart filePart = (FilePart) part;
           String fileName = filePart.getFileName();
           if (fileName != null) {
             long size = filePart.writeTo(new File("c:/tmp/"));
             System.out.println("file: name=" + name + "; fileName=" + fileName +
               ", filePath=" + filePart.getFilePath() +
               ", contentType=" + filePart.getContentType() +
               ", size=" + size);
           }
           else {
            System.out.println("file: name=" + name + "; EMPTY");
           }
           System.out.flush();
         }
       }
     }

}

web.xml中加入

<servlet>
     <servlet-name>MultipartTestServlet</servlet-name>
     <servlet-class>com.bug.servlet.MultipartTestServlet</servlet-class>
   </servlet>
   <servlet>
     <servlet-name>MultipartTestServlet2</servlet-name>
     <servlet-class>com.bug.servlet.MultipartTestServlet2</servlet-class>
   </servlet>
   <servlet>
     <servlet-name>MultipartTestServlet3</servlet-name>
     <servlet-class>com.bug.servlet.MultipartTestServlet3</servlet-class>
   </servlet>
   <servlet-mapping>
     <servlet-name>MultipartTestServlet</servlet-name>
     <url-pattern>/MultipartTestServlet</url-pattern>
   </servlet-mapping>
   <servlet-mapping>
     <servlet-name>MultipartTestServlet2</servlet-name>
     <url-pattern>/MultipartTestServlet2</url-pattern>
   </servlet-mapping>
   <servlet-mapping>
     <servlet-name>MultipartTestServlet3</servlet-name>
     <url-pattern>/MultipartTestServlet3</url-pattern>
   </servlet-mapping>

我用过第一个例子的:

<!--注意:

1.当利用ServletUpload时<input type="radio" checked="checked">的元素会被认为是文件元素<input type="file"> 
从而会被解析出几个空File出来

2.当使用在struts的action时,action的name不要设置,否则解析不出文件控件存在.因为actionform之前被解析掉了.
-->

问题1、中文问题：
三种凡是都可以通过自己的方法来设置encoding为gbk开处理和解决中文问题，包括初始化的时候传入gbk作为参数，或是是初始化后通过setEncoding的方式来实现。
另外ServletFileUpload方式也可以通过request.setCharacterEncoding("gbk");的方式来实现，而其它两种方式不支持这种方式。

问题2、文件大小限制
ServletFileUpload方式可以设置文件大小限制，也可以不用设置，例子中的upload.setSizeMax(2000000)就可以注释掉。如果设置upload.setSizeMax(-1)，表明不限制上传的大小。文档中没有指明默认的限制的多少，我在不设置的情况下上传了一个9M的东西，可以上传，估计默认是不限制大小的。
而MultipartRequest方式和MultipartParser方式是必须设置文件的上传文件的大小限制的，如果不设置，默认是1M的大小限制。

问题3、文件上传发生错误
如果文件上传过程中发生任何错误，或者是文件的大小超出了范围，系统都将抛出错误。
ServletFileUpload方式在upload.parseRequest(request)时抛出错误
MultipartRequest方式在new MultipartRequest(。。。)时抛出错误
MultipartParser方式在new MultipartParser(。。。)时抛出错误

问题4、上传同名文件时，他们保存到临时目录是的冲突问题
ServletFileUpload方式，不会有冲突，系统会把上传得文件按照一定的规则重新命名，保证不会冲突
MultipartParser方式，会产生冲突，系统会把文件按照上传时的文件名，保存到临时目录下，如果两个用会同时上传文件名相同的文件，那么就可能会产生冲突，一方把另一方的临时文件给替换了。
MultipartRequest方式，在初始化时如果提供了一个名称转换策略，就不会有冲突，如果不提桶，就会有冲突。在上面的例子中我们提供了一个new DefaultFileRenamePolicy()保证了文件名不会有冲突发生。

问题5：表单中有两个同名的文件上传选择框，就像我们例子中的myfile一样，每个表单中有两个name=“myfile”的上传框
ServletFileUpload方式，可以处理，可以分别得到他们各自的文件，
MultipartRequest方式，不可以处理，会发生冲突，会有一个上传框的文件覆盖了另外一个。
MultipartParser方式，可以处理，可以分别得到他们各自的文件，

备注：
代码比较乱，主要是为了说明他们间的区别。他们的详细地使用说明还是要参考他的javadoc和domo。

参考：
1、http://www.servlets.com/cos/#classes
2、http://jakarta.apache.org/commons/fileupload/apidocs/index.html
3、http://jakarta.apache.org/commons/fileupload/using.html
4、http://www.onjava.com/pub/a/onjava/2003/06/25/commons.html?page=3

<%@ taglib uri="http://struts.apache.org/tags-bean" prefix="bean" %>
<%@ taglib uri="http://struts.apache.org/tags-html" prefix="html" %>
<%@ taglib uri="http://struts.apache.org/tags-logic" prefix="logic" %>
<%@ taglib uri="http://struts.apache.org/tags-tiles" prefix="tiles" %>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html:html>
<head>
<title>
multiUploadDemo
</title>
</head>
<script language="javascript">
   var num = 0;
 
 function upload(){
  document.getElementById("status").innerHTML = "文件上传中...";
     multiUploadForm.submit();
   }

function additem(id)
{
 var row,cell,str;
 row = eval("document.all["+'"'+id+'"'+"]").insertRow();
 if(row != null )
    {
       cell = row.insertCell();
       str="<input type="+'"'+"file"+'"'+" name=uploadFile["+ num +"].file><input type="+'"'+"button"+'"'+" value="+'"'+"删除"+'"'+" onclick='deleteitem(this,"+'"'+"tb"+'"'+");'>"
      cell.innerHTML=str;
    }
 num++;
}
function deleteitem(obj,id)
{
 var rowNum,curRow;
 curRow = obj.parentNode.parentNode;
 rowNum = eval("document.all."+id).rows.length - 1;
 eval("document.all["+'"'+id+'"'+"]").deleteRow(curRow.rowIndex);
}
function callback(msg)
{
 document.getElementById("status").innerHTML = "文件上传完成...<br>" + msg;
}
</script>
<body bgcolor="#ffffff">
<div id="status"></div>
<html:form method="post" action="/multiUpload.do" enctype="multipart/form-data" target="hidden_frame">

<table id="tb">
</table>

</html:form>
<iframe name='hidden_frame' id="hidden_frame" style="display:none"></iframe>
<input type="button" name="btnAddFile" value="Add File" onclick="additem('tb')"/>
<input type="button" name="btnUpload" value="upload" onclick="upload()"/>
</body>
</html:html>

Struts config.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN" "http://struts.apache.org/dtds/struts-config_1_2.dtd">

<struts-config>
  <data-sources />
  <form-beans >
    <form-bean name="multiUploadForm" type="com.yourcompany.struts.MultiUploadForm" />

  </form-beans>

  <global-exceptions />
  <global-forwards />
  <action-mappings >
    <action
      attribute="multiUploadForm"
      name="multiUploadForm"
      path="/multiUpload"
      scope="request"
      type="com.yourcompany.struts.MultiUploadAction"
      validate="false" />

  </action-mappings>

  <message-resources parameter="com.yourcompany.struts.ApplicationResources" />
</struts-config>

Form bean:  MultiUploadForm.java


package com.yourcompany.struts;

import java.util.ArrayList;
import java.util.List;

import org.apache.struts.action.ActionForm;

public class MultiUploadForm extends ActionForm {
 private  List  myFiles; 
    public  MultiUploadForm(){ 
            myFiles  =  new  ArrayList(); 
            //为了能够在页面初始显示一个file 
            myFiles.add(new  UploadFile()); 
    } 
    public  List  getMyFiles()  { 
            return  myFiles; 
    }         

//注意这个方法的定义 

  public  UploadFile  getUploadFile(int  index){ 
            int  size  =  myFiles.size(); 
            if(index>size-1){ 
                    myFiles.add(new  UploadFile()); 
            } 
            return  (UploadFile)myFiles.get(index); 
    } 
    public  void  setMyFiles(List  myFiles)  { 
            this.myFiles  =  myFiles; 
    } 

}


ActionBean :MultiUploadAction.java

package com.yourcompany.struts;

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

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

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.upload.FormFile;

public class MultiUploadAction extends Action {
 public ActionForward execute(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response) {
  MultiUploadForm multiUploadForm = (MultiUploadForm) form;
  List myFiles = multiUploadForm.getMyFiles();
  String fileStr = "";
  for (int i = 0; i < myFiles.size(); i++) {
   UploadFile uploadFile = (UploadFile) myFiles.get(i);
   FormFile file = uploadFile.getFile();

   if (file == null) {
    System.out.println("file  is  null");
   } else {

    // 能运行到这里，就可以使用单个文件上传的方法进行上传了。循环而已
    System.out.println("filename:::" + file.getFileName());
    System.out.println("file  size:::" + file.getFileSize());
    fileStr += "filename:::" + file.getFileName() + "file  size:::" + file.getFileSize() ;
     
   }
  }
  //返回文本
  try
  {
   response.setHeader("ContentType", "text/html;charset=gbk");
   PrintWriter out = response.getWriter();
   out.write("<script>parent.callback('upload file success" + fileStr + "')</script>");
  }catch(IOException e)
  {
   e.printStackTrace();
  }

  return null;
 }

}


Bean: UploadFile.java

package com.yourcompany.struts;

import java.io.Serializable;

import org.apache.struts.upload.FormFile;

public class UploadFile implements Serializable {
  private  FormFile  file; 
     public  FormFile  getFile()  { 
             System.out.println("run  in  uploadFile.getFile()"); 
             return  file; 
     } 
     public  void  setFile(FormFile  file)  { 
             this.file  =  file; 
     } 
}

  public ActionForward execute(ActionMapping mapping, ActionForm inForm, HttpServletRequest request, HttpServletResponse response) throws Exception {

    String feedURL = (String)request.getParameter("feedURL");

    if (feedURL == null || feedURL.equalsIgnoreCase("")) {
      return null; // Trivial error handling... if no URL sent in, essentially do nothing
    }
    feedURL = new URLCodec().decode(feedURL);

    // Go get the feed
    StringBuffer xml = new StringBuffer(4096);
    try {
      URL               u   = new URL(feedURL);
      InputStream       in  = u.openStream();
      InputStreamReader isr = new InputStreamReader(in);
      BufferedReader    br  = new BufferedReader(isr);
      String theLine;
      while ((theLine = br.readLine()) != null) {
        xml.append(theLine);
      }
    } catch (Exception e) {
      System.err.println("Example7Action Exception: " + e);
    }

    // Write the XML to response
    response.setContentType("text/xml");
    PrintWriter out = response.getWriter();
    out.println(xml);
    out.flush();

    return null;

  } // End execute()

}

<html:html>
<head>
<title>
multiUploadDemo
</title>
</head>
<script language="javascript" type="">
   var num = 0;
 
 function upload(){
     multiUploadForm.submit();
   }

function additem(id)
{
 var row,cell,str;
 row = eval("document.all["+'"'+id+'"'+"]").insertRow();
 if(row != null )
    {
       cell = row.insertCell();
       str="<input type="+'"'+"file"+'"'+" name=uploadFile["+ num +"].file><input type="+'"'+"button"+'"'+" value="+'"'+"删除"+'"'+" onclick='deleteitem(this,"+'"'+"tb"+'"'+");'>"
      cell.innerHTML=str;
    }
 num++;
}
function deleteitem(obj,id)
{
 var rowNum,curRow;
 curRow = obj.parentNode.parentNode;
 rowNum = eval("document.all."+id).rows.length - 1;
 eval("document.all["+'"'+id+'"'+"]").deleteRow(curRow.rowIndex);
}

</script>
<body bgcolor="#ffffff">
<html:form method="post" action="/multiUploadAction.do" enctype="multipart/form-data">

<table id="tb">
</table>

</html:form>
<input type="button" name="btnAddFile" value="Add File" onclick="additem('tb')"/>
<input type="button" name="btnUpload" value="upload" onclick="upload()"/>
</body>
</html:html> 
 struts-config.xml部分：  
 
   <form-beans>  
       <form-bean  name="multiUploadForm"  type="MultiUploadForm"  />  
   </form-beans>  
 
<action  name="multiUploadForm"  path="/multiUploadAction"  type="MultiUploadAction"  />  
 
以上只是对动态多文件上传部分进行了描述，只是一个Demo。大家可以根据自己的需求变通的调整一下。  

import java.io.File;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.actions.DownloadAction;

public class ExampleFileDownload extends DownloadAction{

    protected StreamInfo getStreamInfo(ActionMapping mapping, 
                                       ActionForm form,
                                       HttpServletRequest request, 
                                       HttpServletResponse response)
            throws Exception {
        
        // Download a "pdf" file - gets the file name from the
        // Action Mapping's parameter
        String contentType = "application/pdf";
        File file          = new File(mapping.getParameter());

        return new FileStreamInfo(contentType, file);
        
    }

}

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.actions.DownloadAction;

public class ExampleResourceDownload extends DownloadAction {

    protected StreamInfo getStreamInfo(ActionMapping mapping, 
                                       ActionForm form,
                                       HttpServletRequest request, 
                                       HttpServletResponse response)
            throws Exception {
        
        // Download a "jpeg" file - gets the file name from the
        // Action Mapping's parameter
        String contentType         = "image/jpeg";
        String path                = mapping.getParameter();
        ServletContext application = servlet.getServletContext();
        
        
        return new ResourceStreamInfo(contentType, application, path);
        
    }

}

import java.io.IOException;
import java.io.InputStream;
import java.io.ByteArrayInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.actions.DownloadAction;

public class ExampleByteArrayDownload extends DownloadAction {

    protected StreamInfo getStreamInfo(ActionMapping mapping, 
                                       ActionForm form,
                                       HttpServletRequest request, 
                                       HttpServletResponse response)
            throws Exception {
        
        // Download a "pdf" file
        String contentType = "application/pdf";
        byte[] myPdfBytes  = null;              // Get the bytes from somewhere

        return new ByteArrayStreamInfo(contentType, myPdfBytes);
        
    }

    protected class ByteArrayStreamInfo implements StreamInfo {
        
        protected String contentType;
        protected byte[] bytes;
        
        public ByteArrayStreamInfo(String contentType, byte[] bytes) {
            this.contentType = contentType;
            this.bytes = bytes;
        }
        
        public String getContentType() {
            return contentType;
        }

        public InputStream getInputStream() throws IOException {
            return new ByteArrayInputStream(bytes);
        }
    }
}

    <action path="/downloadMyPdfFile" type="myPackage.ExampleFileDownload" parameter="/foo/bar.pdf">
    <action path="/downloadMyImage"   type="myPackage.ExampleResourceDownload" parameter="/images/myImage.jpeg">

    <html:img action="downloadMyImage" alt="My Image" height="400" width="400"/>

    <html:link action="downloadMyPdfFile">Click Here to See the PDF</html:link>

    <controller contentType="text/html;charset=UTF-8" locale="true" nocache="false" />

public class ExampleFileDownload extends DownloadAction{


    protected StreamInfo getStreamInfo(ActionMapping mapping, 
                                       ActionForm form,
                                       HttpServletRequest request, 
                                       HttpServletResponse response)
            throws Exception {

        // File Name
        String fileName = mapping.getParameter();

        // Set the content disposition
        response.setHeader("Content-disposition", 
                           "attachment; filename=" + fileName);
        
        // Download a "pdf" file - gets the file name from the
        // Action Mapping's parameter
        String contentType = "application/pdf";
        File file          = new File(fileName);

        return new FileStreamInfo(contentType, file);
        
    }
}

last edited 2006-01-25 18:40:18 by WendySmoak

功能设计： 给用户提供一个上传的界面，并设定上传文件的尺寸上限。用户上传的照片先统一保存在一个临时文件夹中，之后可以用 <img> 指向临时文件夹中的这个图片，让用户可以预览自己上传的照片。当所有的用户信息都收集完成后，将图片和其他信息一并提交，保存到数据库中。保存成功以后，删除临时文件夹中的图片。

实现步骤：

我使用的是从 struts 主页上下载的 struts-1.2.8-src ，其中 web/examples/ 目录下有一个 upload 的例子，稍微修改了一下就直接拿过来用了。这是一个 JSP 页面、 ActionForm 和 Action 的组合。下面分别列出各自的代码。

upload.jsp 的部分源代码：

<html:form action="/UploadSubmit" enctype="multipart/form-data">     

      请选择需要上传的照片 :

     <html:file property="theFile"/>

     <html:submit value=" 上传 "/>     

</html:form>

接下来需要在 ActionForm 中声明这个属性，并设置 getter 和 setter 方法，这部分源代码如下：

public class UploadForm extends ActionForm {

    protected FormFile theFile;

    public FormFile getTheFile() {

        return theFile;

    }

    public void setTheFile(FormFile theFile) {

        this.theFile = theFile;

    }

}

这个表单的 theFile 属性不是 String 或 boolean ，而是 org.apache.struts.upload.FormFile 。因为用户上传的是一个二进制文件，而 HTTP 协议是以文本形式传输数据的，这就需要进行转换。打个比方，一辆汽车需要从甲地送到乙地，但是两地之间只有一条索道，汽车没法开，所以就想个办法在甲地把汽车先拆了，把零件送到乙地再重新组装成一辆汽车。 FormFile 起的就是拆卸和组装的作用，只不过它把拆卸、传输和组装的过程都封装起来了，我们看到的是一辆汽车从甲地开进 FormFile ，过一会它就从乙地开出来了 J 我们要决定的只是把它停到什么地方，这就是 Action 的活了。

按照功能设计， Action 要把这部车停到一个临时文件夹下面，这部分源代码如下：

public ActionForward execute(ActionMapping mapping,

                                 ActionForm form,

                                 HttpServletRequest request,

                                 HttpServletResponse response)

        throws Exception {

        if (form instanceof UploadForm) {

            UploadForm theForm = (UploadForm) form;

             // 获取上传的数据文件

            FormFile file = theForm.getTheFile();

            // 获取文件名

            String filename= file.getFileName();

            // 设置图片文件临时存放的路径

            HttpSession session = request.getSession();

            String path = session.getServletContext().getRealPath("/") + "temp\\" + filename;

            try {

                // 读取文件中的数据，获取二进制的数据流

             InputStream stream = file.getInputStream();

             // 把数据写到指定路径

             OutputStream bos = new FileOutputStream(path);

             int bytesRead = 0;

             byte[] buffer = new byte[8192];

             while ((bytesRead = stream.read(buffer, 0, 8192)) != -1) {

                 bos.write(buffer, 0, bytesRead);

             }

             bos.close();

             logger.info("The file has been written to \""

                       + path + "\"");

                // 设计一个标记，说明用户已经上传过照片了。               

             session.setAttribute("imageuploaded","true");

             session.setAttribute("filename",filename);

             // close the stream

             stream.close();

             bos.flush();

             bos.close();

            }catch (FileNotFoundException fnfe) {

                return null;

            }catch (IOException ioe) {

                return null;

            }

            //destroy the temporary file created

            file.destroy();

            // 转向下一个页面

            return mapping.findForward("next");

        }

        //this shouldn't happen in this example

        return null;

    }

这样图片就被放在 temp 的临时文件夹下，显示的时候，只需要先检查一下标记，看看用户是否上传了照片，如果已经上传，就用一个 <img src=””> 引用这个图片。还有一个小地方需要修改，因为限定上传的是身份照片，需要限定一个尺寸上限，这个在 struts 的 upload 里面有现成的例子。先在 struts-config.xml 中配置这个 ActionForm 和 Action ：

<form-bean name="uploadForm"

 type="org.apache.struts.webapp.upload.UploadForm"/>

……

<action input="/pages/hr/error.jsp" name="uploadForm"

          path="/UploadSubmit" scope="request"

type="org.apache.struts.webapp.upload.UploadAction" validate="true">

   <forward name="next" path="/pages/hr/input.jsp"/>

</action>

……

<controller maxFileSize="2M" inputForward="true" />

在配置文件中已经看到 <action> 的 validate 属性被设置成“ true ”，这就是说表单提交之前先要对其内容进行验证，这里我们要验证的就是 theFile 是否超出了 controller 中设定的最大尺寸 ”2M” 。这个验证是通过 ActionForm 的 validate 方法来实现的：

/**

     * Check to make sure the client hasn't exceeded the maximum allowed upload size inside of this validate method.

**/

    public ActionErrors validate(ActionMapping mapping,

        HttpServletRequest request) {           

        ActionErrors errors = null;

        //has the maximum length been exceeded?

        Boolean maxLengthExceeded =

            (Boolean) request.getAttribute(

                MultipartRequestHandler.ATTRIBUTE_MAX_LENGTH_EXCEEDED);               

        if ((maxLengthExceeded != null) && (maxLengthExceeded.booleanValue())) {

            errors = new ActionErrors();

            errors.add(

                ActionMessages.GLOBAL_MESSAGE ,

                new ActionMessage("maxLengthExceeded"));

            errors.add(

                ActionMessages.GLOBAL_MESSAGE ,

                new ActionMessage("maxLengthExplanation"));

        }

        return errors;

    }

这里我估计有个 hook 之类的东西先截获了表单（应该和 controller 有关），对 theFile 的尺寸进行校验，然后把结果保存在 request scope 中。 Validate 方法只要检查一下这个结果就可以了，如果尺寸超标，表单就不会被提交给 Action 。

以上算是完成了第一步，从用户那里拿到照片，并保存在临时文件夹当中。接下来要做的就是把照片保存到 MySQL 数据库中，这个字段我用的是 MEDIUMBLOB ，因为 BLOB 最大长度是 2¹⁶-1 字节，大约 64K ； MEDIUMBLOB 是 2²⁴-1 字节，约 16M ，足够用了。保存图片的主要代码如下：

/**

 * 将用户的照片保存在数据表中，添加成功后，删除临时文件夹中的图片。

 * @param id 用户的身份号，作为图片的标识码

 * @param path 图片存放的路径。一般存放在一个临时文件夹中。

 * @return

 */

public static void saveImage(int id, String path) throws SQLException{

     String time = new java.util.Date().toString();

     Connection conn = null;

     PreparedStatement pstmt = null;

     boolean flag = false;

     // 获取连接

     try {

         conn = DbManager.getConnection();

         logger.info(time + ":saveImage() 从 DbManager 数据库连接池获取一个连接。 ");

     } catch (SQLException e) {

         // 如果没有能够从 DbManager 获取连接，此次查询操作失败

         logger.error(time + ": saveImage() 不能获取数据库连接，无法保存图片！ ");

         throw new SQLException(":saveImage() 不能获取数据库连接，无法保存图片！ ");

     }

         // 执行查询

     try {

         pstmt = conn.prepareStatement("UPDATE hr01 SET hr01_photo=? where hr01_id=?");

         FileInputStream in = new FileInputStream(path);

         pstmt.setBinaryStream(1,in,in.available());

         pstmt.setInt(2,id);        

         pstmt.executeUpdate();

         pstmt.executeUpdate("COMMIT");

         logger.info(" 图片 " + path + " 被添加到数据库中！ ");

         flag = true;           

     }catch(IOException e){

         logger.error(" 图片 " + path + " 文件读写错误！请检查文件路径是否正确 ");

         throw new SQLException(" 无法保存图片！ ");

     }catch (SQLException ex) {

         logger.error(new java.util.Date() + "Error:Insert into table."

                 + ex.getMessage());        

         logger.error(" 图片 " + path +" 没有被保存到数据库 .");

         throw new SQLException(" 图片 " + path +" 没有被保存到数据库 .");

     } finally {

         try {

             pstmt.close();

             conn.close();

             logger.info("DbHrinfo saveImage() closed the connection created at " + time);

         } catch (SQLException e) {

         }

     }
>    

     // 图片添加成功以后就删除临时文件夹中的图片数据

     if(flag == true){

         File file = new File(path);

         if(file.exists()){

             file.delete();

         }

     }

}

需要注意的是 pstmt.executeUpdate("COMMIT"); 这行代码，最初我并没有写这行，程序能顺利执行，日志中也显示“图片××被添加到数据库中”，但是到库里一查询，什么都没有。 SQL 语句被提交，但是数据库里面没有即时的显示，估计是缓冲区的作用，它把我的 SQL 语句缓存起来而不是立即提交给数据库。后来我在 textpad 里面单独执行这段代码，发现不用“ COMMIT ” SQL 语句就立即被提交了。这个地方还没有弄清楚，以后需要继续研究。

功能上做一点小改进，用户提交了照片以后，浏览了一下觉得不满意，只要还没有最终提交数据，当然允许他重新上传一个照片。我们只需要在 <img src=””> 下面提供一个“重新提交”的链接就可以了。这个链接指向一个 AlterImageAction ，它的功能就是清除 session 中用户已经上传照片的标记，并把刚才保存到临时文件夹中的照片删掉，等待用户重新上传。这部分代码如下：

public ActionForward execute(ActionMapping mapping,

         ActionForm form,HttpServletRequest request,

         HttpServletResponse response)

throws IOException,ServletException{

     HttpSession session = request.getSession();

        //1. 从临时文件夹中删除图片

     String filename = (String)session.getAttribute("filename");

     String path = session.getServletContext().getRealPath("/")

+ "temp\\" + filename;

     File file = new File(path);

     if(file.exists()){

         file.delete();

         logger.info(" 文件 " + path + " 已经被删除 ");

     }

     //2. 从 session 中清除上传图片的标记

     session.removeAttribute("imageuploaded");

     session.removeAttribute("filename");       

     return mapping.findForward("next");    

}

提交和保存到此功德圆满。下次用户想要查询自己的信息的时候，因为临时文件夹中已经没有用户照片，需要从数据库中读取。用一个 ShowImageAction 来实现这个功能：

public ActionForward execute(ActionMapping mapping,

         ActionForm form, HttpServletRequest request,

         HttpServletResponse response)

throws IOException,ServletException{

     // 需要的情况下设置数据源

     if (!DbManager.hasSetDataSource()) {

         javax.sql.DataSource dataSource;

         try {

             dataSource = getDataSource(request);

             DbManager.setDataSource(dataSource);

         } catch (Exception e) {

             logger.error(e.getMessage());

             mapping.findForward("error");

         }

     }

     String photo_no = request.getParameter("photo_no");

     Connection conn = null;

     Statement stmt = null;

     // 获取连接

     try {

         conn = DbManager.getConnection();

         logger.info("showimage.jsp 从 DbManager 数据库连接池获取一个连接。 ");

     } catch (SQLException e) {

         // 如果没有能够从 DbManager 获取连接，此次查询操作失败

        logger.error(" showimage.jsp 不能获取数据库连接，无法读取图片！ ");

     }

     try {

         // 准备语句执行对象

         stmt = conn.createStatement();

         String sql = " SELECT hr01_photo FROM hr01 WHERE hr01_id='" + photo_no + "'";

         ResultSet rs = stmt.executeQuery(sql);

         if (rs.next()) {

             InputStream in = rs.getBinaryStream("hr01_photo");

             int bytesRead = 0;

byte[] buffer = new byte[8192];

             response.setContentType("image/jpeg");

             response.setContentLength(in.available());

             OutputStream outs = response.getOutputStream();

             while ((bytesRead = in.read(buffer, 0, 8192)) != -1) {

                 outs.write(buffer, 0, bytesRead);

             }

             outs.flush();

             in.close();

             rs.close();

         } else {

             rs.close();

             response.sendRedirect("error.jsp");

         }

     }catch(SQLException e){

     }finally {

         try{

         stmt.close();

         conn.close();

         }catch(SQLException ex){

         }

     }

     return null;

}

以前一直不清楚 execute 方法中的 response 参数的用法，因为处理完以后总要 redirect 到另外一个页面，所以用的最多的就是把数据保存在 session 中，在另一个页面里再取出来用。这次纯粹是试验性地在 response 中写入 image/jpeg 内容，然后返回一个 null 值。最后的执行结果跟我预期的一样，在浏览器中直接显示从数据库中读出的图片。那么接下来就很好做了，只需要在 JSP 页面中设置一个 <image> 标签，指向这个 Action 就可以，当然，在这之前需要在 struts-config.xml 中先部署这个 Action ：

<action path="/ShowImage"

 type="software.action.ShowImageAction"></action>

然后在 JSP 页面中引用这个 Action 来显示图像 :

<img src="/tibet/ShowImage.do?photo_no=666542">

3. 属性
(1) name: 指定ActionMessages 对象存放在 request 或 session 范围内的属性 key(即上面实例中的message). 标签处理类将根据这一属性key 来检索request 或 session 范围的 ActionMessages 对象.

(2) message: 指定消息的来源. 如果为true , 则从request 或 session 范围内检索出属性 key为 Globals.MESSAGE_KEY 的 ActionMessages 对象, 此时 name 属性无效; 如果为false ,则根据name 属性来检索ActionMessages 对象, 如果此时没有设置name 属性, 将采用默认值Globals.ERROR_KEY. message 属性的默认值为false.
(3) id: 用来命名从消息集合中检索出的每个 ActionMessage 对象, 它和<bean:write>标签的name 属性匹配. 在上例中, <html:messages> 标签的处理类每次从消息集合中取出一个 ActionMessages 对象, 就把它命名为 "message", <bean:write> 标签接着把这个名为"message" 的ActionMessage 对象的消息输出到网页上.
4. 创建ActionMessages 集合, 存入request 中
    ActionMessages actionMessages = new ActionMessages();
    actionMessages.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage("record.inserted"));
    saveMessages(request, actionMessages);