群组首页 → 企业架构 → struts2 → 知识库 → Struts原理与实践（7）
原创作者: letle   阅读:5483次   评论:5条   更新时间:2011-06-01    

在上一篇文章中介绍校验时提到客户边的校验用到了JavaScript，实际上用Struts配合JavaScript还可以实现许多有用的功能，比如，级联下拉菜单的实现就是一个典型的例子：

本例假设要实现的是一个文章发布系统，我们要发布的文章分为新闻类和技术类，其中新闻类又分为时事新闻和行业动态；技术类又分为操作系统、数据库、和编程语言等，为了便于添加新的条目，所有这些都保存在数据库表中。

为此，我们建立一个名为articleClass的表和一个名为articleSubClass的表。 

articleClass表的结构如下：
articleClassID字段：char类型，长度为2，主键
articleClassName字段：varchar类型，长度为20
articleSubClass表的结构如下：
articleClassID字段：char类型，长度为2
articleSubClassID字段：char类型，长度为2与articleClassID一起构成主键
articleSubClassName字段：varchar类型，长度为20


表建好后,在articleClass表中录入如下数据:如,01、新闻类；02、技术类

在articleSubClass表中录入：01、01、时事新闻；01、02、行业动态；02、01、操作系统等记录。到这里，数据库方面的准备工作就已做好。

有了前面做登录例子的基础，理解下面要进行的工作就没有什么难点了，我们现在的工作也在原来mystruts项目中进行。首先，建立需要用到的formbean即ArticleClassForm，其代码如下： 

  1. package entity;   
  2. import org.apache.struts.action.*;   
  3. import javax.servlet.http.*;   
  4. import java.util.Collection;   
  5.   
  6. public class ArticleClassForm extends ActionForm {   
  7.   //为select的option做准备   
  8.   private Collection beanCollection;   
  9.   private String singleSelect = "";   
  10.   private String[] beanCollectionSelect = { "" };   
  11.   private String articleClassID;   
  12.   private String articleClassName;   
  13.   private String subI;//子类所在行数   
  14.   private String subJ;//子类所在列数   
  15.   private String articleSubClassID;   
  16.   private String articleSubClassName;   
  17.   
  18.   public Collection getBeanCollection(){   
  19.     return beanCollection;   
  20.   }   
  21.   
  22.   public void setBeanCollection(Collection beanCollection){   
  23.     this.beanCollection=beanCollection;   
  24.   }   
  25.   
  26.   public String getSingleSelect() {   
  27.     return (this.singleSelect);   
  28.   }   
  29.   public void setSingleSelect(String singleSelect) {   
  30.     this.singleSelect = singleSelect;   
  31.   }   
  32.   public String[] getBeanCollectionSelect() {   
  33.     return (this.beanCollectionSelect);   
  34.   }   
  35.   public void setBeanCollectionSelect(String beanCollectionSelect[]) {   
  36.     this.beanCollectionSelect = beanCollectionSelect;   
  37.   }   
  38.   
  39.   public String getArticleClassID() {   
  40.     return articleClassID;   
  41.   }   
  42.   public void setArticleClassID(String articleClassID) {   
  43.     this.articleClassID = articleClassID;   
  44.   }   
  45.   public String getArticleClassName() {   
  46.     return articleClassName;   
  47.   }   
  48.   public void setArticleClassName(String articleClassName) {   
  49.     this.articleClassName = articleClassName;   
  50.   }   
  51.   
  52.   public String getSubI() {   
  53.     return subI;   
  54.   }   
  55.   public void setSubI(String subI) {   
  56.     this.subI = subI;   
  57.   }   
  58.   
  59.   public String getSubJ() {   
  60.     return subJ;   
  61.   }   
  62.   public void setSubJ(String subJ) {   
  63.     this.subJ = subJ;   
  64.   }   
  65.   
  66.   public String getArticleSubClassID() {   
  67.     return articleSubClassID;   
  68.   }   
  69.   public void setArticleSubClassID(String articleSubClassID) {   
  70.     this.articleSubClassID = articleSubClassID;   
  71.   }   
  72.   
  73.   public String getArticleSubClassName() {   
  74.     return articleSubClassName;   
  75.   }   
  76.   public void setArticleSubClassName(String articleSubClassName) {   
  77.     this.articleSubClassName = articleSubClassName;   
  78.   }   
  79. }  



