Struts2+Spring2+Hibernate3 web应用示例【整合】【转载】

Struts作为MVC 2的Web框架，自推出以来不断受到开发者的追捧，得到广泛的应用。作为最成功的Web框架，Struts自然拥有众多的优点：MVC 2模型的使用、功能齐全的标志库（Tag Library）、开放源代码。而Spring的出现，在某些方面极大的方面了Struts的开发。同时，Hibernate作为对象持久化的框架，能显示的提高软件开发的效率与生产力。这三种流行框架的整合应用，可以发挥它们各自的优势，使软件开发更加的快速与便捷。

struts2发布已经很久了，但关于如何使用它的教程及实例并不多。特别是与Spring及Hibernate等流行框架的集成，并不多见。现在就将笔者使用Myeclipse工具应用struts2 + spring2 + hibernate3 实现CRUD操作的步骤一一纪录下来，为初学者少走弯路略尽绵薄之力！在本文中，笔者将Struts2.0.6、Spring2.0.6和Hibernate3.1进行整合，希望通过这样的整合示例，让读者了解这些框架各自的特点，以便于在自己的项目中，根据实际情况，尽快的过渡到Struts2的时代。本文的内容基于Struts2.0.6。

一、 准备工作

spring2与1.x区别不大，可以平滑的过度，笔者也是把spring1.28换成了spring2.0.6，算是升级到spring 2.0了。struts2基本就是webwork2.2，与以前的struts1.x可以说没任何关系了。因为是第一次用struts2，也是第一次用webwork，所以有很多不完善，不规范的地方，还望大家来拍砖。

开发环境：MyEclipse5.0+Eclipse3.2+JDK5.0+Tomcat5.5+struts2+Spring2.0.6+Hibernate3.1。

本示例通过对一个图书进行管理的系统，提供基本的增加、删除、修改、查询等功能。

自己准备lin包

使用的数据库为mysql 5.0，使用的JDBC驱动JAR包为：mysql-connection-java-5.0.4-bin

创建数据表的sql语句为：

create database game

 1 CREATE TABLE `books` (
 2   `book_id` int(11) NOT NULL default '0',
 3   `book_name` varchar(200) character set gb2312 default NULL,
 4   `book_author` varchar(100) character set gb2312 default NULL,
 5   `book_publish` varchar(100) character set gb2312 default NULL,
 6   `book_date` date default NULL,
 7   `book_isbn` varchar(20) default NULL,
 8   `book_page` int(11) default NULL,
 9   `book_price` decimal(10,2) default NULL,
10   `book_content` varchar(100) character set gb2312 default NULL,
11   PRIMARY KEY  (`book_id`)
12 ) ENGINE=InnoDB DEFAULT CHARSET=gbk ROW_FORMAT=COMPRESSED;

二、 建立公共类

1、AbstractAction类

Struts2和Struts1.x的差别，最明显的就是Struts2是一个pull-MVC架构。Struts1.x 必须继承org.apache.struts.action.Action或者其子类，表单数据封装在FormBean中。Struts 2无须继承任何类型或实现任何接口，表单数据包含在Action中，通过Getter和Setter获取。

虽然，在理论上Struts2的Action无须实现任何接口或者是继承任何的类，但是，在实际编程过程中，为了更加方便的实现Action，大多数情况下都会继承com.opensymphony.xwork2.ActionSupport类，并且重载（Override）

1 package com.sterning.commons;
2 
3 import com.opensymphony.xwork2.ActionSupport;
4 
5 public class AbstractAction extends ActionSupport {
6 }

com.sterning.commons.AbstractAction.java

参考JavaDoc，可知ActionSupport类实现了接口：

com.opensymphony.xwork2.Action

com.opensymphony.xwork2.LoaleProvider

com.opensymphony.xwork2.TextProvider

com.opensymphony.xwork2.Validateable

com.opensymphony.xwork2.ValidationAware

com.uwyn.rife.continuations.ContinuableObject

java.io.Searializable

java.lang.Cloneable

2、Pager分页类

为了增加程序的分页功能，特意建立共用的分页类。

 1 package com.sterning.commons;
 2 
 3 import java.math.*;
 4 
 5 public class Pager {
 6     private int totalRows; //总行数
 7     private int pageSize = 5; //每页显示的行数
 8     private int currentPage; //当前页号
 9     private int totalPages; //总页数
10     private int startRow; //当前页在数据库中的起始行
11     
12     public Pager() {
13     }
14     
15     public Pager(int _totalRows) {
16         totalRows = _totalRows;
17         totalPages=totalRows/pageSize;
18         int mod=totalRows%pageSize;
19         if(mod>0){
20             totalPages++;
21         }
22         currentPage = 1;
23         startRow = 0;
24     }
25     
26     public int getStartRow() {
27         return startRow;
28     }
29     public int getTotalPages() {
30         return totalPages;
31     }
32     public int getCurrentPage() {
33         return currentPage;
34     }
35     public int getPageSize() {
36         return pageSize;
37     }
38     public void setTotalRows(int totalRows) {
39         this.totalRows = totalRows;
40     }
41     public void setStartRow(int startRow) {
42         this.startRow = startRow;
43     }
44     public void setTotalPages(int totalPages) {
45         this.totalPages = totalPages;
46     }
47     public void setCurrentPage(int currentPage) {
48         this.currentPage = currentPage;
49     }
50     public void setPageSize(int pageSize) {
51         this.pageSize = pageSize;
52     }
53     public int getTotalRows() {
54         return totalRows;
55     }
56     public void first() {
57         currentPage = 1;
58         startRow = 0;
59     }
60     public void previous() {
61         if (currentPage == 1) {
62             return;
63         }
64         currentPage--;
65         startRow = (currentPage - 1) * pageSize;
66     }
67     public void next() {
68         if (currentPage < totalPages) {
69             currentPage++;
70         }
71         startRow = (currentPage - 1) * pageSize;
72     }
73     public void last() {
74         currentPage = totalPages;
75         startRow = (currentPage - 1) * pageSize;
76     }
77     public void refresh(int _currentPage) {
78         currentPage = _currentPage;
79         if (currentPage > totalPages) {
80             last();
81         }
82     }
83 }

com.sterning.commons.Pager.java

同时，采用PagerService类来发布成为分页类服务PagerService，代码如下：

 1 同时，采用PagerService类来发布成为分页类服务PagerService，代码如下：
 2 package com.sterning.commons;
 3 
 4 public class PagerService {
 5     public Pager getPager(String currentPage,String pagerMethod,int totalRows) {
 6         //    定义pager对象，用于传到页面
 7         Pager pager = new Pager(totalRows);
 8         //    如果当前页号为空，表示为首次查询该页
 9         //    如果不为空，则刷新pager对象，输入当前页号等信息
10         if (currentPage != null) {
11             pager.refresh(Integer.parseInt(currentPage));
12         }
13         //    获取当前执行的方法，首页，前一页，后一页，尾页。
14         if (pagerMethod != null) {
15             if (pagerMethod.equals("first")) {
16                 pager.first();
17             } else if (pagerMethod.equals("previous")) {
18                 pager.previous();
19             } else if (pagerMethod.equals("next")) {
20                 pager.next();
21             } else if (pagerMethod.equals("last")) {
22                 pager.last();
23             }
24         }
25         return pager;
26     }
27 }

