Spring-hibernate

1， 集成Hibernate3与Hibernate4有一定的区别，这里介绍Hibernate3的集成

这里的使用的是 ：hibernate-distribution-3.6.7.Final

  1）导入hibernate包和Spring包

   hibernate3.jar  libjpahibernate-jpa-2.0-api-1.0.1.Final.jar（支持annotation时需要） lib equired下所有包

   log4j的包 （1.2.17）

   hibernate的log4j.properties文件

  2）beans.xml

    创建dataSource（与集成jdbc一模一样）；

    创建Hibernate的SessionFactory

 3）在实体类中创建hibernate的hbm文件或者annotation

 4）创建基于Hibernate的Dao

    在相应的dao中注入相应的sessionFactory

    （如果通过Spring来管理SessionFactory，不再使用openSession()方法，而是使用getCurrentSession()方法来打开一个session，这个session就会被spring所管理，此时开发人员不用进行事务控制，也不用关闭session，全部由Spring来完成）

 5）配置Spring事务管理

2， 具体过程内容见下面代码

<beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:context="http://www.springframework.org/schema/context"
     xmlns:aop="http://www.springframework.org/schema/aop"
     xmlns:tx="http://www.springframework.org/schema/tx"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.0.xsd
            http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
           http://www.springframework.org/schema/tx
         http://www.springframework.org/schema/tx/spring-tx.xsd">

   <!--1, 打开Spring的annotation -->
   <context:annotation-config/>
   <!-- 2, 设定Spring去那些包中找annotation -->
   <context:component-scan base-package="com.yangw.spring" />
    
   <!--
           使用dbcp没有成功, 加的是commons-dbcp-1.4.jar 
        class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    -->
   <bean id="dataSource"
            
               class="org.springframework.jdbc.datasource.DriverManagerDataSource" >
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
     
    <context:property-placeholder location="jdbc.properties"/> 
    
    <!--创建sessionFactory -->
  <bean id="sessionFactory" 
        class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean" >
       <!-- class="org.springframework.orm.hibernate3.LocalSessionFactoryBean" -->
    <property name="dataSource" ref="dataSource"/>
    <!--  基于XML配置文件的形式
    <property name="mappingResources">
      <list>
        <value>product.hbm.xml</value>
      </list>
    </property>
    -->
    <!-- 自动去包中找hbm文件或者设置了annotation的类-->
    <property name="packagesToScan" value="com.yangw.spring.model" />
    <!-- 将hibernate配置文件放到单独的配置文件中的方式-->
    <!-- 
    <property name="configLocation" value="classpath:hibernate.cfg.xml" />
    -->
    <property name="hibernateProperties">
      <value>
        hibernate.dialect=org.hibernate.dialect.MySQLDialect
        hibernate.show_sql=true
        hibernate.hbm2ddl.auto=update
        hibernate.format_sql=false
      </value>
    </property>
  </bean>
    <!-- 配置Spring事务处理 -->
    <!-- 1,创建事务管理器 -->
      <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    <!-- 2, 配置AOP，Spring是通过AOP进行事务管理的-->
   <aop:config>
       <!-- 设置PointCut表示哪些方法要加入事务-->
    <aop:pointcut id="allMethods"
            expression="execution(* com.yangw.spring.dao.*.*(..))"/>
    <!-- 通过advisor来确定具体加入事务控制的方法 -->
    <aop:advisor advice-ref="txAdvice" pointcut-ref="allMethods"/>
  </aop:config>
    <!--3, 配置哪些方法要加入事务 -->
 
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="get*" read-only="true" />
            <tx:method name="count*" read-only="true" />
            <tx:method name="is*" read-only="true" />
            <tx:method name="has*" read-only="true" />
            <!-- 所有方法都加入事务 -->
            <tx:method name="*"  />
        </tx:attributes>
    </tx:advice>
</beans>

package com.yangw.spring.dao;

import javax.annotation.Resource;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

public class BaseDao {

    @Resource
    private SessionFactory sessionFactory;
    
    protected Session getSession(){
        /*如果通过Spring来管理SessionFactory，不再使用openSession()方法，
         *而是使用getCurrentSession()方法来打开一个session，这个session就会被spring所管理，
         *此时开发人员不用进行事务控制，也不用关闭session，全部由Spring来完成
         */
        return sessionFactory.getCurrentSession();
    }

    public SessionFactory getSessionFactory() {
        return sessionFactory;
    }

}

package com.yangw.spring.dao;

import java.util.List;

import com.yangw.spring.model.User;

public interface IUserDao {

    public void addUser(User user);
    
    public void delUser(int id);
    
    public User loadUser(int id);
    
    public List<User> loadAllUser();
}

package com.yangw.spring.dao;

import java.util.List;

import org.springframework.stereotype.Repository;