将它放在包entity中。其次，我们的系统要访问数据库，因此也要建立相应的数据库访问对象ArticleClassDao,其代码如下：

  1. package db;   
  2.   
  3. import entity.ArticleClassForm;   
  4. import db.*;   
  5. import java.sql.*;   
  6.   
  7. import java.util.Collection;   
  8. import java.util.ArrayList;   
  9. import org.apache.struts.util.LabelValueBean;   
  10. public class ArticleClassDao {   
  11.   private Connection con;   
  12.   
  13.   public ArticleClassDao(Connection con) {   
  14.     this.con=con;   
  15.   }   
  16.   public Collection findInUseForSelect(){   
  17.     PreparedStatement ps=null;   
  18.     ResultSet rs=null;   
  19.     ArrayList list=new ArrayList();   
  20.     String sql="select * from articleClass order by articleClassID";   
  21.     try{   
  22.       if(con.isClosed()){   
  23.         throw new IllegalStateException("error.unexpected");   
  24.       }   
  25.       ps=con.prepareStatement(sql);   
  26.       rs=ps.executeQuery();   
  27.   
  28.       while(rs.next()){   
  29.         String value=rs.getString("articleClassID");   
  30.         String label=rs.getString("articleClassName");   
  31.         list.add(new LabelValueBean(label,value));   
  32.       }   
  33.       return list;   
  34.     }   
  35.     catch(SQLException e){   
  36.       e.printStackTrace();   
  37.       throw new RuntimeException("error.unexpected");   
  38.     }   
  39.     finally{   
  40.       try{   
  41.         if(ps!=null)   
  42.           ps.close();   
  43.         if(rs!=null)   
  44.           rs.close();   
  45.   
  46.       }   
  47.       catch(SQLException e){   
  48.         e.printStackTrace();   
  49.         throw new RuntimeException("error.unexpected");   
  50.       }   
  51.     }   
  52.   }   
  53.   
  54.   public Collection findInUseForSubSelect(){   
  55.     PreparedStatement ps=null;   
  56.     ResultSet rs=null;   
  57.     PreparedStatement psSub=null;   
  58.     ResultSet rsSub=null;   
  59.     int i=0;//大类记数器   
  60.     int j=0;//小类记数器   
  61.     String classID="";   
  62.     String subClassID="";   
  63.     String subClassName="";   
  64.   
  65.     ArrayList list=new ArrayList();   
  66.     ArticleClassForm articleClassForm;   
  67.   
  68.   
  69.     String sql="select * from articleClass order by articleClassID";   
  70.     try{   
  71.       if(con.isClosed()){   
  72.         throw new IllegalStateException("error.unexpected");   
  73.       }   
  74.       ps=con.prepareStatement(sql);   
  75.       rs=ps.executeQuery();   
  76.   
  77.       while(rs.next()){   
  78.         i++;   
  79.         classID=rs.getString("articleClassID");   
  80.         String sqlSub="select * from articleSubClass where articleClassID=?   
  81.         order by articleSubClassID";   
  82.         psSub=con.prepareStatement(sqlSub);   
  83.         psSub.setString(1,classID);   
  84.         rsSub=psSub.executeQuery();   
  85.   
  86.         articleClassForm=new ArticleClassForm();   
  87.         articleClassForm.setSubI(""+i);   
  88.         articleClassForm.setSubJ(""+j);   
  89.         articleClassForm.setArticleSubClassID("请输入一个小类");   
  90.         articleClassForm.setArticleSubClassName("请输入一个小类");   
  91.         list.add(articleClassForm);   
  92.   
  93.         while(rsSub.next()){   
  94.           subClassID=rsSub.getString("articleSubClassID");   
  95.           subClassName=rsSub.getString("articleSubClassName");   
  96.           j++;   
  97.           //optionStr="articleSubClassGroup[" + i + "][" + j + "]=   
  98. new Option('"+ subClassName +"','"+ subClassID+ "')";   
  99.           articleClassForm=new ArticleClassForm();   
  100.           articleClassForm.setSubI(""+i);   
  101.           articleClassForm.setSubJ(""+j);   
  102.           articleClassForm.setArticleSubClassID(subClassID);   
  103.           articleClassForm.setArticleSubClassName(subClassName);   
  104.           list.add(articleClassForm);   
  105.         }   
  106.   
  107.         j=0;   
  108.       }   
  109.       return list;   
  110.     }   
  111.     catch(SQLException e){   
  112.       e.printStackTrace();   
  113.       throw new RuntimeException("error.unexpected");   
  114.     }   
  115.     finally{   
  116.       try{   
  117.         if(ps!=null)   
  118.           ps.close();   
  119.         if(rs!=null)   
  120.           rs.close();   
  121.   
  122.       }   
  123.       catch(SQLException e){   
  124.         e.printStackTrace();   
  125.         throw new RuntimeException("error.unexpected");   
  126.       }   
  127.     }   
  128.   }   
  129. }  