com.sterning.commons.PagerService.java

三、 建立数据持久化层

1、编写实体类Books及books.hbm.xml映射文件。

 1 package com.sterning.books.model;
 2 
 3 import java.util.Date;
 4 
 5 public class Books {
 6     //    Fields 
 7     private String bookId;//编号
 8     private String bookName;//书名
 9     private String bookAuthor;//作者
10     private String bookPublish;//出版社
11     private Date bookDate;//出版日期
12     private String bookIsbn;//ISBN
13     private String bookPage;//页数
14     private String bookPrice;//价格
15     private String bookContent;//内容提要
16     
17     //    Constructors
18     public Books(){}
19     
20     //    Property accessors
21 
22     public String getBookId() {
23         return bookId;
24     }
25 
26     public void setBookId(String bookId) {
27         this.bookId = bookId;
28     }
29 
30     public String getBookName() {
31         return bookName;
32     }
33 
34     public void setBookName(String bookName) {
35         this.bookName = bookName;
36     }
37 
38     public String getBookAuthor() {
39         return bookAuthor;
40     }
41 
42     public void setBookAuthor(String bookAuthor) {
43         this.bookAuthor = bookAuthor;
44     }
45 
46     public String getBookContent() {
47         return bookContent;
48     }
49 
50     public void setBookContent(String bookContent) {
51         this.bookContent = bookContent;
52     }
53 
54     public Date getBookDate() {
55         return bookDate;
56     }
57 
58     public void setBookDate(Date bookDate) {
59         this.bookDate = bookDate;
60     }
61 
62     public String getBookIsbn() {
63         return bookIsbn;
64     }
65 
66     public void setBookIsbn(String bookIsbn) {
67         this.bookIsbn = bookIsbn;
68     }
69 
70     public String getBookPage() {
71         return bookPage;
72     }
73 
74     public void setBookPage(String bookPage) {
75         this.bookPage = bookPage;
76     }
77 
78     public String getBookPrice() {
79         return bookPrice;
80     }
81 
82     public void setBookPrice(String bookPrice) {
83         this.bookPrice = bookPrice;
84     }
85 
86     public String getBookPublish() {
87         return bookPublish;
88     }
89 
90     public void setBookPublish(String bookPublish) {
91         this.bookPublish = bookPublish;
92     }
93 }

com.sterning.books.model.Books.java

接下来要把实体类Books的属性映射到books表，编写下面的books.hbm.xml文件：

 1 <?xml version="1.0"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 4 
 5 <hibernate-mapping>
 6      <class name="com.sterning.books.model.Books" table="books" >
 7          <id name="bookId" type="string">
 8             <column name="book_id" length="5" />
 9             <generator class="assigned" />
10         </id>
11         <property name="bookName" type="string">
12             <column name="book_name" length="100" />
13         </property>
14          <property name="bookAuthor" type="string">
15             <column name="book_author" length="100" />
16         </property>
17         <property name="bookPublish" type="string">
18             <column name="book_publish" length="100" />
19         </property>
20          <property name="bookDate" type="java.sql.Timestamp">
21             <column name="book_date" length="7" />
22         </property>
23           <property name="bookIsbn" type="string">
24             <column name="book_isbn" length="20" />
25         </property>
26         <property name="bookPage" type="string">
27             <column name="book_page" length="11" />
28         </property>
29         <property name="bookPrice" type="string">
30             <column name="book_price" length="4" />
31         </property> 
32          <property name="bookContent" type="string">
33             <column name="book_content" length="100" />
34         </property>
35      </class>
36 </hibernate-mapping>

com.sterning.books.model.books.hbm.xml

2、hibernate.cfg.xml配置文件如下：（注意它的位置在scr/hibernate.cfg.xml）

 1 <?xml version="1.0" encoding="ISO-8859-1"?>
 2 <!DOCTYPE hibernate-configuration PUBLIC
 3     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
 4     "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
 5 <hibernate-configuration>
 6 <session-factory>
 7     <property name="show_sql">true</property>
 8 
 9     <mapping resource="com/sterning/books/model/books.hbm.xml"></mapping>
10 </session-factory>
11 </hibernate-configuration>

Com.sterning.bean.hibernate.hibernate.cfg.xml

四、建立DAO层

DAO访问层负责封装底层的数据访问细节，不仅可以使概念清晰，而且可以提高开发效率。

1、建立DAO的接口类：BooksDao

 1 package com.sterning.books.dao.iface;
 2 
 3 import java.util.List;
 4 
 5 import com.sterning.books.model.Books;
 6 
 7 public interface BooksDao {
 8     List getAll();//获得所有记录
 9     List getBooks(int pageSize, int startRow);//获得所有记录
10     int getRows();//获得总行数
11     int getRows(String fieldname,String value);//获得总行数
12     List queryBooks(String fieldname,String value);//根据条件查询
13     List getBooks(String fieldname,String value,int pageSize, int startRow);//根据条件查询
14     Books getBook(String bookId);//根据ID获得记录
15     String getMaxID();//获得最大ID值
16     void addBook(Books book);//添加记录
17     void updateBook(Books book);//修改记录
18     void deleteBook(Books book);//删除记录    
19 }

com.sterning.books.dao.iface.BooksDao.java

