limq

rainman
随笔 - 19, 文章 - 2, 评论 - 115, 引用 - 1
数据加载中……

Struts+Spring+Hibernate开发实例

介绍

本文并不想介绍StrutsSpringHibernate的原理系统架构等,本文地目的是通过一个较复杂地实例介绍如何整合StrutsSpringHibernate,网上现有的例子虽然也能达到目的,但功能都比较单一,复杂的例子时会有意想不到的麻烦。本文对读者假设已经具备了以上框架的基础知识。以及那些已经了解StrutsSpringHibernate的基本概念,但是还没有亲身在较复杂的项目中体验StrutsSpringHibernate的开发人员。

1 Struts

    虽然不打算过多介绍Struts的原理,但是大概介绍一下还是有必要的。Struts本身就是 MVC 在这里负责将用户数据传人业务层,以及 将业务层处理的结果返回给用户,此系统属于较简单WEB应用,采用了OpenSessionInView模式处理LazyLoad问题,这样我们可以在用户视图中使用 getset方法来方便地获取关联对象。为了处理庞大的ActionActionForm问题,在此我门准备使用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层,StudentsServiceImplTeachersServiceImplAdminServiceImpl

 

3 Hibernate

 有了Spring的封装,我们要对Hibernate做的就是正确实现对象关系的映射。由于此处处于系统的最底层,准确无误的实现对象之间的关联关系映射将起着至关重要的作用。

 总之,理解了StrutsSpringHibernate地原理以及之间的关系之后,剩下的工作就如同在以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 

同样在History.cfg.xml中加入:

1  <many-to-one name="student"
2                   class="limq.hibernate.vo.Students"
3                   column="student_id"  >    
4      many-to-one>
5 

用过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 以及对应的getset 方法,History.java 中加入

private Students student;

public Students getStudent() {

        return student;

    }

  

 public void setStudent(Students student) {

        this.student = student;

    }

具体内容请查看 源代码。

2 DAO 数据访问层

首先,编写IBaseDaoBaseDao,其中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

实现以上的 定义的方法

如:

 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 

可以看到,这里即充分利用了SpringHibernate的支持,还弥补了Spring的不足。最后分别为每个持久对象建立Interface,以及DAO,使其分别继承IBaseDaoBaseDao

IDepartmentDepartmentDao

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以为例,下图演示了如何利用SpringIocHibernate的结合。

可以看到分别将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