Spring和Hibernate的整合操作示例

<?xml version="1.0" encoding="gbk"?>
<web-app xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
  xmlns="http://xmlns.jcp.org/xml/ns/javaee"
  xsi:schemalocation="http://xmlns.jcp.org/xml/ns/javaee
  http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
  version="3.1">
  <listener>
    <listener-class>org.springframework.web.context.contextloaderlistener
    </listener-class>
  </listener>
  <filter>
    <filter-name>struts2</filter-name>
    <filter-class>org.apache.struts2.dispatcher.ng.filter.strutsprepareandexecutefilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
</web-app>

<?xml version="1.0" encoding="gbk"?>
<beans xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
  xmlns="http://www.springframework.org/schema/beans"
  xmlns:p="http://www.springframework.org/schema/p"
  xmlns:tx="http://www.springframework.org/schema/tx"
  xmlns:aop="http://www.springframework.org/schema/aop"
  xsi:schemalocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
  http://www.springframework.org/schema/tx
  http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">
  <!-- 定义数据源bean，使用c3p0数据源实现，并注入数据源的必要信息 -->
  <bean id="datasource" class="com.mchange.v2.c3p0.combopooleddatasource"
    destroy-method="close"
    p:driverclass="com.mysql.jdbc.driver"
    p:jdbcurl="jdbc:mysql://localhost/spring"
    p:user="root"
    p:password="32147"
    p:maxpoolsize="40"
    p:minpoolsize="2"
    p:initialpoolsize="2"
    p:maxidletime="30"/>
  <!-- 定义hibernate的sessionfactory，sessionfactory需要依赖数据源，注入datasource -->
  <bean id="sessionfactory"
    class="org.springframework.orm.hibernate4.localsessionfactorybean"
    p:datasource-ref="datasource">
    <!-- mappingresources用来列出全部映射文件 -->
    <property name="annotatedclasses">
      <list>
        <!-- 以下用来列出所有的po类-->
        <value>org.crazyit.booksys.domain.book</value>
      </list>
    </property>
    <!-- 定义hibernate sessionfactory的属性 -->
    <property name="hibernateproperties">
      <props>
        <!-- 指定hibernate的连接方言 -->
        <prop key="hibernate.dialect">
          org.hibernate.dialect.mysql5innodbdialect</prop>
        <!--是否根据hiberante映射创建数据表 -->
        <prop key="hibernate.hbm2ddl.auto">update</prop>
        <prop key="hibernate.show_sql">true</prop>
        <prop key="hibernate.format_sql">true</prop>
      </props>
    </property>
  </bean>
  <!-- 定义service组件，并将dao组件注入service组件 -->
  <bean id="bookservice" class="org.crazyit.booksys.service.impl.bookserviceimpl"
    p:bookdao-ref="bookdao"/>
  <!-- 定义dao组件，并将sessionfactory注入dao组件 -->
  <bean id="bookdao" class="org.crazyit.booksys.dao.impl.bookdaohibernate4"
    p:sessionfactory-ref="sessionfactory"/>
  <!-- 配置hibernate的局部事务管理器，使用hibernatetransactionmanager类 -->
  <!-- 该类是platformtransactionmanager接口针对采用hibernate的特定实现类 -->
  <!-- 配置hibernatetransactionmanager需依赖注入sessionfactory -->
  <bean id="transactionmanager"
    class="org.springframework.orm.hibernate4.hibernatetransactionmanager"
    p:sessionfactory-ref="sessionfactory"/>
<!-- 配置事务增强处理bean,指定事务管理器 -->
<tx:advice id="txadvice"
  transaction-manager="transactionmanager">
  <!-- 用于配置详细的事务定义 -->
  <tx:attributes>
    <!-- 所有以'get'开头的方法是read-only的 -->
    <tx:method name="get*" read-only="true"/>
    <!-- 其他方法使用默认的事务设置，指定超时时长为5秒 -->
    <tx:method name="*" isolation="default"
      propagation="required" timeout="5"/>
  </tx:attributes>
</tx:advice>
<!-- aop配置的元素 -->
<aop:config>
  <!-- 配置一个切入点 -->
  <aop:pointcut id="mypointcut" expression="bean(bookservice)"/>
  <!-- 指定在mypointcut切入点应用txadvice事务增强处理 -->
  <aop:advisor advice-ref="txadvice"
    pointcut-ref="mypointcut"/>
</aop:config>
</beans>