2、实现此接口的类文件，BooksMapDao

  1 package com.sterning.books.dao.hibernate;
  2 
  3 import java.sql.SQLException;
  4 import java.util.Iterator;
  5 import java.util.List;
  6 
  7 import org.hibernate.HibernateException;
  8 import org.hibernate.Query;
  9 import org.hibernate.Session;
 10 import org.springframework.orm.hibernate3.HibernateCallback;
 11 import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
 12 
 13 import com.sterning.books.dao.iface.BooksDao;
 14 import com.sterning.books.model.Books;
 15 import com.sterning.commons.PublicUtil;
 16 
 17 
 18 /**
 19  * @author cwf
 20  *
 21  */
 22 public class BooksMapDao extends HibernateDaoSupport implements BooksDao {
 23 
 24     public BooksMapDao(){}
 25 
 26     /**
 27      * 函数说明：添加信息
 28      * 参数说明：对象 
 29      * 返回值：
 30      */
 31     public void addBook(Books book) {
 32         this.getHibernateTemplate().save(book);
 33     }
 34 
 35     /**
 36      * 函数说明：删除信息
 37      * 参数说明： 对象
 38      * 返回值：
 39      */
 40     public void deleteBook(Books book) {
 41         this.getHibernateTemplate().delete(book);
 42     }
 43 
 44     /**
 45      * 函数说明：获得所有的信息
 46      * 参数说明： 
 47      * 返回值：信息的集合
 48      */
 49     public List getAll() {
 50         String sql="FROM Books ORDER BY bookName";
 51         return this.getHibernateTemplate().find(sql);
 52     }
 53     
 54     /**
 55      * 函数说明：获得总行数
 56      * 参数说明： 
 57      * 返回值：总行数
 58      */
 59     public int getRows() {
 60         String sql="FROM Books ORDER BY bookName";
 61         List list=this.getHibernateTemplate().find(sql);
 62         return list.size();
 63     }
 64     
 65     /**
 66      * 函数说明：获得所有的信息
 67      * 参数说明： 
 68      * 返回值：信息的集合
 69      */
 70     public List getBooks(int pageSize, int startRow) throws HibernateException {
 71         final int pageSize1=pageSize;
 72         final int startRow1=startRow;
 73         return this.getHibernateTemplate().executeFind(new HibernateCallback(){
 74 
 75             public List doInHibernate(Session session) throws HibernateException, SQLException {
 76                 // TODO 自动生成方法存根
 77                 Query query=session.createQuery("FROM Books ORDER BY bookName");
 78                 query.setFirstResult(startRow1);
 79                 query.setMaxResults(pageSize1);
 80                 return query.list();
 81             }
 82         });
 83     }
 84 
 85     /**
 86      * 函数说明：获得一条的信息
 87      * 参数说明： ID
 88      * 返回值：对象
 89      */
 90     public Books getBook(String bookId) {
 91         return (Books)this.getHibernateTemplate().get(Books.class,bookId);
 92     }
 93 
 94     /**
 95      * 函数说明：获得最大ID
 96      * 参数说明： 
 97      * 返回值：最大ID
 98      */
 99     public String getMaxID() {
100         String date=PublicUtil.getStrNowDate();
101         String sql="SELECT MAX(bookId)+1 FROM Books  ";
102         String noStr = null;
103         List ll = (List) this.getHibernateTemplate().find(sql);
104         Iterator itr = ll.iterator();
105         if (itr.hasNext()) {
106             Object noint = itr.next();
107             if(noint == null){
108                 noStr = "1";                
109             }else{
110                 noStr = noint.toString();
111             }
112         }
113         
114         if(noStr.length()==1){
115             noStr="000"+noStr;
116         }else if(noStr.length()==2){
117             noStr="00"+noStr;
118         }else if(noStr.length()==3){
119             noStr="0"+noStr;
120         }else{
121             noStr=noStr;
122         }
123         return noStr;
124     }
125 
126     /**
127      * 函数说明：修改信息
128      * 参数说明： 对象
129      * 返回值：
130      */
131     public void updateBook(Books pd) {
132         this.getHibernateTemplate().update(pd);
133     }
134 
135     /**
136      * 函数说明：查询信息
137      * 参数说明： 集合
138      * 返回值：
139      */
140     public List queryBooks(String fieldname,String value) {
141         System.out.println("value: "+value);
142         String sql="FROM Books where "+fieldname+" like '%"+value+"%'"+"ORDER BY bookName";
143         return this.getHibernateTemplate().find(sql);
144     }
145     
146     /**
147      * 函数说明：获得总行数
148      * 参数说明： 
149      * 返回值：总行数
150      */
151     public int getRows(String fieldname,String value) {
152         String sql="";
153         if(fieldname==null||fieldname.equals("")||fieldname==null||fieldname.equals(""))
154             sql="FROM Books ORDER BY bookName";
155         else    
156             sql="FROM Books where "+fieldname+" like '%"+value+"%'"+"ORDER BY bookName";
157         List list=this.getHibernateTemplate().find(sql);
158         return list.size();
159     }
160     
161     /**
162      * 函数说明：查询信息
163      * 参数说明： 集合
164      * 返回值：
165      */
166     public List getBooks(String fieldname,String value,int pageSize, int startRow) {
167         final int pageSize1=pageSize;
168         final int startRow1=startRow;
169         final String queryName=fieldname;
170         final String queryValue=value;
171         String sql="";
172         
173         if(queryName==null||queryName.equals("")||queryValue==null||queryValue.equals(""))
174             sql="FROM Books ORDER BY bookName";
175         else    
176             sql="FROM Books where "+fieldname+" like '%"+value+"%'"+"ORDER BY bookName";
177         
178         final String sql1=sql;
179         return this.getHibernateTemplate().executeFind(new HibernateCallback(){
180 
181             public List doInHibernate(Session session) throws HibernateException, SQLException {
182                 // TODO 自动生成方法存根
183                 Query query=session.createQuery(sql1);
184                 query.setFirstResult(startRow1);
185                 query.setMaxResults(pageSize1);
186                 return query.list();
187             }
188         });
189     }
190 
191 }

com.sterning.books.dao.hibernate.BooksMapDao.java

五、 业务逻辑层

在业务逻辑层需要认真思考每个业务逻辑所能用到的持久层对象和DAO。DAO层之上是业务逻辑层，DAO类可以有很多个，但业务逻辑类应该只有一个，可以在业务逻辑类中调用各个DAO类进行操作。

1、创建服务接口类IBookService

 1 package com.sterning.books.services.iface;
 2 
 3 import java.util.List;
 4 
 5 import com.sterning.books.model.Books;
 6 
 7 public interface IBooksService {
 8     List getAll();//获得所有记录
 9     List getBooks(int pageSize, int startRow);//获得所有记录
10     int getRows();//获得总行数
11     int getRows(String fieldname,String value);//获得总行数
12     List queryBooks(String fieldname,String value);//根据条件查询
13     List getBooks(String fieldname,String value,int pageSize, int startRow);//根据条件查询
14     Books getBook(String bookId);//根据ID获得记录
15     String getMaxID();//获得最大ID值
16     void addBook(Books pd);//添加记录
17     void updateBook(Books pd);//修改记录
18     void deleteBook(String bookId);//删除记录    
19 }

com.sterning.books.services.iface.IBookService.java

2、实现此接口类：BookService：

  1 package com.sterning.books.services;
  2 
  3 import java.util.List;
  4 
  5 import com.sterning.books.dao.iface.BooksDao;
  6 import com.sterning.books.model.Books;
  7 import com.sterning.books.services.iface.IBooksService;
  8 
  9 public class BooksService implements IBooksService{
 10     private BooksDao booksDao;
 11     
 12     public BooksService(){}
 13     
 14     /**
 15      * 函数说明：添加信息
 16      * 参数说明：对象 
 17      * 返回值：
 18      */
 19     public void addBook(Books book) {
 20         booksDao.addBook(book);
 21     }
 22 
 23     /**
 24      * 函数说明：删除信息
 25      * 参数说明： 对象
 26      * 返回值：
 27      */
 28     public void deleteBook(String bookId) {
 29         Books book=booksDao.getBook(bookId);
 30         booksDao.deleteBook(book);
 31     }
 32 
 33     /**
 34      * 函数说明：获得所有的信息
 35      * 参数说明： 
 36      * 返回值：信息的集合
 37      */
 38     public List getAll() {
 39         return booksDao.getAll();
 40     }
 41     
 42     /**
 43      * 函数说明：获得总行数
 44      * 参数说明： 
 45      * 返回值：总行数
 46      */
 47     public int getRows() {
 48         return booksDao.getRows();
 49     }
 50     
 51     /**
 52      * 函数说明：获得所有的信息
 53      * 参数说明： 
 54      * 返回值：信息的集合
 55      */
 56     public List getBooks(int pageSize, int startRow) {
 57         return booksDao.getBooks(pageSize, startRow);
 58     }
 59 
 60     /**
 61      * 函数说明：获得一条的信息
 62      * 参数说明： ID
 63      * 返回值：对象
 64      */
 65     public Books getBook(String bookId) {
 66         return booksDao.getBook(bookId);
 67     }
 68 
 69     /**
 70      * 函数说明：获得最大ID
 71      * 参数说明： 
 72      * 返回值：最大ID
 73      */
 74     public String getMaxID() {
 75         return booksDao.getMaxID();
 76     }
 77 
 78     /**
 79      * 函数说明：修改信息
 80      * 参数说明： 对象
 81      * 返回值：
 82      */
 83     public void updateBook(Books book) {
 84         booksDao.updateBook(book);
 85     }
 86 
 87     /**
 88      * 函数说明：查询信息
 89      * 参数说明： 集合
 90      * 返回值：
 91      */
 92     public List queryBooks(String fieldname,String value) {
 93         return booksDao.queryBooks(fieldname, value);
 94     }
 95     
 96     /**
 97      * 函数说明：获得总行数
 98      * 参数说明： 
 99      * 返回值：总行数
100      */
101     public int getRows(String fieldname,String value) {
102         return booksDao.getRows(fieldname, value);
103     }
104     
105     /**
106      * 函数说明：查询信息
107      * 参数说明： 集合
108      * 返回值：
109      */
110     public List getBooks(String fieldname,String value,int pageSize, int startRow) {
111         return booksDao.getBooks(fieldname, value,pageSize,startRow);
112     }
113 
114     public BooksDao getBooksDao() {
115         return booksDao;
116     }
117 
118     public void setBooksDao(BooksDao booksDao) {
119         this.booksDao = booksDao;
120     }
121 
122 }

