搭建好SSH的组合环境，简单的开发一个东西，一个页面输入用户的编号和用户名，年龄来进行页面的跳转，还用查询所有的对象信息。

   安装Hibernate的真正意义是不用手动建数据库表的，只需要创建好实体类就通过Hibernate提供的

   1.在MySql数据库中先创建一个数据库

    

  1.  

  1. create database ssha 

   2.在数据库ssha中创建一张表emps表

 

  1. create table emps 
  2. ( 
  3.    empId int auto_increment primary key, 
  4.    empName varchar(29) not null, 
  5.    empAge int not null 
  6. ) 

   3.数据库中插入数据

   

Struts1.2 Hibernate Spring框架组合（二）_Hibernate组合

  4.使用MyEclipse生成实体类

 

  1. package xiao.zhang.bean; 
  2.  
  3. /** 
  4.  * Emps entity. 
  5.  *  
  6.  * @author MyEclipse Persistence Tools 
  7.  */ 
  8.  
  9. public class Emps implements java.io.Serializable { 
  10.  
  11.     // Fields 
  12.  
  13.     private Integer empId; 
  14.     private String empName; 
  15.     private Integer empAge; 
  16.  
  17.     // Constructors 
  18.  
  19.     /** default constructor */ 
  20.     public Emps() { 
  21.     } 
  22.  
  23.     /** minimal constructor */ 
  24.     public Emps(String empName) { 
  25.         this.empName = empName; 
  26.     } 
  27.  
  28.     /** full constructor */ 
  29.     public Emps(String empName, Integer empAge) { 
  30.         this.empName = empName; 
  31.         this.empAge = empAge; 
  32.     } 
  33.  
  34.     // Property accessors 
  35.  
  36.     public Integer getEmpId() { 
  37.         return this.empId; 
  38.     } 
  39.  
  40.     public void setEmpId(Integer empId) { 
  41.         this.empId = empId; 
  42.     } 
  43.  
  44.     public String getEmpName() { 
  45.         return this.empName; 
  46.     } 
  47.  
  48.     public void setEmpName(String empName) { 
  49.         this.empName = empName; 
  50.     } 
  51.  
  52.     public Integer getEmpAge() { 
  53.         return this.empAge; 
  54.     } 
  55.  
  56.     public void setEmpAge(Integer empAge) { 
  57.         this.empAge = empAge; 
  58.     } 
  59.  
  60. } 

  5.Emps.hbm.xml文件信息如下：

   

  1. <hibernate-mapping> 
  2.     <class name="xiao.zhang.bean.Emps" table="emps" catalog="ssha"> 
  3.         <id name="empId" type="java.lang.Integer"> 
  4.             <column name="empId" /> 
  5.             <generator class="native" /> 
  6.         </id> 
  7.         <property name="empName" type="java.lang.String"> 
  8.             <column name="empName" length="20" not-null="true" /> 
  9.         </property> 
  10.         <property name="empAge" type="java.lang.Integer"> 
  11.             <column name="empAge" /> 
  12.         </property> 
  13.     </class> 
  14.  

  1. </hibernate-mapping> 

在Spring配种文件中配置实体类的映射文件，这一部分属于Hibernate和Spring的组合：

  1. <bean id="sessionFactory" 
  2.         class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> 
  3.         <property name="dataSource"> 
  4.             <ref bean="dataSource" /> 
  5.         </property> 
  6.         <property name="hibernateProperties"> 
  7.             <props> 
  8.                 <prop key="hibernate.dialect"> 
  9.                     org.hibernate.dialect.MySQLDialect 
  10.                 </prop> 
  11.             </props> 
  12.         </property> 
  13. <!--*********************************************************--> 
  14.         <property name="mappingResources"> 
  15.             <list> 
  16.                 <value>xiao/zhang/bean/Emps.hbm.xml</value> 
  17.             </list> 
  18.         </property> 
  19. <!--*********************************************************--> 
  20.     </bean> 

*星号括起的部分信息。 

