Struts+Spring+Hibernate開發實例

 
本文並不想介紹Struts,Spring,Hibernate的原理系統架構等,本文地目的是通過一個較複雜地實例介紹如何整合Struts,Spring,Hibernate,網上現有的例子雖然也能達到目的,但功能都比較單一,複雜的例子時會有意想不到的麻煩。本文對讀者假設已經具備了以上框架的基礎知識。以及那些已經瞭解Struts,Spring,Hibernate的基本概念,但是還沒有親身在較複雜的項目中體驗Struts+Spring+Hibernate的開發人員。
1 Struts
   雖然不打算過多介紹Struts的原理,但是大概介紹一下還是有必要的。Struts本身就是 MVC 在這裏負責將用戶數據傳人業務層,以及 將業務層處理的結果返回給用戶,此係統屬於較簡單WEB應用,採用了OpenSessionInView模式處理LazyLoad問題,這樣我們可以在用戶視圖中使用 get,set方法來方便地獲取關聯對象。爲了處理龐大的Action和ActionForm問題,在此我門準備使用DynaActionForm (DynaValidatorForm)和DispatchAction以及 動態驗證框架 來解決。及使用Tile來解決框架問題 。使用自定義標籤處理分頁和身份驗證問題。
2 Spring
   Spring Framework最得以出名的是與Hibernate的無縫鏈接,雖然Spring 對Hibernate提供了90%以上的封裝,使我們不必去關心Session 的建立,關閉,以及事務使我們能夠專心的關注業務邏輯。但是一些特殊情況如 有時需要Query以及Criteria 對象,分頁等,Spring不能給我們提供支持,總不能每次都在你的DAO上寫個HibernateCallBackup()吧?Spring的作用不是把Hibernate再封裝一層,而是讓你接觸不到HibernateAPI,而是幫助你管理好SessionTransaction
在這裏解決方法是:首先寫一個IBase 的接口,和一個BaseDao的實現。在實現中仿照HibernateTemplate,將其功能一一實現,同時考慮到Spring 未能支持的地方,我們不得已只好自己來管理Session,因此加入public Session openSession(),public Query getQuery(String sql),public Criteria getCriteria(Class clazz),以及分頁的方法。 然後爲每一個Entity 都建立繼承於以上類的IEntity,與EntityDao。這裏可以根據需求對Entity加入特殊的方法實現,如 在 StudentsDao.java 中加入類似用戶身份驗證等。以上就是數據訪問層。接下來在Service層中通過對dao的引用完成業務邏輯方法。在下面的例子中我們分別爲學生模塊,教師模塊,管理員模塊構建Service層,StudentsServiceImpl,TeachersServiceImpl,AdminServiceImpl。
 
3 Hibernate
 有了Spring的封裝,我們要對Hibernate做的就是正確實現對象關係的映射。由於此處處於系統的最底層,準確無誤的實現對象之間的關聯關係映射將起着至關重要的作用。
 總之,理解了Struts,Spring,Hibernate地原理以及之間的關係之後,剩下的工作就如同在以Spring爲核心的Struts爲表現的框架中堆積木。
下圖可以更好的幫助我們理解StrutsSpringHibernate之間的關係。
pic1.JPG

案例簡述
設計思路主要源於 大學選修課,該系統可以方便處理學生在課程選報,學分查詢,成績查詢,以及 成績發佈等。
系統以班級爲核心,一門課程可以對應多個班級,一名教師也可以帶不同的班級,學生可以選報不同課程所對應的班級,班級自身有目前人數,和最大人數,以及上課時間,上課地點的屬性。
學生在選報班級之後,班級的人數會自動加一,直到等於最大人數時,其他學生將會有人數已滿的錯誤提示。同理如果學生選擇了同一課程的不同班級,也將收到錯誤提示。學生有密碼,系別,學分,地址,電話等屬性。
教師在系統中主要負責成績發佈,教師可以對其所帶的班級的學生的成績修改,系統會以成績是否大於等於60來判斷學生是否通過考試,如果通過會將該課程的學分累加到學生學分,同樣如果教師二次修改了成績,而且小於60,系統會在學生學分上扣掉該課程的分數。
課程在系統中具體體現爲班級,自身帶有學分屬性。
繫有編號,名稱的屬性,同時可以作爲聯繫教師,課程,學生的橋樑。
 
功能模塊
l       身份驗證模塊: 根據用戶名,密碼,用戶類別 轉發用戶到不同的模塊。
l       學生模塊: 查看課程,查看班級,選報課程,查看己選課程,成績查詢。
l       教師模塊: 錄入成績
l       管理員模塊:對學生,教師,課程,班級,系 增,刪,查,改。
 
具體實踐
代碼下載
http://www.blogjava.net/Files/limq/StudentManger.rar
1  
對象關係映射:
首先,將庫表映射爲數據模型(SQL在源碼中查看),轉換後的數據模型如下圖:
pic2.jpg
由此我們可以看出一下關聯關係:
1 Students 和 Contact(聯繫方式)一對一關係。
2 Students 和 History(選課歷史) 一對多關係
3 Students 和 Classes 多對多關係。
4 Classes 和 Classes_info 一對多關係。
5 Classes 和 Teachers 多對一關係。
6 Classes 和 Courses 多對一關係。
7 Course 和 Department(系) 多對一關係。
8 Teachers 和 Department 多對一關係。
9 Students 和 Department 多對一關係。
 
在Hibernate中將以上關係一一映射,如Students 和 History 一對多關係
Students.cfg.xm.:
 1 <set name="history"
 2                  table="history" 
 3                  cascade="all"
 4                  inverse="true"
 5                  lazy="true"  >
 6                 <key  column="student_id"/> 
 7             <one-to-many class="limq.hibernate.vo.History"
 8                                     />
 9             set>