com.sterning.books.services.BookService.java

六、创建Action类：BookAction

有Struts 1.x经验的朋友都知道Action是Struts的核心内容，当然Struts 2.0也不例外。不过，Struts 1.x与Struts 2.0的Action模型很大的区别。

	Struts 1.x	Stuts 2.0
接口	必须继承org.apache.struts.action.Action或者其子类	无须继承任何类型或实现任何接口
表单数据	表单数据封装在FormBean中	表单数据包含在Action中，通过Getter和Setter获取

1、建立BookAction类

  1 package com.sterning.books.web.actions;
  2 
  3 import java.util.Collection;
  4 
  5 import com.sterning.books.model.Books;
  6 import com.sterning.books.services.iface.IBooksService;
  7 import com.sterning.commons.AbstractAction;
  8 import com.sterning.commons.Pager;
  9 import com.sterning.commons.PagerService;
 10 
 11 public class BooksAction extends AbstractAction {
 12     
 13     private IBooksService booksService;
 14     private PagerService pagerService;
 15     
 16     private Books book;
 17     private Pager pager;
 18     
 19     protected Collection availableItems;
 20     protected String currentPage;
 21     protected String pagerMethod;
 22     protected String totalRows;
 23     protected String bookId;
 24     protected String queryName;
 25     protected String queryValue;
 26     protected String searchName;
 27     protected String searchValue;
 28     protected String queryMap;
 29     
 30     public String list() throws Exception {
 31         if(queryMap ==null||queryMap.equals("")){
 32             
 33         }else{
 34             String[] str=queryMap.split("~");
 35             this.setQueryName(str[0]);
 36             this.setQueryValue(str[1]);
 37         }
 38         
 39         System.out.println("asd"+this.getQueryValue());
 40         int totalRow=booksService.getRows(this.getQueryName(),this.getQueryValue());
 41         pager=pagerService.getPager(this.getCurrentPage(), this.getPagerMethod(), totalRow);
 42         this.setCurrentPage(String.valueOf(pager.getCurrentPage()));
 43         this.setTotalRows(String.valueOf(totalRow));
 44         availableItems=booksService.getBooks(this.getQueryName(),this.getQueryValue(),pager.getPageSize(), pager.getStartRow());
 45         
 46         this.setQueryName(this.getQueryName());
 47         this.setQueryValue(this.getQueryValue());
 48         
 49         this.setSearchName(this.getQueryName());
 50         this.setSearchValue(this.getQueryValue());
 51         
 52         return SUCCESS;         
 53     }
 54     
 55     public String load() throws Exception {
 56         if(bookId!=null)
 57             book = booksService.getBook(bookId);
 58         else
 59             bookId=booksService.getMaxID();
 60         return SUCCESS;
 61     }
 62     
 63     public String save() throws Exception {
 64         if(this.getBook().getBookPrice().equals("")){
 65             this.getBook().setBookPrice("0.0");
 66         }
 67         
 68         String id=this.getBook().getBookId();
 69         Books book=booksService.getBook(id);
 70         
 71         
 72         
 73         if(book == null)
 74             booksService.addBook(this.getBook());
 75         else
 76             booksService.updateBook(this.getBook());
 77         
 78         this.setQueryName(this.getQueryName());
 79         this.setQueryValue(this.getQueryValue());
 80         
 81         if(this.getQueryName()==null||this.getQueryValue()==null||this.getQueryName().equals("")||this.getQueryValue().equals("")){
 82             
 83         }else{
 84             queryMap=this.getQueryName()+"~"+this.getQueryValue();
 85         }        
 86         
 87         return SUCCESS;
 88     }
 89     
 90     public String delete() throws Exception {
 91         booksService.deleteBook(this.getBookId());
 92         
 93         if(this.getQueryName()==null||this.getQueryValue()==null||this.getQueryName().equals("")||this.getQueryValue().equals("")){
 94             
 95         }else{
 96             queryMap=this.getQueryName()+"~"+this.getQueryValue();
 97         }
 98         return SUCCESS;
 99     }    
100     
101     public Books getBook() {
102         return book;
103     }
104 
105     public void setBook(Books book) {
106         this.book = book;
107     }
108 
109     public IBooksService getBooksService() {
110         return booksService;
111     }
112 
113     public void setBooksService(IBooksService booksService) {
114         this.booksService = booksService;
115     }
116 
117     public Collection getAvailableItems() {
118         return availableItems;
119     }
120 
121     public String getCurrentPage() {
122         return currentPage;
123     }
124 
125     public void setCurrentPage(String currentPage) {
126         this.currentPage = currentPage;
127     }
128 
129     public String getPagerMethod() {
130         return pagerMethod;
131     }
132 
133     public void setPagerMethod(String pagerMethod) {
134         this.pagerMethod = pagerMethod;
135     }
136 
137     public Pager getPager() {
138         return pager;
139     }
140 
141     public void setPager(Pager pager) {
142         this.pager = pager;
143     }
144 
145     public String getTotalRows() {
146         return totalRows;
147     }
148 
149     public void setTotalRows(String totalRows) {
150         this.totalRows = totalRows;
151     }
152         
153     public String getBookId() {
154         return bookId;
155     }
156 
157     public void setBookId(String bookId) {
158         this.bookId = bookId;
159     }
160 
161     public String getQueryName() {
162         return queryName;
163     }
164 
165     public void setQueryName(String queryName) {
166         this.queryName = queryName;
167     }
168 
169     public String getQueryValue() {
170         return queryValue;
171     }
172 
173     public void setQueryValue(String queryValue) {
174         this.queryValue = queryValue;
175     }
176     
177     public String getSearchName() {
178         return searchName;
179     }
180 
181     public void setSearchName(String searchName) {
182         this.searchName = searchName;
183     }
184 
185     public String getSearchValue() {
186         return searchValue;
187     }
188 
189     public void setSearchValue(String searchValue) {
190         this.searchValue = searchValue;
191     }
192     
193     public String getQueryMap() {
194         return queryMap;
195     }
196 
197     public void setQueryMap(String queryMap) {
198         this.queryMap = queryMap;
199     }
200     
201     public PagerService getPagerService() {
202         return pagerService;
203     }
204 
205 
206     public void setPagerService(PagerService pagerService) {
207         this.pagerService = pagerService;
208     }    
209 }