6.生成Emps的DAO

   

  1. public class EmpsDAO extends HibernateDaoSupport implements ImpEmpsDao { 
  2.     private static final Log log = LogFactory.getLog(EmpsDAO.class); 
  3.     // property constants 
  4.     public static final String EMP_NAME = "empName"; 
  5.     public static final String EMP_AGE = "empAge"; 
  6.  
  7.     protected void initDao() { 
  8.         // do nothing 
  9.     } 
  10.  
  11.     public void save(Emps transientInstance) { 
  12.         log.debug("saving Emps instance"); 
  13.         try { 
  14.             getHibernateTemplate().save(transientInstance); 
  15.             log.debug("save successful"); 
  16.         } catch (RuntimeException re) { 
  17.             log.error("save failed", re); 
  18.             throw re; 
  19.         } 
  20.     } 
  21.  
  22.     public void delete(Emps persistentInstance) { 
  23.         log.debug("deleting Emps instance"); 
  24.         try { 
  25.             getHibernateTemplate().delete(persistentInstance); 
  26.             log.debug("delete successful"); 
  27.         } catch (RuntimeException re) { 
  28.             log.error("delete failed", re); 
  29.             throw re; 
  30.         } 
  31.     } 
  32.  
  33.     public Emps findById(java.lang.Integer id) { 
  34.         log.debug("getting Emps instance with id: " + id); 
  35.         try { 
  36.             Emps instance = (Emps) getHibernateTemplate().get( 
  37.                     "xiao.zhang.bean.Emps", id); 
  38.             return instance; 
  39.         } catch (RuntimeException re) { 
  40.             log.error("get failed", re); 
  41.             throw re; 
  42.         } 
  43.     } 
  44.  
  45.     public List findByExample(Emps instance) { 
  46.         log.debug("finding Emps instance by example"); 
  47.         try { 
  48.             List results = getHibernateTemplate().findByExample(instance); 
  49.             log.debug("find by example successful, result size: " 
  50.                     + results.size()); 
  51.             return results; 
  52.         } catch (RuntimeException re) { 
  53.             log.error("find by example failed", re); 
  54.             throw re; 
  55.         } 
  56.     } 
  57.  
  58.     public List findByProperty(String propertyName, Object value) { 
  59.         log.debug("finding Emps instance with property: " + propertyName 
  60.                 + ", value: " + value); 
  61.         try { 
  62.             String queryString = "from Emps as model where model." 
  63.                     + propertyName + "= ?"; 
  64.             return getHibernateTemplate().find(queryString, value); 
  65.         } catch (RuntimeException re) { 
  66.             log.error("find by property name failed", re); 
  67.             throw re; 
  68.         } 
  69.     } 
  70.  
  71.     public List findByEmpName(Object empName) { 
  72.         return findByProperty(EMP_NAME, empName); 
  73.     } 
  74.  
  75.     public List findByEmpAge(Object empAge) { 
  76.         return findByProperty(EMP_AGE, empAge); 
  77.     } 
  78.  
  79.     public List findAll() { 
  80.         log.debug("finding all Emps instances"); 
  81.         try { 
  82.             String queryString = "from Emps"; 
  83.             return getHibernateTemplate().find(queryString); 
  84.         } catch (RuntimeException re) { 
  85.             log.error("find all failed", re); 
  86.             throw re; 
  87.         } 
  88.     } 
  89.  
  90.     public Emps merge(Emps detachedInstance) { 
  91.         log.debug("merging Emps instance"); 
  92.         try { 
  93.             Emps result = (Emps) getHibernateTemplate().merge(detachedInstance); 
  94.             log.debug("merge successful"); 
  95.             return result; 
  96.         } catch (RuntimeException re) { 
  97.             log.error("merge failed", re); 
  98.             throw re; 
  99.         } 
  100.     } 
  101.  
  102.     public void attachDirty(Emps instance) { 
  103.         log.debug("attaching dirty Emps instance"); 
  104.         try { 
  105.             getHibernateTemplate().saveOrUpdate(instance); 
  106.             log.debug("attach successful"); 
  107.         } catch (RuntimeException re) { 
  108.             log.error("attach failed", re); 
  109.             throw re; 
  110.         } 
  111.     } 
  112.  
  113.     public void attachClean(Emps instance) { 
  114.         log.debug("attaching clean Emps instance"); 
  115.         try { 
  116.             getHibernateTemplate().lock(instance, LockMode.NONE); 
  117.             log.debug("attach successful"); 
  118.         } catch (RuntimeException re) { 
  119.             log.error("attach failed", re); 
  120.             throw re; 
  121.         } 
  122.     } 
  123.  
  124.     public static EmpsDAO getFromApplicationContext(ApplicationContext ctx) { 
  125.         return (EmpsDAO) ctx.getBean("EmpsDAO"); 
  126.     } 
  127. } 

   将数据访问对象交由Spring容器管理，在Spring的配置文件中配置该类的信息


  1. <!-- 数据库访问对象 --> 
  2.     <bean id="EmpsDAO" class="xiao.zhang.dao.imp.EmpsDAO"> 
  3.         <property name="sessionFactory"> 
  4.             <ref bean="sessionFactory" /> 
  5.         </property> 
  6.     </bean> 