10 
用過MyEclipse開發Hibernate的就知道,MyEclipse會幫助我們生成持久對象和抽象對象,我們要在 Students.java 中加入對History的引用
private Set history=new HashSet();
 
     public Set getHistory() {
        return history;
      }
 
    public void setHistory(Set history) {
        this.history = history;
}
同時,在AbstractHistory.java 中刪除student_id 以及對應的get,set 方法,History.java 中加入
private Students student;
public Students getStudent() {
        return student;
    }
  
 public void setStudent(Students student) {
        this.student = student;
    }
具體內容請查看 源代碼。

1 public interface IDepartment extends IBaseDao {}
2 
3 public class DepartmentDao extends BaseDao implements IBaseDao {}
4 
 
3 Service
 在這裏需要認真思考每個業務邏輯所能用到的持久層對象和DAO,還要完成配置Spring框架, 首先我一起看看applications-service.xml
 
  1 xml version="1.0" encoding="UTF-8"?>
  2 DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" 
  3     "http://www.springframework.org/dtd/spring-beans.dtd">
  4 <beans>
  5   <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
  6     <property name="driverClassName">
  7       <value>com.mysql.jdbc.Drivervalue>
  8     property>
  9     <property name="url">
 10       <value>jdbc:mysql://localhost:3306/Studentvalue>
 11     property>
 12     <property name="username">
 13       <value>rootvalue>
 14     property>
 15     <property name="password">
 16       <value>value>
 17     property>
 18   bean>
 19   <bean id="sessionFactory" class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
 20     <property name="dataSource">
 21       <ref local="dataSource"/>
 22     property>
 23     <property name="mappingResources">
 24       <list>
 25         <value>limq/hibernate/vo/Admins.hbm.xmlvalue>
 26         <value>limq/hibernate/vo/Classes.hbm.xmlvalue>
 27         <value>limq/hibernate/vo/Courses.hbm.xmlvalue>
 28         <value>limq/hibernate/vo/Students.hbm.xmlvalue>
 29         <value>limq/hibernate/vo/ClassesInfo.hbm.xmlvalue>
 30         <value>limq/hibernate/vo/Contact.hbm.xmlvalue>
 31         <value>limq/hibernate/vo/Department.hbm.xmlvalue>
 32         <value>limq/hibernate/vo/History.hbm.xmlvalue>
 33         <value>limq/hibernate/vo/Teachers.hbm.xmlvalue>
 34       list>
 35     property>
 36     <property name="hibernateProperties">
 37       <props>
 38         <prop key="hibernate.dialect">net.sf.hibernate.dialect.MySQLDialectprop>
 39         <prop key="hibernate.show_sql">trueprop>
 40       props>
 41     property>
 42   bean>
 43   <bean id="myTransactionManager" class="org.springframework.orm.hibernate.HibernateTransactionManager">
 44     <property name="sessionFactory">
 45       <ref local="sessionFactory"/>
 46     property>
 47   bean>
 48   
 49   <bean id="hibernateInterceptor" class="org.springframework.orm.hibernate.HibernateInterceptor">
 50     <property name="sessionFactory">
 51       <ref bean="sessionFactory"/>
 52     property>
 53   bean>
 54   <bean id="studentDaoTarget" class="limq.hibernate.dao.StudentsDao">
 55     <property name="sessionFactory">
 56       <ref bean="sessionFactory"/>
 57     property>
 58   bean>
 59   <bean id="teacherDaoTarget" class="limq.hibernate.dao.TeachersDao">
 60     <property name="sessionFactory">
 61       <ref bean="sessionFactory"/>
 62     property>
 63   bean>
 64   <bean id="courseDaoTarget" class="limq.hibernate.dao.CoursesDao">
 65     <property name="sessionFactory">
 66       <ref bean="sessionFactory"/>
 67     property>
 68   bean>
 69   <bean id="classDaoTarget" class="limq.hibernate.dao.ClassesDao">
 70     <property name="sessionFactory">
 71       <ref bean="sessionFactory"/>
 72     property>
 73   bean>
 74   <bean id="departmentDaoTarget" class="limq.hibernate.dao.DepartmentDao">
 75     <property name="sessionFactory">
 76       <ref bean="sessionFactory"/>
 77     property>
 78   bean>
 79   <bean id="adminDaoTarget" class="limq.hibernate.dao.AdminDao">
 80     <property name="sessionFactory">
 81       <ref bean="sessionFactory"/>
 82     property>
 83   bean>
 84   <bean id="studentDao" class="org.springframework.aop.framework.ProxyFactoryBean">
 85     <property name="proxyInterfaces">
 86       <value>limq.hibernate.dao.IStudentsvalue>
 87     property>
 88     <property name="interceptorNames">
 89       <list>
 90         <value>hibernateInterceptorvalue>
 91         <value>studentDaoTargetvalue>
 92       list>
 93     property>
 94   bean>
 95   <bean id="teacherDao" class="org.springframework.aop.framework.ProxyFactoryBean">
 96     <property name="proxyInterfaces">
 97       <value>limq.hibernate.dao.ITeachersvalue>
 98     property>
 99     <property name="interceptorNames">