com.sterning.books.web.actions.BookAction.java

（1）、默认情况下，当请求bookAction.action发生时(这个会在后面的Spring配置文件中见到的)，Struts运行时（Runtime）根据struts.xml里的Action映射集(Mapping)，实例化com.sterning.books.web.actions.BookAction类，并调用其execute方法。当然，我们可以通过以下两种方法改变这种默认调用。这个功能（Feature）有点类似Struts 1.x中的LookupDispathAction。

在classes/sturts.xml中新建Action，并指明其调用的方法；

访问Action时，在Action名后加上“!xxx”（xxx为方法名）。

（2）、细心的朋友应该可能会发现com.sterning.books.web.actions.BookAction.java中Action方法（execute）返回都是SUCCESS。这个属性变量我并没有定义，所以大家应该会猜到它在ActionSupport或其父类中定义。没错，SUCCESS在接口com.opensymphony.xwork2.Action中定义，另外同时定义的还有ERROR, INPUT, LOGIN, NONE。

此外，我在配置Action时都没有为result定义名字（name），所以它们默认都为success。值得一提的是Struts 2.0中的result不仅仅是Struts 1.x中forward的别名，它可以实现除forward外的很激动人心的功能，如将Action输出到FreeMaker模板、Velocity模板、JasperReports和使用XSL转换等。这些都过result里的type（类型）属性（Attribute）定义的。另外，您还可以自定义result类型。

（3）、使用Struts 2.0，表单数据的输入将变得非常方便，和普通的POJO一样在Action编写Getter和Setter，然后在JSP的UI标志的name与其对应，在提交表单到Action时，我们就可以取得其值。

（4）、Struts 2.0更厉害的是支持更高级的POJO访问，如this.getBook().getBookPrice()。private Books book所引用的是一个关于书的对象类，它可以做为一个属性而出现在BookActoin.java类中。这样对我们开发多层系统尤其有用。它可以使系统结构更清晰。

（5）、有朋友可能会这样问：“如果我要取得Servlet API中的一些对象，如request、response或session等，应该怎么做？这里的execute不像Struts 1.x的那样在参数中引入。”开发Web应用程序当然免不了跟这些对象打交道。在Strutx 2.0中可以有两种方式获得这些对象：非IoC（控制反转Inversion of Control）方式和IoC方式。

非IoC方式

要获得上述对象，关键是Struts 2.0中com.opensymphony.xwork2.ActionContext类。我们可以通过它的静态方法getContext()获取当前Action的上下文对象。另外，org.apache.struts2.ServletActionContext作为辅助类（Helper Class），可以帮助您快捷地获得这几个对象。

HttpServletRequest request = ServletActionContext.getRequest();

HttpServletResponse response = ServletActionContext.getResponse();

HttpSession session = request.getSession();

如果你只是想访问session的属性（Attribute），你也可以通过ActionContext.getContext().getSession()获取或添加session范围（Scoped）的对象。

IoC方式

要使用IoC方式，我们首先要告诉IoC容器（Container）想取得某个对象的意愿，通过实现相应的接口做到这点。如实现SessionAware, ServletRequestAware, ServletResponseAware接口，从而得到上面的对象。

1、对BookAction类的Save方法进行验证

正如《Writing Secure Code》文中所写的名言All input is evil：“所有的输入都是罪恶的”，所以我们应该对所有的外部输入进行校验。而表单是应用程序最简单的入口，对其传进来的数据，我们必须进行校验。Struts2的校验框架十分简单方便，只在如下两步：

在Xxx-validation.xml文件中的<message>元素中加入key属性；

在相应的jsp文件中的<s:form>标志中加入validate="true"属性，就可以在用Javascript在客户端校验数据。

其验证文件为：BooksAction-save-validation.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE validators PUBLIC "-//OpenSymphony Group//XWork Validator 1.0//EN" "http://www.opensymphony.com/xwork/xwork-validator-1.0.dtd">
 3 <validators>
 4     <!-- Field-Validator Syntax -->
 5     <field name="book.bookName">
 6         <field-validator type="requiredstring">
 7             <message key="book.bookName.required"/>
 8         </field-validator>
 9     </field>
10     <field name="book.bookAuthor">
11         <field-validator type="requiredstring">
12             <message key="book.bookAuthor.required"/>
13         </field-validator>
14     </field>
15     <field name="book.bookPublish">
16         <field-validator type="requiredstring">
17             <message key="book.bookPublish.required"/>
18         </field-validator>
19     </field>
20 </validators>

com.sterning.books.web.actions.BooksAction-save-validation.xml

1、对BookAction类的Save方法进行验证的资源文件

注意配置文件的名字应该是：配置文件（类名-validation.xml）的格式。BooksAction类的验证资源文件为：BooksAction.properties

book=Books
book.bookName.required=\u8bf7\u8f93\u5165\u4e66\u540d
book.bookAuthor.required=\u8bf7\u8f93\u5165\u4f5c\u8005
book.bookPublish.required=\u8bf7\u8f93\u5165\u51fa\u7248\u793e
format.date={0,date,yyyy-MM-dd}

com.sterning.books.web.actions.BooksAction.properties

资源文件的查找顺序是有一定规则的。之所以说Struts 2.0的国际化更灵活是因为它可以根据不同需要配置和获取资源（properties）文件。在Struts 2.0中有下面几种方法：

（1）、使用全局的资源文件。这适用于遍布于整个应用程序的国际化字符串，它们在不同的包（package）中被引用，如一些比较共用的出错提示；

（2）、使用包范围内的资源文件。做法是在包的根目录下新建名的package.properties和package_xx_XX.properties文件。这就适用于在包中不同类访问的资源；

（3）、使用Action范围的资源文件。做法为Action的包下新建文件名（除文件扩展名外）与Action类名同样的资源文件。它只能在该Action中访问。如此一来，我们就可以在不同的Action里使用相同的properties名表示不同的值。例如，在ActonOne中title为“动作一”，而同样用title在ActionTwo表示“动作二”，节省一些命名工夫；

（4）、使用<s:i18n>标志访问特定路径的properties文件。在使用这一方法时，请注意<s:i18n>标志的范围。在<s:i18n name="xxxxx">到</s:i18n>之间，所有的国际化字符串都会在名为xxxxx资源文件查找，如果找不到，Struts 2.0就会输出默认值（国际化字符串的名字）。

例如：某个ChildAction中调用了getText("user.title")，Struts 2.0的将会执行以下的操作：

查找ChildAction_xx_XX.properties文件或ChildAction.properties；

查找ChildAction实现的接口，查找与接口同名的资源文件MyInterface.properties；

查找ChildAction的父类ParentAction的properties文件，文件名为ParentAction.properties；

判断当前ChildAction是否实现接口ModelDriven。如果是，调用getModel()获得对象，查找与其同名的资源文件；

查找当前包下的package.properties文件；

查找当前包的父包，直到最顶层包；

在值栈（Value Stack）中，查找名为user的属性，转到user类型同名的资源文件，查找键为title的资源;

查找在struts.properties配置的默认的资源文件，参考例1;

输出user.title。

七、 Web页面