import com.yangw.spring.model.User;

@Repository("userHibernateDao")
public class UserDao extends BaseDao implements IUserDao {

    @Override
    public void addUser(User user) {
        
        getSession().save(user);
    }

    @Override
    public void delUser(int id) {
        // TODO Auto-generated method stub
        
    }

    @Override
    public User loadUser(int id) {
        // load()方法时，有错误，因为懒加载
        return (User) getSession().get(User.class, id);
        
    }

    @Override
    public List<User> loadAllUser() {
        // TODO Auto-generated method stub
        return null;
    }

}

package com.yangw.spring.test;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.yangw.spring.dao.IUserDao;
import com.yangw.spring.model.User;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/beans.xml")
/**
 * 当使用了@RunWith,@ContextConfiguration注解之后，就可以直接在Test中进行依赖注入
 * @author Administrator
 */
public class TestHibernate {
    
    @Resource
    private IUserDao userHibernateDao;
   
    @Test
    public void testAdd(){
        
       User user=new User();
       user.setName("wangwu");
       user.setAge(21);
       userHibernateDao.addUser(user);
    }
    
    @Test
    public void testLoad(){
        
   
      User user = userHibernateDao.loadUser(4);
      System.out.println(user);
    }


}

 3， 使用HibernateTemplate进行操作

   在配置文件中，再注入HibernateTemplate

  <!-- 使用HibernateTemplate进行操作时需要-->
  <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
      <property name="sessionFactory" ref="sessionFactory"></property>
  </bean>

package com.yangw.spring.dao;

import javax.annotation.Resource;

import org.springframework.orm.hibernate3.HibernateTemplate;

public class BaseDao1 {

    @Resource
    private HibernateTemplate hibernateTemplate;

    public HibernateTemplate getHibernateTemplate() {
        return hibernateTemplate;
    }

    public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
        this.hibernateTemplate = hibernateTemplate;
    }
    
}

package com.yangw.spring.dao;

import java.util.List;

import org.springframework.stereotype.Repository;

import com.yangw.spring.model.User;

@Repository("userHibernateDao1")
public class UserDao1 extends BaseDao1 implements IUserDao {

    @Override
    public void addUser(User user) {
        
        getHibernateTemplate().save(user);
    }

    @Override
    public void delUser(int id) {
        User user=this.loadUser(id);
        getHibernateTemplate().delete(user);
    }

    @Override
    public User loadUser(int id) {
        return (User) getHibernateTemplate().get(User.class, id);
        
    }

    @SuppressWarnings("unchecked")
    @Override
    public List<User> loadAllUser() {
        String hql="select * from User";
        return (List<User>) getHibernateTemplate().getSessionFactory().getCurrentSession().createQuery(hql);
    }
}

package com.yangw.spring.test;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.yangw.spring.dao.IUserDao;
import com.yangw.spring.model.User;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/beans.xml")
/**
 * 当使用了@RunWith,@ContextConfiguration注解之后，就可以直接在Test中进行依赖注入
 * @author Administrator
 */
public class TestHibernate {
    
    @Resource
    private IUserDao userHibernateDao1;
   
    @Test
    public void testAdd(){
        
       User user=new User();
       user.setName("wangwu");
       user.setAge(21);
       userHibernateDao1.addUser(user);
    }
    
    @Test
    public void testLoad(){
        
   
      User user = userHibernateDao1.loadUser(4);
      System.out.println(user);
    }


}

 3， 使用HibernateDaoSupport类

package com.yangw.spring.dao;

import javax.annotation.Resource;

import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public class BaseDao2 extends HibernateDaoSupport{

    //注入SessionFactory
    @Resource(name="sessionFactory")
    public void setSuperSessionFactory(SessionFactory sessionFactory){
        super.setSessionFactory(sessionFactory);
    }
    
}

有了HibernateDaoSupport，就可以使用HibernateTemplate了

package com.yangw.spring.dao;

import java.util.List;

import org.springframework.stereotype.Repository;

import com.yangw.spring.model.User;

@Repository("userHibernateDao2")
public class UserDao2 extends BaseDao2 implements IUserDao {

    @Override
    public void addUser(User user) {
        
        getHibernateTemplate().save(user);
    }

    @Override
    public void delUser(int id) {
        User user=this.loadUser(id);
        getHibernateTemplate().delete(user);
    }

    @Override
    public User loadUser(int id) {
        // load()方法时，有错误，因为懒加载
        return (User) getHibernateTemplate().get(User.class, id);
        
    }

    @SuppressWarnings("unchecked")
    @Override
    public List<User> loadAllUser() {
        String hql="select * from User";
        return (List<User>) getHibernateTemplate().getSessionFactory().getCurrentSession().createQuery(hql);
    }



}

测试就不写了