100       <list>
101         <value>hibernateInterceptorvalue>
102         <value>teacherDaoTargetvalue>
103       list>
104     property>
105   bean>
106   <bean id="courseDao" class="org.springframework.aop.framework.ProxyFactoryBean">
107     <property name="proxyInterfaces">
108       <value>limq.hibernate.dao.ICoursesvalue>
109     property>
110     <property name="interceptorNames">
111       <list>
112         <value>hibernateInterceptorvalue>
113         <value>courseDaoTargetvalue>
114       list>
115     property>
116   bean>
117   <bean id="classDao" class="org.springframework.aop.framework.ProxyFactoryBean">
118     <property name="proxyInterfaces">
119       <value>limq.hibernate.dao.IClassesvalue>
120     property>
121     <property name="interceptorNames">
122       <list>
123         <value>hibernateInterceptorvalue>
124         <value>classDaoTargetvalue>
125       list>
126     property>
127   bean>
128   <bean id="departmentDao" class="org.springframework.aop.framework.ProxyFactoryBean">
129     <property name="proxyInterfaces">
130       <value>limq.hibernate.dao.IDepartmentvalue>
131     property>
132     <property name="interceptorNames">
133       <list>
134         <value>hibernateInterceptorvalue>
135         <value>departmentDaoTargetvalue>
136       list>
137     property>
138   bean>
139   <bean id="adminDao" class="org.springframework.aop.framework.ProxyFactoryBean">
140     <property name="proxyInterfaces">
141       <value>limq.hibernate.dao.IAdminvalue>
142     property>
143     <property name="interceptorNames">
144       <list>
145         <value>hibernateInterceptorvalue>
146         <value>adminDaoTargetvalue>
147       list>
148     property>
149   bean>
150   
151   <bean id="studentManagerTarget" class="limq.spring.service.StudentsServiceImpl">
152     <property name="studentsDao">
153       <ref bean="studentDao"/>
154     property>
155     <property name="coursesDao">
156       <ref bean="courseDao"/>
157     property>
158     <property name="classesDao">
159       <ref bean="classDao"/>
160     property>
161     <property name="departmentsdao">
162       <ref bean="departmentDao"/>
163     property>
164   bean>
165   <bean id="teacherManagerTarget" class="limq.spring.service.TeachersServiceImpl">
166     <property name="teachersDao">
167       <ref bean="teacherDao"/>
168     property>
169     <property name="coursesDao">
170       <ref bean="courseDao"/>
171     property>
172     <property name="classesDao">
173       <ref bean="classDao"/>
174     property>
175     <property name="studentsDao">
176       <ref bean="studentDao"/>
177     property>
178   bean>
179   <bean id="adminManagerTarget" class="limq.spring.service.AdminServiceImpl">
180     <property name="adminDao">
181       <ref bean="adminDao"/>
182     property>
183     <property name="teachersDao">
184       <ref bean="teacherDao"/>
185     property>
186     <property name="coursesDao">
187       <ref bean="courseDao"/>
188     property>
189     <property name="classesDao">
190       <ref bean="classDao"/>
191     property>
192     <property name="studentsDao">
193       <ref bean="studentDao"/>
194     property>
195     <property name="departmentsdao">
196       <ref bean="departmentDao"/>
197     property>
198   bean>
199   
200   <bean id="studentManager" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
201     <property name="transactionManager">
202       <ref bean="myTransactionManager"/>
203     property>
204     <property name="target">
205       <ref bean="studentManagerTarget"/>
206     property>
207     <property name="transactionAttributes">
208       <props>
209         <prop key="get*">PROPAGATION_SUPPORTSprop>
210         <prop key="*">PROPAGATION_REQUIREDprop>
211       props>
212     property>
213   bean>
214   <bean id="teacherManager" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
215     <property name="transactionManager">
216       <ref bean="myTransactionManager"/>
217     property>
218     <property name="target">
219       <ref bean="teacherManagerTarget"/>
220     property>
221     <property name="transactionAttributes">
222       <props>
223         <prop key="get*">PROPAGATION_SUPPORTSprop>
224         <prop key="*">PROPAGATION_REQUIREDprop>
225       props>
226     property>
227   bean>
228   <bean id="adminManager" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
229     <property name="transactionManager">
230       <ref bean="myTransactionManager"/>
231     property>
232     <property name="target">
233       <ref bean="adminManagerTarget"/>
234     property>
235     <property name="transactionAttributes">
236       <props>
237         <prop key="get*">PROPAGATION_SUPPORTSprop>
238         <prop key="*">PROPAGATION_REQUIREDprop>
239       props>
240     property>
241   bean>
242 beans>
243 