在这一节中，主要使用到了Struts2的标签库。在这里，会对所用到的主要标签做一个初步的介绍。更多的知识请读者访问Struts的官方网站做更多的学习。在编写Web页面之前，先从总体上，对Struts 1.x与Struts 2.0的标志库（Tag Library）作比较。

	Struts 1.x	Struts 2.0
分类	将标志库按功能分成HTML、Tiles、Logic和Bean等几部分	严格上来说，没有分类，所有标志都在URI为“/struts-tags”命名空间下，不过，我们可以从功能上将其分为两大类：非UI标志和UI标志
表达式语言（expression languages）	不支持嵌入语言（EL）	OGNL、JSTL、Groovy和Velcity

1、主页面：index.jsp，其代码如下：

 1 <%@page pageEncoding="UTF-8" contentType="text/html; charset=UTF-8" %>
 2 <%@ taglib prefix="s" uri="/struts-tags" %>
 3 <html>
 4 <head>
 5 <meta http-equiv="Content-Type" content="text/html; charset=GBK"/>
 6 <title>图书管理系统</title>
 7 </head>
 8 <body>
 9 <p><a href="<s:url action="list" />">进入图书管理系统</a></p>
10 </body>
11 </html>

WebRoot/index.jsp

要在JSP中使用Struts 2.0标志，先要指明标志的引入。通过在JSP的代码的顶部加入以下代码可以做到这点。<%@taglib prefix="s" uri="/struts-tags" %>

1、<s:url>标签：该标签用于创建url,可以通过"param"标签提供request参数。当includeParams的值时'all'或者'get', param标签中定义的参数将有优先权,也就是说其会覆盖其他同名参数的值。

2、列表页面：list.jsp

  1 <%@page pageEncoding="gb2312" contentType="text/html; charset=UTF-8" %>
  2 <%@ taglib prefix="s" uri="/struts-tags" %>
  3 
  4 <html>
  5 <head><title>图书管理系统</title></head>
  6     <style type="text/css">
  7         table {
  8             border: 1px solid black;
  9             border-collapse: collapse;
 10         }
 11         
 12         table thead tr th {
 13             border: 1px solid black;
 14             padding: 3px;
 15             background-color: #cccccc;
 16             background-color: expression(this.rowIndex % 2 == 0 ? "#FFFFFF" : "#EEEEEE");
 17         }
 18         
 19         table tbody tr td {
 20             border: 1px solid black;
 21             padding: 3px;
 22         }
 23         .trs{
 24             background-color: expression(this.rowIndex % 2 == 0 ? "#FFFFFF" : "#EEEEEE");
 25         }
 26     </style>
 27 
 28     <script language="JavaScript">   
 29         function doSearch(){
 30             if(document.all.searchValue.value=="")
 31             {    
 32                 alert("请输入查询关键字!");
 33             }else{
 34                 window.location.href="bookAdmin/list.action?queryName="+document.all.searchName.value+"&&queryValue="+document.all.searchValue.value;
 35              }
 36         }
 37     </script>
 38 <body>
 39 
 40 <table align="center">
 41 <tr align="center">
 42     <td>
 43         <select name="searchName">
 44             <option value="bookName">书名</option>
 45             <option value="bookAuthor">作者</option>
 46             <option value="bookPublish">出版社</option>
 47             <option value="bookDate">出版日期</option>
 48             <option value="bookIsbn">ISNB</option>
 49             <option value="bookPage">页数</option>
 50         </select>
 51         <input type="text" name="searchValue" value="" size="10"/>
 52         <input type="button" value="查询" onClick="doSearch();">
 53     </td>
 54 </tr>
 55 <tr align="center">    
 56     <td>
 57         <a href="<s:url action="list" includeParams="none"/>">全部</a>
 58         <a href='<s:url action="edit" ></s:url>'>增加</a>
 59     </td>
 60 </tr>
 61 <tr>
 62 <td>
 63 <table cellspacing="0" align="center">
 64     <thead>
 65     <tr>
 66         <th>书名</th>
 67         <th>作者</th>
 68         <th>出版社</th>
 69         <th>出版日期</th>
 70         <th>ISNB</th>
 71         <th>页数</th>
 72         <th>价格</th>
 73         <th>内容提要</th>
 74         <th>删除</th>
 75     </tr>
 76     </thead>
 77     <tbody>
 78     <s:iterator value="availableItems">
 79         <tr class="trs">
 80             <td>
 81             <a href='<s:url action="edit" ><s:param name="bookId" value="bookId" /></s:url>'>
 82             <s:property value="bookName"/>
 83             </a>
 84             </td>
 85             <td><s:property value="bookAuthor"/></td>
 86             <td><s:property value="bookPublish"/></td>
 87             <td><s:text name="format.date"><s:param value="bookDate"/></s:text></td>     
 88             <td><s:property value="bookIsbn" /></td>
 89             <td><s:property value="bookPage" /></td>
 90             <td><s:property value="bookPrice"/></td>
 91             <td><s:property value="bookContent"/></td>
 92             
 93             <td><a href='<s:url action="delete"><s:param name="bookId" value="bookId" /></s:url>'>删除</a></td>
 94         </tr>
 95     </s:iterator>
 96     <tr align="right">
 97         <td colspan="9">
 98             共<s:property value="totalRows"/>行&nbsp;
 99             第<s:property value="currentPage"/>页&nbsp;
100             共<s:property value="pager.getTotalPages()"/>页&nbsp;
101             <a href="<s:url value="list.action">
102                 <s:param name="currentPage" value="currentPage"/>
103                 <s:param name="pagerMethod" value="'first'"/>
104                 
105             </s:url>">首页</a>
106             <a href="<s:url value="list.action">
107                 <s:param name="currentPage" value="currentPage"/>
108                 <s:param name="pagerMethod" value="'previous'"/>
109             </s:url>">上一页</a>
110             <a href="<s:url value="list.action">
111                 <s:param name="currentPage" value="currentPage"/>
112                 <s:param name="pagerMethod" value="'next'"/>
113             </s:url>">下一页</a>
114             <a href="<s:url value="list.action">
115                 <s:param name="currentPage" value="currentPage"/>
116                 <s:param name="pagerMethod" value="'last'"/>
117             </s:url>">尾页</a>
118         </td>
119     </tr>    
120     </tbody>
121 </table>
122 </td>
123 </tr>
124 </table>
125 </body>
126 </html>

/WebRoot/list.jsp

(1)、<s:property> :得到'value'的属性,如果value没提供,默认为堆栈顶端的元素。其相关的参数及使用如下表所示：

名称	必需	默认	类型	描述
default	否		String	如果属性是null则显示的default值
escape	否	true	Booelean	是否escape HTML
value	否	栈顶	Object	要显示的值
id	否		Object/String	用来标识元素的id。在UI和表单中为HTML的id属性

(2)、<s:Iterator>：用于遍历集合（java.util.Collection）或枚举值（java.util.Iterator）。其相关的参数及使用如下表所示：

名称	必需	默认	类型	描述
status	否		String	如果设置此参数，一个IteratorStatus的实例将会压入每个遍历的堆栈
value	否		Object/String	要遍历的可枚举的（iteratable）数据源，或者将放入新列表（List）的对象
id	否		Object/String	用来标识元素的id。在UI和表单中为HTML的id属性