将它保存在db目录中。它们的目的是将文章的类和子类信息从数据库表中读出，以一定的格式保存在集合对象中以供页面显示。

再次,我们要建立相应的jsp文件,文件名为selectArticleClass.jsp,代码如下: 

  1. <%@ page contentType="text/html; charset=UTF-8" %>  
  2. <%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>  
  3. <%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>  
  4. <%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic" %>  
  5. <html>  
  6. <head>  
  7. <title>选择文件类别</title>
  8. </head>  
  9. <body bgcolor="#ffffff">  
  10. <h3>  
  11. 选择文件所属类型   
  12. </h3>  
  13. <html:errors/>  
  14. <table width="500" border="0" cellspacing="0" cellpadding="0">  
  15.   <tr>  
  16.     <td><html:form name="articleClassForm" type="entity.ArticleClassForm"  
  17.     action="selectArticleClassAction.do">  
  18.         <table width="500" border="0" cellspacing="0" cellpadding="0">  
  19.           <tr>  
  20.             <td align="right">文章大类*td>  
  21.             <td>  
  22.               <html:select property="articleClassID" styleClass="word"  
  23.              onchange="articleClassFormredirect(this.options.selectedIndex)">  
  24.                 <html:option value="">请选择一个大类html:option>  
  25.                 <html:optionsCollection name="articleClassForm" 
  26.                        property="beanCollection" styleClass="word"/>  
  27.               html:select>  
  28.             td>  
  29.           tr>  
  30.           <tr>  
  31.             <td align="right">文章小类*td>  
  32.             <td>  
  33.               <select name="articleSubClassID" Class="word" >  
  34.                 <option value="">请选择一个小类option>  
  35.               select>  
  36.               <SCRIPT language=JavaScript>  
  37.               <!--   </sp-->
  38.               var articleSubClassGroups=document.articleClassForm.articleClassID.   
  39.              options.length   
  40.               var articleSubClassGroup=new Array(articleSubClassGroups)   
  41.               for (i=0; i<articleSubClassGroups; i++)   
  42.               articleSubClassGroup[i]=new Array()   
  43.               <logic:iterate name="articleSubClassList" id="articleClassForm"  
  44.               scope="request" type="entity.ArticleClassForm">  
  45.                 articleSubClassGroup[<bean:write name="articleClassForm"  
  46.                 property="subI"/>][<bean:write name="articleClassForm"  
  47.                 property="subJ"/>]=new Option("<bean:write name="articleClassForm"  
  48.             property="articleSubClassName"/>","<bean:write name="articleClassForm"  
  49.             property="articleSubClassID"/>")   
  50.               logic:iterate>  
  51.               var articleSubClassTemp=document.articleClassForm.articleSubClassID   
  52.               function articleClassFormredirect(x){   
  53.                 for (m=articleSubClassTemp.options.length-1;m>0;m--)   
  54.                 articleSubClassTemp.options[m]=null   
  55.                 for (i=0;i<articleSubClassGroup[x].length;i++){   
  56.                   articleSubClassTemp.options[i]=new   
  57.         Option(articleSubClassGroup[x][i].text,   
  58.                    articleSubClassGroup[x][i].value)   
  59.                 }   
  60.                 articleSubClassTemp.options[0].selected=true  
  61.               }   
  62.              //-->  
  63.            SCRIPT>  
  64.             td>  
  65.           tr>  
  66.         table>  
  67.       html:form>  
  68.     td>  
  69.   tr>  
  70. table>  
  71. body>  
  72. html>  



这里值得重点关注的是其中的JavaScript代码,有兴趣的可以仔细分析一下它们是怎样配合集合中的元素来实现级联选择的。

最后，为了例子的完整。我们将涉及到action代码和必要的配置代码在下面列出：其中，action的文件名为SelectArticleClassAction.java,代码如下： 

  1. package action;   
  2. import entity.*;   
  3. import org.apache.struts.action.*;   
  4. import javax.servlet.http.*;   
  5. import javax.sql.DataSource;   
  6. import java.sql.Connection;   
  7. import db.ArticleClassDao;   
  8. import java.util.Collection;   
  9. import java.sql.SQLException;   
  10. public class SelectArticleClassAction extends Action {   
  11.   public ActionForward execute(ActionMapping actionMapping, ActionForm actionForm,   
  12.   HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) {   
  13.     /**@todo: complete the business logic here, this is just a skeleton.*/  
  14.     ArticleClassForm articleClassForm = (ArticleClassForm) actionForm;   
  15.     DataSource dataSource;   
  16.     Connection cnn=null;   
  17.     ActionErrors errors=new ActionErrors();   
  18.     try{   
  19.       dataSource = getDataSource(httpServletRequest,"A");   
  20.       cnn = dataSource.getConnection();   
  21.       ArticleClassDao articleClassDao=new ArticleClassDao(cnn);   
  22.   
  23.       Collection col=articleClassDao.findInUseForSelect();   
  24.       articleClassForm.setBeanCollection(col);   
  25.       httpServletRequest.setAttribute("articleClassList",col);   
  26.   
  27.       //处理子类选项   
  28.       Collection subCol=articleClassDao.findInUseForSubSelect();   
  29.       httpServletRequest.setAttribute("articleSubClassList",subCol);   
  30.       return actionMapping.findForward("success");   
  31.     }   
  32.     catch(Throwable e){   
  33.       e.printStackTrace();   
  34.       //throw new RuntimeException("未能与数据库连接");   
  35.       ActionError error=new ActionError(e.getMessage());   
  36.       errors.add(ActionErrors.GLOBAL_ERROR,error);   
  37.     }   
  38.     finally{   
  39.       try{   
  40.         if(cnn!=null)   
  41.           cnn.close();   
  42.       }   
  43.       catch(SQLException e){   
  44.         throw new RuntimeException(e.getMessage());   
  45.       }   
  46.     }   
  47.     saveErrors(httpServletRequest,errors);   
  48.     return actionMapping.findForward("fail");   
  49.   }   
  50. }  



将其保存在action目录中。

在struts-config.xml文件中做如下配置：

在

  1. <form-beans>  

中加入

  1. <form-bean name="articleClassForm" type="entity.ArticleClassForm" />  



在

  1. <action-mappings>  

中加入： 

  1. <action name="articleClassForm" path="/selectArticleClassAction" scope="session"  
  2.     type="action.SelectArticleClassAction" validate="false">  
  3.    <forward name="success" path="/selectArticleClass.jsp" />  
  4.    <forward name="fail" path="/genericError.jsp" />  
  5. </action> 

为了对应配置中的 

  1. <forward name="fail" path="/genericError.jsp" />  

,我们还要提供一个显示错误信息的jsp页面,代码加入: 

  1. <html:errors />  

现在一切就绪，可以编译执行了。在浏览器中输入：http://127.0.0.1:8080/mystruts/selectArticleClassAction.do就可以看到该例子的运行结果了。(T111)

本文作者：张永美 罗会波 湖北省当阳市国税局 可通过lhbf@sina.com与他们联系
评论 共 5 条 请登录后发表评论
5 楼 492919982 2010-12-30 13:06
快考试了才看这个struts2  不知道晚不晚
谢了。。
4 楼 chengzhi_hong 2009-08-24 20:03
你在见ActionForm的时候为什么将所有的数据都放到一个ActionForm里啊？
你建立了两个数据表，为什么不根据数据表建立ActionForm啊？？？
3 楼 paudal 2009-05-05 17:42
JSP的代码有点问题，可能传的时候掉了一些字符
2 楼 KEYMENLW 2009-03-02 15:52
              
1 楼 passer000 2008-12-26 16:13
很好.谢谢

发表评论

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

文章信息

知识库: struts2
  • 由letle在2007-01-10创建
  • 由letle在2011-06-01更新
Global site tag (gtag.js) - Google Analytics