StudentsServiceImpl以爲例,下圖演示瞭如何利用Spring的Ioc與Hibernate的結合。
可以看到分別將studentDao,classDao,coursesDao,departmentDao,注入studentManager.
pic4.JPG
  1 IStudentsService.java
  2 public interface IStudentsService {
  3 
  4     public  boolean validate(String username,String pasword);  
  5     public Classes[] getClassesFromCourse(Courses courses);
  6     public  Department getDepFromID(Integer id);
  7     public   Courses getCourseFromID(Integer id);
  8     public   Classes getClassFromID(Integer id);
  9     public  Students getStudetFromName(String name);
 10     public  boolean ifEnrolSameCourse(Classes clazz,Students stu);
 11     public  void selectClasses(Students stu, Classes clazz,Date date);
 12     public  boolean ifMoreThanCap(Classes clazz);
 13     public void updateSudent(Students stu,Contact contact);
 14     public HashMap getCourse(PageInfo pageinfo) throws Exception;
 15     public HashMap getStudentHistory(PageInfo pageinfo,String stu_name) throws Exception;
 16  
 17 }
 18 
 19 實現StudentsServiceImpl.java
 20 public class StudentsServiceImpl implements IStudentsService {
 21 
 22     private Logger log = Logger.getLogger(this.getClass());
 23 
 24     private IStudents studentsDao;
 25 
 26     private ICourses coursesDao;
 27 
 28     private IClasses classesDao;
 29 
 30     private IDepartment departmentsdao;
 31 
 32     /**
 33      * 驗證用戶名密碼
 34      * 
 35      * @param username
 36      *            用戶名
 37      * @param password
 38      *            密碼
 39      */
 40 
 41     public boolean validate(String username, String password) {
 42 
 43         String password2 = studentsDao.getPasswordFromUsername(username);
 44         if (password.equals(password2))
 45             return true;
 46         else
 47             return false;
 48 
 49     }
 50 
 51     /**
 52      * 查找所有課程
 53      *  
 54      */
 55     public Courses[] getAllCourses() {
 56 
 57         List list = null;
 58         try {
 59 
 60             list = coursesDao.find("select c from Courses as c ");
 61         } catch (Exception e) {
 62         }
 63 
 64         return (Courses[]) list.toArray(new Courses[0]);
 65     }
 66 
 67     /**
 68      *  分頁顯示所有課程
 69      * 
 70      * @param pageinfo
 71      */
 72     public HashMap getCourse(PageInfo pageinfo) throws Exception {
 73 
 74         HashMap hp = new HashMap();
 75         String hsql = "select c from Courses as c order by c.id";
 76         Query query = coursesDao.getQuery(hsql);
 77         int totalCount = pageinfo.getTatalCount();
 78         int totalPage = pageinfo.getTotalpage();
 79         int start = pageinfo.getStart();
 80         totalCount = totalCount == -1 ? coursesDao.getTotalCount(hsql)
 81                 : totalCount;
 82         totalPage = totalPage == -1 ? coursesDao.getTotalPage(totalCount,
 83                 pageinfo.getPageSize()) : totalPage;
 84         query.setFirstResult(start);
 85         query.setMaxResults(pageinfo.getPageSize());
 86         List list = query.list();
 87         hp.put("courses", (Courses[]) list.toArray(new Courses[0]));
 88         hp.put("totalCount"new Integer(totalCount));
 89         hp.put("totalPage"new Integer(totalPage));
 90         return hp;
 91     }
 92     /**
 93      *  分頁顯示所有選課歷史
 94      * @param pageinfo 
 95      * @param stu_name
 96      */
 97     public HashMap getStudentHistory(PageInfo pageinfo, String stu_name)
 98             throws Exception {
 99         HashMap hp = new HashMap();
100         Students stu = this.getStudetFromName(stu_name);
101         Integer stu_id = stu.getId();
102         Criteria criteria = coursesDao.getCriteria(History.class);
103         criteria.createCriteria("student").add(Expression.eq("name", stu_name));
104         int totalCount = pageinfo.getTatalCount();
105         int totalPage = pageinfo.getTotalpage();
106         int start = pageinfo.getStart();
107         totalCount = totalCount == -1 ? criteria.list().size() : totalCount;
108         totalPage = totalPage == -1 ? studentsDao.getTotalPage(totalCount,
109         pageinfo.getPageSize()) : totalPage;
110         criteria.setFirstResult(start);
111         criteria.setMaxResults(pageinfo.getPageSize());
112         criteria.addOrder(Order.asc("id"));
113         List list = criteria.list();
114         hp.put("history", (History[]) list.toArray(new History[0]));
115         hp.put("totalCount"new Integer(totalCount));
116         hp.put("totalPage"new Integer(totalPage));
117         return hp;
118     }
119     /**
120      * 根據課程查找班級
121      * @param course
122      *            課程實體
123      * @return 返回該課程下所有班級
124      */
125     public Classes[] getClassesFromCourse(Courses course) {
126         return coursesDao.getClassesFromCourse(course);
127     }
128 
129     /**
130      * 根據主鍵查找系
131      * @param id
132      *            主鍵ID
133      */
134     public Department getDepFromID(Integer id) {
135         return (Department) departmentsdao
136                 .loadByKey(Department.class"id", id);
137     }
138 
139     /**
140      * 根據主鍵查找課程
141      * @param id
142      *            主鍵ID
143      */
144     public Courses getCourseFromID(Integer id) {
145         return (Courses) coursesDao.loadByKey(Courses.class"id", id);
146     }
147     /**
148      * 根據主鍵查找班級
149      * @param id
150      *            主鍵ID
151      */
152     public Classes getClassFromID(Integer id) {
153         return (Classes) classesDao.loadByKey(Classes.class"id", id);
154     }
155 
156     /**
157      * 根據姓名查找學生
158      * @param name
159      */
160     public Students getStudetFromName(String name) {
161         return (Students) studentsDao.loadByKey(Students.class"name", name);
162     }
163 
164     /**
165      * 檢查學生是否選報了同一課程的班級
166      * @param clazz
167      *            所選報的班級
168      * @param stu
169      *            學生實體
170      * @return true 該生選報同一課程的班級
171      * @return false 沒有報過該課程的班級,可以選報
172      *  
173      */
174     public boolean ifEnrolSameCourse(Classes clazz, Students stu) {
175 
176         Courses cour = clazz.getCourse();
177 
178         Classes[] classes = (Classes[]) stu.getClasses()
179                 .toArray(new Classes[0]);
180         for (int i = 0; i < classes.length; i++) {
181 
182             Courses c1 = classes[i].getCourse();
183 
184             if (c1.getId().equals(cour.getId()))
185                 return true;
186         }
187         return false;
188     }
189 
190     /**
191      * 檢查課程的目前人數 
192      * @param clazz
193      *            檢查班級人數是否已滿
194      * @param clazz
195      *            班級實體
196      * @return true 班級人數已滿
197      * @return false 班級人數未滿
198      *  
199      */
200     public boolean ifMoreThanCap(Classes clazz) {
201         Integer capacity = clazz.getCapacity();
202         Integer maxcapacity = clazz.getMaxcapacity();
203         if (capacity.intValue() < maxcapacity.intValue()) {
204             clazz.setCapacity(Integer.valueOf(capacity.intValue() + 1));
205             //classesDao.update(clazz);
206             return false;
207         } else
208             return true;
209 
210     }
211 
212     /**
213      * 數據庫插入選擇班級的記錄
214      * @param stu
215      *            學生
216      * @param clazz
217      *            所選擇的班級
218      */
219     public void selectClasses(Students stu, Classes clazz, Date date)
220  {
221         stu.getClasses().add(clazz);
222         clazz.getStudents().add(stu);          
223         History his = new History();
224         his.setEnrolTime(date);
225         his.setStudent(stu);
226         his.setClasses(clazz);
227         his.setScore(clazz.getCourse().getScore());
228         his.setMarking(new Double(0));
229         try{
230         String cour_name=new String(clazz.getCourse().getName().getBytes("GBK"));       
231         his.setCourseName(cour_name);
232         }catch( java.io.UnsupportedEncodingException e){e.getStackTrace();}       
233         stu.getHistory().add(his);
234     }
235 
236     public void updateSudent(Students stu,Contact contact){
237         
238        studentsDao.update(stu);
239        studentsDao.update(contact);
240     
241     }
242     public IStudents getStudentsDao() {
243         return studentsDao;
244     }
245     public void setStudentsDao(IStudents studentsDao) {
246         this.studentsDao = studentsDao;
247     }
248     public IClasses getClassesDao() {
249         return classesDao;
250     }
251     public void setClassesDao(IClasses classesDao) {
252         this.classesDao = classesDao;
253     }
254     public ICourses getCoursesDao() {
255         return coursesDao;
256     }
257     public void setCoursesDao(ICourses coursesDao) {
258         this.coursesDao = coursesDao;
259     }
260     public IDepartment getDepartmentsdao() {
261         return departmentsdao;
262     }
263     public void setDepartmentsdao(IDepartment departmentdao) {
264         this.departmentsdao = departmentdao;
265     }
266 }
267 
268 