7.为了实现面向接口编程，同时能够将业务逻辑部分与数据库访问部分的代码进行解耦合。下面是文件树图：

 

Struts1.2 Hibernate Spring框架组合（二）_Spring_02

8.接下来应该是手工编程，这样利于代码的控制。

9.根据7中已经对业务和数据访问进行的了分离，下面是分离后的代码:

 

  1. public interface ImpEmpsDao { 
  2.     public void save(Emps transientInstance); 
  3.  
  4.     public void delete(Emps persistentInstance); 
  5.  
  6.     public Emps findById(java.lang.Integer id); 
  7.  
  8.     public List findByExample(Emps instance); 
  9.  
  10.     public List findByProperty(String propertyName, Object value); 
  11.  
  12.     public List findByEmpName(Object empName); 
  13.  
  14.     public List findByEmpAge(Object empAge); 
  15.  
  16.     public List findAll(); 
  17.  
  18.     public Emps merge(Emps detachedInstance); 
  19.  
  20.     public void attachDirty(Emps instance); 
  21.  
  22.     public void attachClean(Emps instance); 
  23.  
  24. } 

上面是数据访问的接口，这样就可以面向接口编程

10.下面是业务逻辑层的代码：

  先定义业务处理的接口：


  1. /** 
  2.  *  
  3.  * 实现了业务逻辑的封装，将业务操作和数据操作分离 
  4.  *  
  5.  * @author aiilive 
  6.  * 
  7.  */ 
  8. public interface ImpEmpsService { 
  9.  
  10.     public void addEmps(Emps transientInstance); 
  11.  
  12.     public void deleteEmpsById(int empId); 
  13.  
  14.     public List findAll(); 
  15.  
  16.     public Emps getEmpsById(int empId); 
  17.  
  18. } 

  实现业务逻辑：

  

  1. import java.util.List; 
  2.  
  3. import xiao.zhang.bean.Emps; 
  4. import xiao.zhang.dao.ImpEmpsDao; 
  5. import xiao.zhang.service.ImpEmpsService; 
  6.  
  7. public class EmpsServiceImp implements ImpEmpsService { 
  8.  
  9.     private ImpEmpsDao empsDao; 
  10.  
  11.     public void addEmps(Emps transientInstance) { 
  12.         empsDao.save(transientInstance); 
  13.     } 
  14.  
  15.     public void deleteEmpsById(int empId) { 
  16.         Emps emps = empsDao.findById(empId); 
  17.         if (emps == null) { 
  18.             return; 
  19.         } 
  20.         empsDao.delete(emps); 
  21.     } 
  22.  
  23.     public List findAll() { 
  24.         return empsDao.findAll(); 
  25.     } 
  26.  
  27.     public Emps getEmpsById(int empId) { 
  28.         return empsDao.findById(empId); 
  29.     } 
  30.  
  31.     public ImpEmpsDao getEmpsDao() { 
  32.         return empsDao; 
  33.     } 
  34.  
  35.     public void setEmpsDao(ImpEmpsDao empsDao) { 
  36.         this.empsDao = empsDao; 
  37.     } 
  38.  
  39. } 

    在实现业务逻辑中有数据访问对象的实例属性，在Spring的配置文件中应该配置，来实现交由Spring容器对业务逻辑处理类的对象的管理

  1. <!-- 业务处理对象 --> 
  2.     <bean id="EmpsService" 
  3.         class="xiao.zhang.service.imp.EmpsServiceImp"> 
  4.         <property name="empsDao"> 
  5.             <ref bean="EmpsDAO" /> 
  6.         </property> 
  7.     </bean> 

    这样就将业务逻辑层和数据访问层分开，这一部分主要是Hibernate和Spring的组合使用。