<?xml version="1.0" encoding="gbk"?>
<!-- 指定struts 2配置文件的dtd信息 -->
<!doctype struts public
  "-//apache software foundation//dtd struts configuration 2.3//en"
  "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
  <!-- 配置了系列常量 -->
  <constant name="struts.i18n.encoding" value="gbk"/>
  <constant name="struts.enable.dynamicmethodinvocation" value="false" />
  <constant name="struts.devmode" value="true"/>
  <package name="lee" extends="struts-default">
    <action name="addbook" class="org.crazyit.booksys.action.bookaction"
      method="add">
      <!-- 添加图书成功，列出所有图书 -->
      <result type="chain">listbooks</result>
      <!-- 添加图书失败，跳转到添加图书的表单页 -->
      <result name="error">/web-inf/content/bookform.jsp</result>
    </action>
    <action name="listbooks" class="org.crazyit.booksys.action.bookaction"
      method="list">
      <result>/web-inf/content/listbooks.jsp</result>
    </action>
    <action name="deletebook" class="org.crazyit.booksys.action.bookaction"
      method="delete">
      <result type="chain">listbooks</result>
    </action>
    <!-- 让用户直接访问该应用时列出所有视图页面 -->
    <action name="*">
      <result>/web-inf/content/{1}.jsp</result>
    </action>
  </package>
</struts>

<%@ page contenttype="text/html; charset=gbk" language="java" errorpage="" %>
<%@taglib prefix="s" uri="/struts-tags"%>
<!doctype html public "-//w3c//dtd xhtml 1.0 transitional//en"
  "http://www.w3.org/tr/xhtml1/dtd/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <title>添加图书</title>
</head>
<body>
<h3>添加图书</h3>
<s:form action="addbook">
  <s:textfield name="book.name" label="书名"/>
  <s:textfield name="book.price" label="价格"/>
  <s:textfield name="book.author" label="作者"/>
  <tr align="center">
    <td colspan="2">
    <s:submit value="添加" theme="simple"/>
    <s:reset value="重设" theme="simple"/>
    </td>
  </tr>
</s:form>
</body>
</html>

<%@ page contenttype="text/html; charset=gbk" language="java" errorpage="" %>
<%@taglib prefix="s" uri="/struts-tags"%>
<!doctype html public "-//w3c//dtd xhtml 1.0 transitional//en"
  "http://www.w3.org/tr/xhtml1/dtd/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <title>全部图书</title>
</head>
<body>
<h3>全部图书</h3>
<table width="640" border="1">
  <s:iterator value="books" var="b">
    <tr>
      <td><s:property value="name"/></td>
      <td><s:property value="price"/></td>
      <td><s:property value="author"/></td>
      <td><a href="${pagecontext.request.contextpath}/deletebook?id=${b.id}" rel="external nofollow" >删除</a></td>
    </tr>
  </s:iterator>
</table>
</body>
</html>

package org.crazyit.booksys.domain;
import javax.persistence.*;
@entity
@table(name="book_inf")
public class book
{
  @id @column(name="book_id")
  @generatedvalue(strategy=generationtype.identity)
  private integer id;
  @column(name="book_name")
  private string name;
  private double price;
  private string author;
  public integer getid()
  {
    return id;
  }
  public void setid(integer id)
  {
    this.id = id;
  }
  public string getname()
  {
    return name;
  }
  public void setname(string name)
  {
    this.name = name;
  }
  public double getprice()
  {
    return price;
  }
  public void setprice(double price)
  {
    this.price = price;
  }
  public string getauthor()
  {
    return author;
  }
  public void setauthor(string author)
  {
    this.author = author;
  }
}

package org.crazyit.booksys.action;
import java.util.list;
import org.crazyit.booksys.domain.book;
import org.crazyit.booksys.service.bookservice;
import com.opensymphony.xwork2.actionsupport;
public class bookaction extends actionsupport
{
  private bookservice bookservice;
  // 依赖注入bookservice组件必须的setter方法。
  // 该方法的方法名要与bookservice的配置id对应
  public void setbookservice(bookservice bookservice)
  {
    this.bookservice = bookservice;
  }
  private book book;
  private list<book> books;
  private int id;
  public book getbook()
  {
    return book;
  }
  public void setbook(book book)
  {
    this.book = book;
  }
  public list<book> getbooks()
  {
    return books;
  }
  public void setbooks(list<book> books)
  {
    this.books = books;
  }
  public int getid()
  {
    return id;
  }
  public void setid(int id)
  {
    this.id = id;
  }
  // 处理添加图书的add()方法
  public string add()
  {
    // 调用业务逻辑组件的addbook()方法来处理用户请求
    int result = bookservice.addbook(book);
    if(result > 0)
    {
      addactionmessage("恭喜您，图书添加成功！");
      return success;
    }
    addactionerror("图书添加失败，请重新输入！");
    return error;
  }
  public string list()
  {
    setbooks(bookservice.getallbooks());
    return success;
  }
  public string delete()
  {
    bookservice.deletebook(id);
    return success;
  }
}

package org.crazyit.booksys.service;
import java.util.list;
import org.crazyit.booksys.domain.book;
public interface bookservice
{
  // 添加图书
  int addbook(book book);
  list<book> getallbooks();
  void deletebook(int id);
}