4 UI
這裏我們選擇Struts,首先配置 web.xml
 1 xml version="1.0" encoding="UTF-8"?>
 2 <web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.4" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee   http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
 3   <context-param>
 4     <param-name>contextConfigLocationparam-name>
 5     <param-value>/WEB-INF/classes/applications-service.xmlparam-value>
 6   context-param>
 7   <context-param>
 8     <param-name>log4jConfigLocationparam-name>
 9     <param-value>/WEB-INF/log4j.propertiesparam-value>
10   context-param>
11   <filter>
12     <filter-name>hibernateFilterfilter-name>
13     <filter-class>org.springframework.orm.hibernate.support.OpenSessionInViewFilterfilter-class>
14   filter>
15   <filter-mapping>
16     <filter-name>hibernateFilterfilter-name>
17     <url-pattern>/*url-pattern>
18   filter-mapping>
19   <filter>
20     <filter-name>Set Character Encodingfilter-name>
21     <filter-class>limq.struts.SetCharacterEncodingFilterfilter-class>
22   filter>
23   <filter-mapping>
24     <filter-name>Set Character Encodingfilter-name>
25     <url-pattern>/*url-pattern>
26   filter-mapping>
27   <servlet>
28     <servlet-name>SpringContextServletservlet-name>
29     <servlet-class>org.springframework.web.context.ContextLoaderServletservlet-class>
30     <load-on-startup>1load-on-startup>
31   servlet>
32   <servlet>
33     <servlet-name>actionservlet-name>
34     <servlet-class>org.apache.struts.action.ActionServletservlet-class>
35     <init-param>
36       <param-name>configparam-name>
37       <param-value>/WEB-INF/struts-config.xmlparam-value>
38     init-param>
39     <init-param>
40       <param-name>debugparam-name>
41       <param-value>3param-value>
42     init-param>
43     <init-param>
44       <param-name>detailparam-name>
45       <param-value>3param-value>
46     init-param>
47     <load-on-startup>0load-on-startup>
48   servlet>
49   <servlet-mapping>
50     <servlet-name>actionservlet-name>
51     <url-pattern>*.dourl-pattern>
52   servlet-mapping>
53 web-app>
54 
55 
其中注意這幾句,
1 <filter>
2     <filter-name>hibernateFilterfilter-name>
3 <filter-class>org.springframework.orm.hibernate.support.OpenSessionInViewFilterfilter-class>
4   filter>
5 <filter-mapping>
6     <filter-name>hibernateFilterfilter-name>
7     <url-pattern>/*url-pattern>
8 filter-mapping>
9 
 1 CoursesAction.java
 2     /** 
 3      * 查看課程下的班級 
 4      */ 
 5     public ActionForward viewClassFromCourse(ActionMapping mapping,
 6             ActionForm form, HttpServletRequest request,
 7             HttpServletResponse response) throws Exception {
 8         Integer cour_id = Integer.valueOf((request.getParameter("cour_id")));
 9         Courses cour = super.getStudentsService().getCourseFromID(cour_id);
10         Classes[] clazz =(Classes[])cour.getClasses().toArray(new Classes[0]);
11         request.setAttribute("clazz", clazz);
12         return mapping.findForward("success");
13 }
14 
這裏從上一個頁面獲得課程編號 cour_id, 然後通過StudentsServiceImpl中的
方法查到Courses實例,利用Courses和Classes的關聯關係得到Classes[],在將其放入
Request. 通過mapping.findForward("success"),轉發到
select_course_Content.jsp