(3)、<s:param>:为其他标签提供参数,比如include标签和bean标签. 参数的name属性是可选的,如果提供，会调用Component的方法addParameter(String, Object), 如果不提供，则外层嵌套标签必须实现UnnamedParametric接口(如TextTag)。 value的提供有两种方式,通过value属性或者标签中间的text,不同之处我们看一下例子:

<param name="color" value="blue"/>
(A)参数值会以String的格式放入statck.
(B)该值会以java.lang.Object的格式放入statck.

其相关的参数及使用如下表所示：

名称	必需	默认	类型	描述
name	否		String	参数名
value	否		String	value表达式
id	否		Object/String	用来标识元素的id。在UI和表单中为HTML的id属性

（4）、国际化是商业系统中不可或缺的一部分，所以无论您学习的是什么Web框架，它都是必须掌握的技能。其实，Struts 1.x在此部分已经做得相当不错了。它极大地简化了我们程序员在做国际化时所需的工作，例如，如果您要输出一条国际化的信息，只需在代码包中加入FILE-NAME_xx_XX.properties（其中FILE-NAME为默认资源文件的文件名），然后在struts-config.xml中指明其路径，再在页面用<bean:message>标志输出即可。

不过，所谓“没有最好，只有更好”。Struts 2.0并没有在这部分止步，而是在原有的简单易用的基础上，将其做得更灵活、更强大。

（5）、list.jsp文件中：

<s:text name="format.date"><s:param value="bookDate"/></s:text>，为了正确的输出出版日期的格式，采用在资源文件中定义输出的格式，并在页面上调用。format.date就是在资源文件com.sterning.books.web.actions.BooksAction.properties中定义。当然也可以别的文件，放在别的路径下，但此时需要在web.xml中注册才可以使用它。

正如读者所见，在pojo（本例为Books.java）中将日期字段设置为java.util.Date，在映射文件中（books.hbm.xml）设置为timestamp（包括日期和时间）。为了便于管理，将日期格式保存在国际化资源文件中。如：globalMessages或globalMessages_zh_CN文件。

其内容为：

format.date={0,date,yyyy-MM-dd}

在页面显示日期时间时：<s:text name="format.date"><s:param value="bookDate"/></s:text>。这样就解决了日期（时间）的显示格式化问题。

3、增加/修改页面：editBook.jsp

 1 <%@page pageEncoding="UTF-8" contentType="text/html; charset=UTF-8" %>
 2 <%@ taglib prefix="s" uri="/struts-tags" %>
 3 
 4 <html>
 5 <head>
 6     <title>编辑图书</title>
 7     <s:head/>
 8 </head>
 9 <body>
10     <h2>
11         <s:if test="null == book">
12             增加图书
13         </s:if>
14         <s:else>
15             编辑图书
16         </s:else>
17     </h2>
18     <s:form name="editForm" action="save" validate="true">
19     
20          <s:textfield label="书名" name="book.bookName"/>
21          <s:textfield label="作者" name="book.bookAuthor"/>
22          <s:textfield label="出版社" name="book.bookPublish"/>
23          <s:datetimepicker label="出版日期" name="book.bookDate"></s:datetimepicker>
24          <s:textfield label="ISBN" name="book.bookIsbn"/>
25          <s:textfield label="页数" name="book.bookPage"/>
26          <s:textfield label="价格(元)" name="book.bookPrice"/>
27          <s:textfield label="内容摘要" name="book.bookContent"/>
28          <s:if test="null == book">
29              <s:hidden name="book.bookId" value="%{bookId}"/>
30          </s:if>         
31          <s:else>
32              <s:hidden name="book.bookId" />
33          </s:else>
34          <s:hidden name="queryName" />
35          <s:hidden name="queryValue" />
36          <s:submit value="%{getText('保存')}" />
37     </s:form>
38 
39 <p><a href="<s:url action="list"/>">返回</a></p>
40 </body>
41 </html>

WebRoot/editBook.jsp

（1）、<s:if>、<s:elseif>和<s:else> ：执行基本的条件流转。其相关的参数及使用如下表所示：

名称	必需	默认	类型	描述	备注
test	是		Boolean	决定标志里内容是否显示的表达式	else标志没有这个参数
id	否		Object/String	用来标识元素的id。在UI和表单中为HTML的id属性

（2）、<s:text>：支持国际化信息的标签。国际化信息必须放在一个和当前action同名的resource bundle中,如果没有找到相应message,tag body将被当作默认message,如果没有tag body,message的name会被作为默认message。其相关的参数及使用如下表所示：

名称	必需	默认	类型	描述
name	是		String	资源属性的名字
id	否		Object/String	用来标识元素的id。在UI和表单中为HTML的id属性

八、配置Struts2

Struts的配置文件都会在web.xml中注册的。

a) Struts的配置文件如下：

 1 <?xml version="1.0" encoding="UTF-8" ?>
 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 
 6 <struts>
 7 
 8     <constant name="struts.enable.DynamicMethodInvocation" value="false" />
 9     <constant name="struts.devMode" value="true" />
10     <constant name="struts.i18n.encoding" value="GBK" />   
11 
12     <!-- Add packages here -->
13 
14 </struts>

Src/struts.xml

b) struts_book.xml配置文件如下：

 1 <?xml version="1.0" encoding="UTF-8" ?>
 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 
 6 <struts>
 7 
 8     <package name="products" extends="struts-default">
 9         <!--default-interceptor-ref name="validation"/-->
10          <!-- Add actions here -->
11         <action name="list" class="bookAction" method="list">            
12             <result>/list.jsp</result>
13         </action>
14 
15     <action name="delete" class="bookAction" method="delete">            
16             <result type="redirect">list.action?queryMap=${queryMap}</result>
17         </action>
18 
19         <action name="*" class="com.sterning.commons.AbstractAction">
20             <result>/{1}.jsp</result>
21         </action>
22         
23     <action name="edit" class="bookAction" method="load">
24             <result>/editBook.jsp</result>
25         </action>
26        
27        <action name="save" class="bookAction" method="save">
28            <interceptor-ref name="params"/>
29            <interceptor-ref name="validation"/>
30             <result name="input">/editBook.jsp</result>
31             <result type="redirect">list.action?queryMap=${queryMap}</result>
32               
33         </action>
34     </package>
35 </struts>

文件中的<interceptor-ref name="params"/>，使用了struts2自己的拦截器，拦截器在AOP（Aspect-Oriented Programming）中用于在某个方法或字段被访问之前，进行拦截然后在之前或之后加入某些操作。拦截是AOP的一种实现策略。

Struts 2已经提供了丰富多样的，功能齐全的拦截器实现。大家可以到struts2-all-2.0.6.jar或struts2-core-2.0.6.jar包的struts-default.xml查看关于默认的拦截器与拦截器链的配置。

在struts-default.xml中已经配置了大量的拦截器。如果您想要使用这些已有的拦截器，只需要在应用程序struts.xml文件中通过“<include file="struts-default.xml" />”将struts-default.xml文件包含进来，并继承其中的struts-default包（package），最后在定义Action时，使用“<interceptor-ref name="xx" />”引用拦截器或拦截器栈（interceptor stack）。一旦您继承了struts-default包（package），所有Action都会调用拦截器栈 ——defaultStack。当然，在Action配置中加入“<interceptor-ref name="xx" />”可以覆盖defaultStack。