package org.crazyit.booksys.service.impl;
import java.util.list;
import org.crazyit.booksys.dao.bookdao;
import org.crazyit.booksys.domain.book;
import org.crazyit.booksys.service.bookservice;
public class bookserviceimpl implements bookservice
{
  private bookdao bookdao;
  public void setbookdao(bookdao bookdao)
  {
    this.bookdao = bookdao;
  }
  @override
  public int addbook(book book)
  {
    return (integer) bookdao.save(book);
  }
  @override
  public list<book> getallbooks()
  {
    return bookdao.findall(book.class);
  }
  @override
  public void deletebook(int id)
  {
    bookdao.delete(book.class, id);
  }
}

package org.crazyit.common.dao;
import java.util.list;
import java.io.serializable;
public interface basedao<t>
{
  // 根据id加载实体
  t get(class<t> entityclazz , serializable id);
  // 保存实体
  serializable save(t entity);
  // 更新实体
  void update(t entity);
  // 删除实体
  void delete(t entity);
  // 根据id删除实体
  void delete(class<t> entityclazz , serializable id);
  // 获取所有实体
  list<t> findall(class<t> entityclazz);
  // 获取实体总数
  long findcount(class<t> entityclazz);
}

package org.crazyit.common.dao.impl;
import java.io.serializable;
import java.util.list;
import org.crazyit.common.dao.basedao;
import org.hibernate.*;
import org.springframework.orm.hibernate4.support.hibernatedaosupport;
import org.springframework.orm.hibernate4.hibernatecallback;
public class basedaohibernate3<t> extends hibernatedaosupport
  implements basedao<t>
{
  // 根据id加载实体
  public t get(class<t> entityclazz, serializable id)
  {
    return gethibernatetemplate().get(entityclazz, id);
  }
  // 保存实体
  public serializable save(t entity)
  {
    return gethibernatetemplate().save(entity);
  }
  // 更新实体
  public void update(t entity)
  {
    gethibernatetemplate().saveorupdate(entity);
  }
  // 删除实体
  public void delete(t entity)
  {
    gethibernatetemplate().delete(entity);
  }
  // 根据id删除实体
  public void delete(class<t> entityclazz, serializable id)
  {
    delete(get(entityclazz , id));
  }
  @override
  @suppresswarnings("unchecked")
  public list<t> findall(class<t> entityclazz)
  {
    return (list<t>)gethibernatetemplate().find("select en from "
      + entityclazz.getsimplename() + " en");
  }
  @override
  @suppresswarnings("unchecked")
  public long findcount(class<t> entityclazz)
  {
    list<long> list = (list<long>)gethibernatetemplate().find(
      "select count(*) from " + entityclazz.getsimplename() + " en");
    return list.get(0);
  }
  /**
   * 使用hql 语句进行分页查询操作
   * @param hql 需要查询的hql语句
   * @param pageno 查询第pageno页的记录
   * @param pagesize 每页需要显示的记录数
   * @return 当前页的所有记录
   */
  @suppresswarnings("unchecked")
  protected list<t> findbypage(final string hql,
    final int pageno, final int pagesize)
  {
    // 通过一个hibernatecallback对象来执行查询
    list<t> list = gethibernatetemplate()
      .execute(new hibernatecallback<list<t>>()
    {
      // 实现hibernatecallback接口必须实现的方法
      public list<t> doinhibernate(session session)
      {
        // 执行hibernate分页查询
        list<t> result = session.createquery(hql)
          .setfirstresult((pageno - 1) * pagesize)
          .setmaxresults(pagesize)
          .list();
        return result;
      }
    });
    return list;
  }
  /**
   * 使用hql 语句进行分页查询操作
   * @param hql 需要查询的hql语句
   * @param pageno 查询第pageno页的记录
   * @param pagesize 每页需要显示的记录数
   * @param params 如果hql带占位符参数，params用于传入占位符参数
   * @return 当前页的所有记录
   */
  @suppresswarnings("unchecked")
  protected list<t> findbypage(final string hql , final int pageno,
    final int pagesize , final object... params)
  {
    // 通过一个hibernatecallback对象来执行查询
    list<t> list = gethibernatetemplate()
      .execute(new hibernatecallback<list<t>>()
    {
      // 实现hibernatecallback接口必须实现的方法
      public list<t> doinhibernate(session session)
      {
        // 执行hibernate分页查询
        query query = session.createquery(hql);
        // 为包含占位符的hql语句设置参数
        for(int i = 0 , len = params.length ; i < len ; i++)
        {
          query.setparameter(i + "" , params[i]);
        }
        list<t> result = query.setfirstresult((pageno - 1) * pagesize)
          .setmaxresults(pagesize)
          .list();
        return result;
      }
    });
    return list;
  }
}