CustomRequestProcessor.java 介紹
 1 public class CustomRequestProcessor extends RequestProcessor {
 2     protected boolean
 processPreprocess(HttpServletRequest request,
 3 
            HttpServletResponse response) {
 4         boolean continueProcessing = true
;
 5         HttpSession session =
 request.getSession();
 6         String uri =
request.getRequestURI();
 7         if ( session == null || session.getAttribute("userName"== null
 ) {
 8             continueProcessing = false
;  
 9         if(uri.endsWith("login.do")) return true
;    
10         try
{
11             response.sendRedirect("/StudentManger/login.jsp"
 );
12           }catch
( Exception ex ){
13             log.error( "Problem sending redirect from processPreprocess()"
 );
14 
          }
15 
        }
16         return
 continueProcessing;
17 
    }
18 
}
19 

爲了驗證用戶操作權限,這裏擴展了Struts 的RequestProcessor來判斷Session如果Session和userName都不空則程序繼續,否則重定向到login.jsp。要想擴展RequestProcessor類,需在Struts的配置文件中加入
呵呵,當然在正規使用時僅僅這樣驗證是不夠的。歡迎你把自己修改方法告訴我。
 
4分頁處理:
下面重點討論一下Hibernate的分頁處理方式。
Hibernate 中處理查詢主要有 Query ,Criteria,分別以 HSQL或編程方式實現,
本例對這兩種方法都有相關處理。由於在Spring中無法直接使用Query和Criteria對象
所以只有先從Spring那裏借一個Session,等使用完了在還給Sping處理。讀者應該還記得在BaseDao中有這樣的語句方便我們獲取Session及其他對象:
 
 1     public Query getQuery(String sql) throws Exception{
 2         Session session = this.openSession();
 3         Query query = session.createQuery(sql); 
 4     return query;
 5     }
 6    
 7     public Criteria getCriteria(Class clazz) throws Exception{
 8         
 9     Session session=this.openSession();
10     Criteria criteria = session.createCriteria(clazz);
11     return criteria;
12     }
13 
Service層以查詢所有課程與學生選課記錄爲例處理Query與Criteria
 1  StudentsServiceImpl.java
 2     public HashMap getCourse(PageInfo pageinfo) throws Exception {
 3 
 4         HashMap hp = new HashMap();
 5         String hsql = "select c from Courses as c order by c.id";
 6         Query query = coursesDao.getQuery(hsql);
 7         int totalCount = pageinfo.getTatalCount();
 8         int totalPage = pageinfo.getTotalpage();
 9         int start = pageinfo.getStart();
10         totalCount = totalCount == -1 ? coursesDao.getTotalCount(hsql)
11                 : totalCount;
12         totalPage = totalPage == -1 ? coursesDao.getTotalPage(totalCount,
13                 pageinfo.getPageSize()) : totalPage;
14         query.setFirstResult(start);
15         query.setMaxResults(pageinfo.getPageSize());
16         List list = query.list();
17         hp.put("courses", (Courses[]) list.toArray(new Courses[0]));
18         hp.put("totalCount"new Integer(totalCount));
19         hp.put("totalPage"new Integer(totalPage));
20         return hp;
21     }
22    
23     public HashMap getStudentHistory(PageInfo pageinfo, String stu_name)
24             throws Exception {
25         HashMap hp = new HashMap();
26         Students stu = this.getStudetFromName(stu_name);
27         Integer stu_id = stu.getId();
28         Criteria criteria = coursesDao.getCriteria(History.class);
29         criteria.createCriteria("student").add(Expression.eq("name", stu_name));
30         int totalCount = pageinfo.getTatalCount();
31         int totalPage = pageinfo.getTotalpage();
32         int start = pageinfo.getStart();
33         totalCount = totalCount == -1 ? criteria.list().size() : totalCount;
34         totalPage = totalPage == -1 ? studentsDao.getTotalPage(totalCount,
35         pageinfo.getPageSize()) : totalPage;
36         criteria.setFirstResult(start);
37         criteria.setMaxResults(pageinfo.getPageSize());
38         criteria.addOrder(Order.asc("id"));
39         List list = criteria.list();
40         hp.put("history", (History[]) list.toArray(new History[0]));
41         hp.put("totalCount"new Integer(totalCount));
42         hp.put("totalPage"new Integer(totalPage));
43         return hp;
44     }
45 PageIngfo.java
46 public class PageInfo  {
47     
48     int pageNo=0;
49     int totalpage=-1;
50     int tatalCount=-1;
51     int pageSize=0;
52 int start=0;
53 
54 

可以看到getCourse和getStudentHistory有很多相似之處,Hibernate爲Query和Criteria提供了針對不同數據庫的解決分頁方法, Quey需要我們寫HSQL, Criteria不但可以應付帶有條件的查詢,還不用我們自己寫HSQL,PageInfo是含有分頁信息的普通java類。
再看看Struts是如何調用getStudentHistory 的,
 1 PageAction.java
 2 public class PageAction  extends BaseDispatchAction{
 3     public ActionForward execute(ActionMapping mapping,
 4              ActionForm form,
 5              HttpServletRequest request,
 6              HttpServletResponse response)
 7 throws Exception {
 8         String pageNo=request.getParameter("pageNo");
 9         String totalcount=request.getParameter("totalcount");
10         String totalpage=request.getParameter("totalpage");
11         int pagesize=2;//每頁的大小
12         PageInfo page =new PageInfo();
13         page.setPageSize(pagesize);
14         HashMap hp=null;
15         History[] historys = null;
16         String stu_name=null;
17         HttpSession session = request.getSession();
18         stu_name = (String) session.getAttribute("userName"); 
19         if(pageNo == null || totalcount == null || totalpage==null){
20         //第一次發送請求
21             page.setPageNo(1);           
22             hp=super.getStudentsService().getStudentHistory(page,stu_name);
23             page.setTatalCount(((Integer)hp.get("totalCount")).intValue());
24             page.setTotalpage(((Integer)hp.get("totalPage")).intValue());      
25         }else{
26             page.setPageNo(Integer.parseInt(pageNo));
27             page.setTatalCount(Integer.parseInt(totalcount));
28             page.setTotalpage(Integer.parseInt(totalpage));
29            hp=super.getStudentsService().getStudentHistory(page,stu_name);
30            
31         }
32      historys =(History[]) hp.get("history");
33      request.setAttribute("history",historys);
34      request.setAttribute("pageinfo",page);    
35         return mapping.findForward("success");
36     }
37 }
38 

在stu_his_Content.jsp中避免代碼重複使用了自定義標誌來處理分頁
 1  
 2 
 3 
 4 
 5 
 6 
 7 
 8 <html:html locale="true"> 
 9   <body>
10   
14 <table width="550" border="1" cellspacing="0" align="center" cellpadding="0">
15   <tr>
16     <td><bean:message key="class.id"/>td>
17     <td><bean:message key="course.name"/>td>
18     <td><bean:message key="enrol.time"/>td>
19     <td><bean:message key="score"/>td>
20     <td><bean:message key="marking"/>td>
21   tr>
22   
26   <tr>
27     <td>td>
28     <td>td>
29     <td>td>
30     <td>td>
31     <td>td>
32   tr>
33   
36 table>
37 <mytag:page pageinfo="" action="getHistory.do"/>
38 body>
39 html:html>
40 

標誌處理類如下:
 1 PageTag.java
 2 
 3 public class PageTag extends SimpleTagSupport {
 4 
 5     private PageInfo pageinfo = null;
 6 private String action = null;
 7 
 8     public String getAction() {
 9         return action;}
10     public void setAction(String action) {
11         this.action = action;
12     }
13     public PageInfo getPageinfo() {
14         return pageinfo;
15     }
16     public void setPageinfo(PageInfo pageinfo) {
17         this.pageinfo = pageinfo;
18     }
19 
20     public void doTag() throws JspException, IOException {
21         JspWriter out = getJspContext().getOut();
22 
23         int totalpage = pageinfo.getTotalpage();
24         int totalcount = pageinfo.getTatalCount();
25         int pageNo = pageinfo.getPageNo();
26         int addPageNo = pageNo + 1;
27         int minPageNo = pageNo - 1;
28 
29         out.println(""400/" align=/"center/"  cellPadding=/"0/" cellSpacing=/"0/"");
30         out.print("");
31         out.println("" + totalcount + "條," + totalpage + "頁,當前"
32                 + pageNo + "
1 <controller 
2 contentType="text/html;charset=UTF-8"
3 locale="true" 
4 nocache="true" 
5 processorClass="limq.struts.CustomRequestProcessor"/>
6 
1 public Courses getCourseFromID(Integer id) {
2         return (Courses) coursesDao.loadByKey(Courses.class"id", id);
3 }
4 

由於我們使用了lazy = "true"如果想在UI層使用實體對象關聯來獲得其他對象時就會有這樣的提示:
org.hibernate.LazyInitializationException: failed to lazily initialize a collection
Spring 中引入了 OpenSessionInView模式可以處理以上問題,即在web.xml中加入以上代碼。
 
 
接下來建立抽象BaseAction,和 BaseDispatchAction,其中後者與前者相似目的爲減少Action的數量
 1 abstract class BaseAction extends Action {
 2 
 3     private IStudentsService studentsService;
 4     private ITeachersService teachersSerivce;
 5     private IAdminService adminService;
 6     public void setServlet(ActionServlet actionServlet) {
 7         super.setServlet(actionServlet);
 8         ServletContext servletContext = actionServlet.getServletContext();
 9         WebApplicationContext wac = WebApplicationContextUtils
10                 .getRequiredWebApplicationContext(servletContext);
11 
12         this.studentsService = (IStudentsService) wac.getBean("studentManager");
13         this.adminService = (IAdminService) wac.getBean("adminManager");
14         this.teachersSerivce = (ITeachersService) wac.getBean("teacherManager");
15     }
16     public IStudentsService getStudentsService() {
17         return studentsService;
18     }
19     public ITeachersService getTeachersSerivce() {
20         return teachersSerivce;
21     }
22     public void setTeachersSerivce(ITeachersService teachersSerivce) {
23         this.teachersSerivce = teachersSerivce;
24     }
25     public IAdminService getAdminService() {
26         return adminService;
27     }
28     public void setAdminService(IAdminService adminService) {
29         this.adminService = adminService;
30     }
31 }
32 

BaseDispatchAction與之類似,請查看源碼。其他Action都從這兩個類繼承。
以下就以查看課程下的班級爲例演示Struts與Spring的使用:
2 DAO 數據訪問層
首先,編寫IBaseDao與BaseDao,其中IBaseDao代碼如下:
 1 package limq.hibernate.dao;
 2 
 3 import java.util.Collection;
 4 import java.util.List;
 5 import net.sf.hibernate.Criteria;
 6 import net.sf.hibernate.Query;
 7 import net.sf.hibernate.Session;
 8 import limq.exception.DaoException;
 9 
10 public interface IBaseDao {
11     
12     public Session openSession();
13     
14     public  int getTotalCount( String hql) throws Exception;
15     
16     public Query getQuery(String sql) throws Exception;
17     
18     public Criteria getCriteria(Class clazz) throws Exception;
19     
20     public int getTotalPage(int totalCount,int pageSize);
21     
22     public void create(Object entity);
23 
24     public void update(Object entity);
25 
26     public void delete(Object entity) throws DaoException;
27 
28     public void deleteAll(Class clazz) throws DaoException;
29 
30     public void deleteAll(Collection entities) throws DaoException;
31 
32     public Object loadByKey(Class clazz, String keyName, Object keyValue);
33 
34     public List find(String queryString) throws DaoException;
35 
36     public List find(String queryString, Object param) throws DaoException;
37 
38     public List find(String queryString, Object[] params) throws DaoException;
39 
40 }
41 

BaseDao繼承org.springframework.orm.hibernate.support.HibernateDaoSupport
實現以上的 定義的方法
如:
可以看到,這裏即充分利用了Spring對Hibernate的支持,還彌補了Spring的不足。最後分別爲每個持久對象建立Interface,以及DAO,使其分別繼承IBaseDao與BaseDao。
如IDepartment,DepartmentDao
 1 public void create(Object entity)  { 
 2         try { 
 3             getHibernateTemplate().save(entity); 
 4             
 5         } catch (Exception e) { 
 6             log.error("保存 " + entity.getClass().getName() + " 實例到數據庫失敗", e); 
 7            
 8         } 
 9     } 
10     /** 
11      * 獲得session        
12      */ 
13     public Session openSession() {
14         return SessionFactoryUtils.getSession(getSessionFactory(), false);
15     }
16 
17     /** 
18      * 獲得Query對象       
19      */ 
20     public Query getQuery(String sql) throws Exception{
21         Session session = this.openSession();
22         Query query = session.createQuery(sql); 
23     return query;
24     }
25     /** 
26      * 獲得Criteria對象       
27      */
28     public Criteria getCriteria(Class clazz) throws Exception{
29         
30     Session session=this.openSession();
31     Criteria criteria = session.createCriteria(clazz);
32     return criteria;
33     }
34 
同樣在History.cfg.xml中加入:
1  <many-to-one name="student"
2                   class="limq.hibernate.vo.Students"
3                   column="student_id"  >    
4      many-to-one>
5 
 ");
33         out.println(" ");
34         if (pageNo > 1) {
35             out
36                     .println("&"/StudentManger/" + action
37                             + "?pageNo=1"+ "&totalpage=" + totalpage + "&totalcount="
38                     + totalcount + "/">" );
39         }
40         out.print("首頁");
41         out.println(" ");
42         if (pageNo > 1) {
43             out.println("&"/StudentManger/" + action + "?pageNo="
44                     + minPageNo + "&totalpage=" + totalpage + "&totalcount="
45                     + totalcount + "/">");
46         }
47         out.print("上頁");
48         out.println(" ");
49         if (pageNo < totalpage) {
50             out.println("&"/StudentManger/" + action + "?pageNo="
51                     + addPageNo + "&totalpage=" + totalpage + "&totalcount="
52                     + totalcount + "/">");
53         }
54         out.print("下頁");
55         out.println(" ");
56         if (pageNo < totalpage) {
57 
58             out.println(""/StudentManger/" + action + "?pageNo="
59                     + totalpage + "&totalpage=" + totalpage + "&totalcount="
60                     + totalcount + "/">");
61 
62         }
63         out.print("末頁");
64         out.println(" ");
65         out.println("  ");
66 
67     }
68 
69 }
70 

5
中文亂碼問題:
1 數據庫:MYSQL 4.1 (或以上版本)4.1直接支持Unicode,以下版本支持的不好。
2 驅動: MySQL JDBC Driver3.0.16(或以上版本)
3 在數據庫中做如下設定
pic5.JPG
4 在建立表時同樣加上ENGINE=MyISAM DEFAULT CHARSET=gbk
5 配置hibernate.cfg.xml
1 <property name="connection.url">jdbc:mysql://localhost:3306/Studentproperty>
2 <property name="dialect">net.sf.hibernate.dialect.MySQLDialectproperty>
3 <property name="connection.password">property>
4 <property name="connection.driver_class">com.mysql.jdbc.Driverproperty>
5 
robbin MySQL JDBC Driver的3.0.16也是一個分水嶺,3.0.16版本會取數據庫本身的編碼,然後按照該編碼轉換,這種方式和Oracle的JDBC Driver是一樣的。例如你的數據庫是GBK編碼的話,JDBC Driver就會把數據庫裏面的取出來的字符串按照GBK往unicode轉換,送給JVM。因此正確的設置數據庫本身的編碼就尤爲重要。
MySQL JDBC Driver3.0.16以下的版本則不然,它不會那麼智能的根據數據庫編碼來確定如何轉換,它總是默認使用ISO8859-1,因此你必須使用 characterEncoding=GBK來強制他把數據庫中取出來的字符串按照GBK來往unicode轉換。
因此,使用什麼數據庫版本,不管是3.x,還是4.0.x還是4.1.x,其實對我們來說不重要,重要的有二:

1) 正確的設定數據庫編碼,MySQL4.0以下版本的字符集總是默認ISO8859-1,MySQL4.1在安裝的時候會讓你選擇。如果你準備使用UTF- 8,那麼在創建數據庫的時候就要指定好UTF-8(創建好以後也可以改,4.1以上版本還可以單獨指定表的字符集)
2) 使用3.0.16以上版本的JDBC Driver,那麼你就不需要再寫什麼characterEncoding=UTF-8
 
6 開發工具介紹
MyEclipse 3.8
首先添加用戶庫,如下圖將Struts,Spring,Hibernate 的庫添加到用戶庫中
pic6.JPG
如果出現環境問題可能你的Struts包有問題,請到http://struts.apache.org/download.cgi下載struts-1.2.7-lib.zip
具體使用參考http://www.laliluna.de/struts-hibernate-integration-tutorial-en.html
總結
本文至此已將Struts+Sprng+Hibernate的大致思路以及本人所遇到的難點,重點介紹完了。
其中管理員我只完成了對學生的部分,其他功能大同小異,有興趣的讀者不妨動手試試。最後建議初學者不要直接使用Spring對Hibernate的封裝,而是從Hibernate學起,先要學會自己管理Session,Transaction,然後在用Spring,這樣理解會更深刻。
1CREATE TABLE `students` (
2  `id` int(20NOT NULL default '0',
3  `name` varchar(20NOT NULL default '',
4  `department_id` int(11default NULL,
5  `password` varchar(20default NULL,
6  `score` double(15,3default NULL,
7  PRIMARY KEY  (`id`)
8) ENGINE=MyISAM DEFAULT CHARSET=gbk
9
介紹
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章