作为“框架（framework）”，可扩展性是不可或缺的，因为世上没有放之四海而皆准的东西。虽然，Struts 2为我们提供如此丰富的拦截器实现，但是这并不意味我们失去创建自定义拦截器的能力，恰恰相反，在Struts 2自定义拦截器是相当容易的一件事。所有的Struts 2的拦截器都直接或间接实现接口com.opensymphony.xwork2.interceptor.Interceptor。除此之外，大家可能更喜欢继承类com.opensymphony.xwork2.interceptor.AbstractInterceptor。

九、配置Spring

1、Spring的配置文件如下：

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
 3  
 4 <beans>
 5     <!-- dataSource config -->
 6     <bean id ="dataSource" class ="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"> 
 7         <property name="driverClassName" value="com.mysql.jdbc.Driver" /> 
 8         <property name="url" value="jdbc:mysql://localhost:3306/game" /> 
 9         <property name="username" value="root" /> 
10         <property name="password" value="root"/> 
11     </bean> 
12     
13     <!-- SessionFactory -->
14     <bean id="sessionFactory"
15         class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
16 
17         <property name="dataSource">
18             <ref bean="dataSource"/>
19         </property>
20         <property name="configLocation">
21             <value>classpath:com\sterning\bean\hibernate\hibernate.cfg.xml</value>
22         </property>        
23     </bean>
24     
25     <!-- TransactionManager  不过这里暂时没注入-->
26     <bean id="transactionManager"
27         class="org.springframework.orm.hibernate3.HibernateTransactionManager">
28         <property name="sessionFactory">
29             <ref local="sessionFactory"/>
30         </property>
31     </bean>
32     
33     <!-- DAO -->
34     <bean id="booksDao" class="com.sterning.books.dao.hibernate.BooksMapDao">
35         <property name="sessionFactory">
36             <ref bean="sessionFactory"/>
37         </property>
38     </bean>
39     
40     <!-- Services -->
41     <bean id="booksService" class="com.sterning.books.services.BooksService">
42         <property name="booksDao">
43             <ref bean="booksDao"/>
44         </property>
45     </bean>
46     
47     <bean id="pagerService" class="com.sterning.commons.PagerService"/>
48     
49     <!-- view -->
50     <bean id="bookAction" class="com.sterning.books.web.actions.BooksAction" singleton="false">
51         <property name="booksService">
52             <ref bean="booksService"/>
53         </property>
54         <property name="pagerService">
55             <ref bean="pagerService"/>
56         </property>
57     </bean>  
58     
59 </beans>

WebRoot/WEB-INF/srping-content/applicationContent.xml

2、Struts.properties.xml

本来此文件应该写在struts 配置一节，但主要是考虑这体现了集成spring的配置，所以放在spring的配置这里来讲。

struts.objectFactory = spring  
struts.locale=zh_CN
struts.i18n.encoding = GBK

struts.objectFactory：ObjectFactory 实现了 com.opensymphony.xwork2.ObjectFactory接口（spring）。struts.objectFactory=spring，主要是告知Struts 2运行时使用Spring来创建对象（如Action等）。当然，Spring的ContextLoaderListener监听器，会在web.xml文件中编写，负责Spring与Web容器交互。

struts.locale：The default locale for the Struts application。默认的国际化地区信息。

struts.i18n.encoding：国际化信息内码。

十、 Web.xml配置

 1 <?xml version="1.0" encoding="GB2312"?>
 2 <!DOCTYPE web-app
 3     PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 4     "http://java.sun.com/dtd/web-app_2_3.dtd">
 5 
 6 <web-app>
 7     <display-name>图书管理系统</display-name>
 8     <context-param>
 9         <param-name>log4jConfigLocation</param-name>
10         <param-value>/WEB-INF/classes/log4j.properties</param-value>
11     </context-param>
12     <!-- ContextConfigLocation -->
13     <context-param>
14         <param-name>contextConfigLocation</param-name>
15         <param-value>/WEB-INF/spring-context/applicationContext.xml</param-value>
16       </context-param>
17     
18     <filter>
19         <filter-name>encodingFilter</filter-name>
20         <filter-class>com.sterning.commons.SetCharacterEncodingFilter</filter-class>
21         <init-param>
22             <param-name>encoding</param-name>
23             <param-value>UTF-8</param-value>
24         </init-param>
25         <init-param>
26             <param-name>forceEncoding</param-name>
27             <param-value>true</param-value>
28         </init-param>
29     </filter>
30      <filter>
31         <filter-name>struts2</filter-name>
32         <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
33         <init-param>
34             <param-name>config</param-name>
35             <param-value>struts-default.xml,struts-plugin.xml,struts.xml,struts_books.xml</param-value>
36         </init-param>
37     </filter>    
38 
39     <filter-mapping>
40         <filter-name>encodingFilter</filter-name>
41         <url-pattern>/*</url-pattern>
42     </filter-mapping>
43     <filter-mapping>
44         <filter-name>struts2</filter-name>
45         <url-pattern>/*</url-pattern>
46     </filter-mapping>        
47     
48     <!-- Listener contextConfigLocation -->
49       <listener>
50         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
51       </listener>
52     <!-- Listener log4jConfigLocation -->
53       <listener>
54         <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
55       </listener>
56  
57     <!-- The Welcome File List -->
58     <welcome-file-list>
59         <welcome-file>index.jsp</welcome-file>
60     </welcome-file-list>
61 </web-app>

在Struts 2中，配置有少许改变，最明显的是分发器（dispatcher）已由Servlet转为Servlet Filter, 其配置和Servlet一样简单。和Servlet配置一样，Filter配置中定义了Filter的名称（作为引用）和类名。Filter Mapping通过URI和名称匹配来调用相应的Filter。默认情况下，扩展名为“.action”，这是在default.properties文件（在Struts 2 JAR文件里）的“struts.action.extension”属性定义的。

十一、 运行结果

1、主页面

2、图书列表页面

3、增加页面

4、修改页面

十二、 总结

从上面的struts2.0.6+spring2.0.6+hibernate3.1的示例代码可以看出，从struts1过渡到Struts2的时候，发现非常方便，标签变得更加的简洁，从而使代码量简缩了，同时整个体系沿用了webwork的精华和struts1的精髓，Struts2的Action不再依耐于Servlet容器，从而可以进行单独的测试。另外对于表达式语言方面，不仅支持原有的JSTL，还支持OGNL（全称是Object Graph Notation Language）。在校验方面，没有再直接使用Common-validator，用的是xwork框架校验。其实说这些，主要把webwork2的特性简单描述一下而已，话说回来，发现struts2跟ajax的某些框架结合得不好，比如流行的dwr，连最简单的页面theme都用不了ajax，这个问题主要出在模版上面，具体位置在Struts2-core-2.0.6.jar包的template/ajax里面的form-close.ftl等几个文件的代码有bug，比如dojo.widget.html.Tooltip问题，是没有这个属性的，应为dojo.widget.Tooltip，这个已经在官方的bug跟踪系统提出了，官方说会在2.1版本时解决（其实在Struts2.0.8中已经有解决的痕迹了）。当然，还有其他一系列的bug，不过大体沿用了webwork2的东西，拿官方说： struts2 = webwork2 + struts 。

posted @ 2012-08-15 18:04 ChazZ 阅读(296) 评论(2) 收藏举报

刷新页面返回顶部

ChazZ

Struts2+Spring2+Hibernate3 web应用示例【整合】【转载】

公告