package org.crazyit.common.dao.impl;
import org.hibernate.*;
import java.util.list;
import java.io.serializable;
import org.crazyit.common.dao.*;
public class basedaohibernate4<t> implements basedao<t>
{
  // dao组件进行持久化操作底层依赖的sessionfactory组件
  private sessionfactory sessionfactory;
  // 依赖注入sessionfactory所需的setter方法
  public void setsessionfactory(sessionfactory sessionfactory)
  {
    this.sessionfactory = sessionfactory;
  }
  public sessionfactory getsessionfactory()
  {
    return this.sessionfactory;
  }
  // 根据id加载实体
  @suppresswarnings("unchecked")
  public t get(class<t> entityclazz , serializable id)
  {
    return (t)getsessionfactory().getcurrentsession()
      .get(entityclazz , id);
  }
  // 保存实体
  public serializable save(t entity)
  {
    return getsessionfactory().getcurrentsession()
      .save(entity);
  }
  // 更新实体
  public void update(t entity)
  {
    getsessionfactory().getcurrentsession().saveorupdate(entity);
  }
  // 删除实体
  public void delete(t entity)
  {
    getsessionfactory().getcurrentsession().delete(entity);
  }
  // 根据id删除实体
  public void delete(class<t> entityclazz , serializable id)
  {
    getsessionfactory().getcurrentsession()
      .createquery("delete " + entityclazz.getsimplename()
        + " en where en.id = ?0")
      .setparameter("0" , id)
      .executeupdate();
  }
  // 获取所有实体
  public list<t> findall(class<t> entityclazz)
  {
    return find("select en from "
      + entityclazz.getsimplename() + " en");
  }
  // 获取实体总数
  public long findcount(class<t> entityclazz)
  {
    list<?> l = find("select count(*) from "
      + entityclazz.getsimplename());
    // 返回查询得到的实体总数
    if (l != null && l.size() == 1 )
    {
      return (long)l.get(0);
    }
    return 0;
  }
  // 根据hql语句查询实体
  @suppresswarnings("unchecked")
  protected list<t> find(string hql)
  {
    return (list<t>)getsessionfactory().getcurrentsession()
      .createquery(hql)
      .list();
  }
  // 根据带占位符参数hql语句查询实体
  @suppresswarnings("unchecked")
  protected list<t> find(string hql , object... params)
  {
    // 创建查询
    query query = getsessionfactory().getcurrentsession()
      .createquery(hql);
    // 为包含占位符的hql语句设置参数
    for(int i = 0 , len = params.length ; i < len ; i++)
    {
      query.setparameter(i + "" , params[i]);
    }
    return (list<t>)query.list();
  }
  /**
   * 使用hql 语句进行分页查询操作
   * @param hql 需要查询的hql语句
   * @param pageno 查询第pageno页的记录
   * @param pagesize 每页需要显示的记录数
   * @return 当前页的所有记录
   */
  @suppresswarnings("unchecked")
  protected list<t> findbypage(string hql,
     int pageno, int pagesize)
  {
    // 创建查询
    return getsessionfactory().getcurrentsession()
      .createquery(hql)
      // 执行分页
      .setfirstresult((pageno - 1) * pagesize)
      .setmaxresults(pagesize)
      .list();
  }
  /**
   * 使用hql 语句进行分页查询操作
   * @param hql 需要查询的hql语句
   * @param params 如果hql带占位符参数，params用于传入占位符参数
   * @param pageno 查询第pageno页的记录
   * @param pagesize 每页需要显示的记录数
   * @return 当前页的所有记录
   */
  @suppresswarnings("unchecked")
  protected list<t> findbypage(string hql , int pageno, int pagesize
    , object... params)
  {
    // 创建查询
    query query = getsessionfactory().getcurrentsession()
      .createquery(hql);
    // 为包含占位符的hql语句设置参数
    for(int i = 0 , len = params.length ; i < len ; i++)
    {
      query.setparameter(i + "" , params[i]);
    }
    // 执行分页，并返回查询结果
    return query.setfirstresult((pageno - 1) * pagesize)
      .setmaxresults(pagesize)
      .list();
  }
}

package org.crazyit.booksys.dao;
import java.util.list;
import org.crazyit.booksys.domain.book;
import org.crazyit.common.dao.basedao;
public interface bookdao extends basedao<book>
{
}

package org.crazyit.booksys.dao.impl;
import java.util.list;
import org.crazyit.booksys.dao.bookdao;
import org.crazyit.booksys.domain.book;
import org.crazyit.common.dao.impl.basedaohibernate3;
import org.crazyit.common.dao.impl.basedaohibernate4;
public class bookdaohibernate4 extends basedaohibernate4<book>
  implements bookdao
{
}