(4) hibernate增删查改+批量操作+类似Mybatis动态sql

 简介

采用spring + hibernate + freemaker+ maven搭建起来的一个hibernate增删查改和

类似mybatis动态sql查询的一个案例

 增删查改demo + 动态sql 

 数据库表(只有一张USER表)

动态sql的xml (test-dynamicHibernateSql.xml )

<?xml version="1.0" encoding="utf-8"?>
<!-- 
<!DOCTYPE dynamic-hibernate-statement SYSTEM "http://localhost:8080/dynamic-hibernate-statement-1.0.dtd"> 
 -->
<!-- 这里采用了freemarker技术,赋值，集合，大小比较,if else都要遵守freemarker语法 -->
<dynamic-hibernate-statement>
	<sql-query name="user.findByAge">  
	    <![CDATA[ 
	        select age from user where 1=1
	        <#if (age>20) > 
	           and age > 20
	        <#else> 
	           and age < 20
	        </#if> 
	    ]]>
    </sql-query>
    
    
    <sql-query name="user.findByName">  
	    <![CDATA[ 
	       SELECT age FROM USER WHERE NAME LIKE '${name}%' AND age > ${age}
	     ]]>
    </sql-query>
    
     <sql-query name="user.findByName2">  
	    <![CDATA[ 
	       SELECT name,birthday,age,address   FROM USER WHERE NAME LIKE '${name}%' AND age > ${age}
	     ]]>
    </sql-query>
    
    <sql-query name="user.findByName3">  
	    <![CDATA[ 
	       SELECT name FROM USER WHERE NAME LIKE '${name}%' AND age > ${age}
	     ]]>
    </sql-query>
    
    <hql-query name="user.findByName4">  
	    <![CDATA[ 
	       SELECT u.name FROM User u WHERE u.name LIKE '${name}%' AND u.age > ${age}
	     ]]>
    </hql-query>
    
  
</dynamic-hibernate-statement>

 user的映射xml文件 ( User.hbm.xml )

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 <hibernate-mapping>
 	<class table="user" name="com.business.entity.User" >
 		<id column="id" name="id"  type="java.lang.Integer">
 		 	<generator class="native"/>
 		</id>
 		<property column="name" name="name"  type="java.lang.String" />
 		<property column="address" name="address"  type="java.lang.String" />
 		<property column="age" name="age"  type="java.lang.Integer" />
 		<property column="birthday" name="birthday"  type="java.util.Date" />
 	</class>
 </hibernate-mapping>

 junit测试增删查改和动态sql (TestUserService.java )

package test;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.business.entity.User;
import com.business.service.UserService;
import com.business.service.impl.UserServiceImpl;
import com.system.hibernate.StatementTemplate;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:applicationContext.xml"})  
public class TestUserService {

	@Resource(name="userService")
	private UserServiceImpl userService;
	
	/**
	 * 保存单个用户方法
	 * */
	@Test
	public void testSave(){
		User u = new User("zhangsan",new Date() );
		this.userService.save(u);
	}
	
	/**
	 * 批量保存多个用户方法
	 * */
	@Test
	public void testSaveAll(){
		List list = new ArrayList();
		for(int i = 0 ; i < 20000 ; i++){
			User user = new User("zhansan"+i,new Date());
			list.add(user);
		}
		this.userService.saveAll(list);
	}
	
	/**
	 * 根据多个id查询
	 * */
	@Test
	public void testGetByIds(){
		List idsList = new ArrayList();
		for(int i = 0 ; i < 100 ; i++){
			idsList.add(39100+i);
		}
		List<User> userList = this.userService.get(User.class, idsList);
		for(int i = 0 ; i < userList.size() ; i++){
			System.out.println(" i =  "+i+"  user name = " + userList.get(i).getName()  );
		}
		
	}
	
	/**
	 * 取得对象的主键名.
	 */
	@Test
	public void testGetIdName() {
		String idName = this.userService.getIdName(User.class);
		System.out.println("idName = " + idName);
	}
	
	
	/**
	 * 删除所有对象
	 * */
	@Test
	public void testDeleteAll() {
		List idsList = new ArrayList();
		for(int i = 0 ; i < 100 ; i++){
			idsList.add(29100+i);
		}
		List<User> userList = this.userService.get(User.class, idsList);
		this.userService.deleteAll(userList);
	}
	
	
	
	/**
	 * 更新对象
	 * */
	@Test
	public void testUpdate() {
		int id = 39100;
		User user = (User) this.userService.get(User.class,id);
		user.setName("update name");
		this.userService.update(user);
	}
	
	/**
	 * 根据id查询
	 * */
	@Test
	public void testGetById() {
		int id = 39100;
		User user = (User) this.userService.get(User.class,id);
		System.out.println("name = " + user.getName() );
	}
	
	/**
	 * 更新所有对象
	 * */
	@Test
	public void testUpdateAll(){
		List ids = new ArrayList();
		ids.add(1);ids.add(2);ids.add(3);ids.add(4);ids.add(5);
		ids.add(39101);ids.add(7);ids.add(39300);ids.add(1);ids.add(39400);
		List<User> userList = (List<User>) this.userService.get(User.class, ids);
		for(int i = 0 ; i < userList.size() ;i ++ ){
			User user = userList.get(i);
			user.setName("update username"+i );
		}
		this.userService.updateAll(userList);
	}
	
	/**
	 * 保存或更新
	 * */
	@Test
	public void testSaveOrUpdate(){
		User u = new User("zhangsan2",new Date() );
		u.setId(1);
		this.userService.saveOrUpdate(u);
	}
	
	
	/**
	 * 保存或更新所有实体
	 * */
	@Test
	public void testSaveOrUpdateAll(){
		List ids = new ArrayList();
		ids.add(1);ids.add(2);ids.add(3);ids.add(4);ids.add(5);
		ids.add(39101);ids.add(7);ids.add(39300);ids.add(1);ids.add(39400);
		List<User> userList = (List<User>) this.userService.get(User.class, ids);
		User newUser = new User("saveOrdate new user",new Date());
		for(int i = 0 ; i < userList.size() ; i++){
			 User user = userList.get(i);
			 user.setName("saveOrUpdateAll name"+i);
		}
		userList.add(newUser);
		this.userService.saveOrUpdateAll(userList);
	}
	
	/**
	 * 根据原生sql语句进行查询,返回对象集合 
	 * String sql 原生sql语句
	 * String[] fields 必需为对象字段属性 
	 * 例子: Sql : select username as name ,userage as age from user;
	 * User : private String name , private int age 
	 * clazz = User.class 
	 * fields ={ "name","age" }; //注意 sql和fields必需一致,并且fields为User的字段属性 
	 * 返回格式 list = { user1,user2,user3... }
	 * 
	 * */
	@Test
	public void testFindBySql1() {
		String sql = "SELECT name,birthday,age,address FROM USER WHERE NAME LIKE 'zhansan100%'";
		String[] fields = { "name","birthday","age","address" };
		List<Map<String, Object>> list = this.userService.findBySql(sql, fields);
		if(list!=null&&list.size()>0){
			for(int i = 0 ; i < list.size() ; i++ ){
				Map map = list.get(i);
				System.out.println(
						"name = " + map.get("name") 
					+ "  birthday = " + map.get("birthday") 
					+ "  age = " + map.get("age") 
					+ "  address = " + map.get("address")
				);
			}
		}
	}
	
	/**
	 * 根据原生sql语句进行查询,返回对象集合 
	 * String sql 原生sql语句
	 *  Class clazz 为类 String[] fields
	 * 必需为对象字段属性 
	 * 例子: Sql : select username as name ,userage as age from user;
	 * User : private String name , private int age 
	 * clazz = User.class 
	 * fields ={ "name","age" }; //注意 sql和fields必需一致,并且fields为User的字段属性 
	 * 返回格式 list = { user1,user2,user3... }
	 * 
	 * */
	@Test
	public void testFindBySql2() {
		String sql = "SELECT name,birthday,age,address FROM USER WHERE NAME LIKE 'zhansan100%'";
		String[] fields = { "name","birthday","age","address" };
		List<User> list = this.userService.findBySql(sql,User.class, fields);
		if(list!=null&&list.size()>0){
			for(int i = 0 ; i < list.size() ; i++ ){
				User user = list.get(i);
				System.out.println(
						"name = " + user.getName()
					+ "  birthday = " + user.getBirthday()
					+ "  age = " + user.getAge()
					+ "  address = " + user.getAddress()
				);
			}
		}
	}
	
	/**
	 * 根据hql查询
	 * */
	@Test
	public void testFindByHql1() {
		String hql = " from User u where u.name like 'zhansan100%' ";
		List<User> userList = this.userService.findByHql(hql);
		if( userList!=null && userList.size()>0 ){
			for(int i = 0 ; i < userList.size() ; i++){
				User user = userList.get(i);
				System.out.println(
						"name = " + user.getName()
					+ "  birthday = " + user.getBirthday()
					+ "  age = " + user.getAge()
					+ "  address = " + user.getAddress()
				);
			}
		}
	}
	
	/**
	 * 根据id查询
	 * */
	@Test
	public void testLoadById() {
		int id = 22114;
		User user = (User) this.userService.load(User.class, id);
		if(user==null) return ;
		System.out.println(
				"name = " + user.getName()
			+ "  birthday = " + user.getBirthday()
			+ "  age = " + user.getAge()
			+ "  address = " + user.getAddress()
		);
	}
	
	/**
	 * 根据Id更新对象指定的属性
	 * */
	@Test
	public void testUpdateOneByProperty1() {
		int id = 22114;
		List<String> pName =  new ArrayList<String>();
		List pValue = new ArrayList();
		pName.add("name");pValue.add("zhangsan7259");
		pName.add("age");pValue.add(1);
		this.userService.updateOneByPropertys(User.class, id, pName, pValue);
	}
	
	/**
	 * 根据id更新多个属性
	 * */
	@Test
	public void testUpdateOneByPropertys2() {
		int id = 39300;
		Map map = new HashMap();
		map.put("name", "zhangsan222");
		map.put("age", 1 );
		this.userService.updateOneByPropertys(User.class, id, map);
		
	}
	
	/**
	 * 动态命名查询,返回对象集合 
	 * 返回格式
	 * map1 = { name=zhangsan,age=1 }, map2 = { name=zhangsan2,age=2 }, map3 = { name=zhangsan3,age=3 }
	 * list = {map1,map2,map3}
	 * 
	 * */
	@Test
	public void testFindByNamedQuery1() {
		String queryName = "user.findByAge";
		String[] fields = {"age"};
		Map pramMap = new HashMap();
		pramMap.put("age", 50);
		List<Map<String, Object>>  list = this.userService.findByNamedQuery(queryName, fields, pramMap);
		if(list==null||list.size()==0) return ;
		for(int i = 0 ; i < list.size() ; i++){
			 Map map = list.get(i);
			 System.out.println( " i = "+i+"  age = " + map.get("age") );
		}
	}
	
	/**
	 * 动态命名查询,返回对象集合 
	 * 返回格式
	 * map1 = { name=zhangsan,age=1 }, map2 = { name=zhangsan2,age=2 }, map3 = { name=zhangsan3,age=3 }
	 * list = {map1,map2,map3}
	 * 
	 * */
	@Test
	public void testFindByNamedQuery2() {
		String queryName = "user.findByName";
		String[] fields = {"age","name"};
		Map pramMap = new HashMap();
		pramMap.put("age", 50);
		pramMap.put("name", "zhansan");
		List<Map<String, Object>>  list = this.userService.findByNamedQuery(queryName, fields, pramMap);
		if(list==null||list.size()==0) return ;
		for(int i = 0 ; i < list.size() ; i++){
			 Map map = list.get(i);
			 System.out.println( " i = "+i+"  age = " + map.get("age") );
		}
	}
	/**
	 * 动态命名查询,返回对象集合 
	 * 返回格式
	 * list = {user1,user2,user3}
	 * 
	 * */
	@Test
	public void testFindByNamedQuery3() {
		String queryName = "user.findByName2";
		String[] fields = {"name","birthday","age","address"};
		Map pramMap = new HashMap();
		pramMap.put("age", 50);
		pramMap.put("name", "zhansan");
		List<Object>  list = this.userService.findByNamedQuery(queryName, User.class,fields, pramMap);
		if(list==null||list.size()==0) return ;
		for(int i = 0 ; i < list.size() ; i++){
			 User user = (User) list.get(i);
			 System.out.println(
						"name = " + user.getName()
					+ "  birthday = " + user.getBirthday()
					+ "  age = " + user.getAge()
					+ "  address = " + user.getAddress()
				);
		}
	}
	
	@Test
	public void testFindByNamedQuery4() {
		String queryName = "user.findByName3";
		String[] fields = {"name"};
		Map pramMap = new HashMap();
		pramMap.put("age", 50);
		pramMap.put("name", "zhansan");
		List<Object>  list = this.userService.findByNamedQuery(queryName, User.class,fields, pramMap);
		if(list==null||list.size()==0) return ;
		for(int i = 0 ; i < list.size() ; i++){
			 User user = (User) list.get(i);
			 System.out.println( "  name = " + user.getName());
		}
	}
	
	
	
	/**
	 * 动态命名查询,返回对象集合 
	 * final String queryName hql命名查询
	 * Class clazz 为类对象
	 * String[] fields  必需为查询字段
	 * Map<String, ?> parameters 为参数{name=zhangsan,age=3}
	 * 例子: queryName : select username as name ,userage as age from user;
	 * User : private String name , private int age 
	 * clazz = User.class 
	 * fields ={ "name","age" }; //注意 sql和fields必需一致,并且fields为User的字段属性 
	 * 返回格式 list = { user1,user2,user3... }
	 * 
	 * */
	@Test
	public void testfindByNamedQuery5() {
		String queryName = "user.findByName4";
		String[] fields = {"name"};
		Map pramMap = new HashMap();
		pramMap.put("age", 50);
		pramMap.put("name", "zhansan");
		List<Object>  list = this.userService.findByNamedQuery(queryName, User.class,fields, pramMap);
		if(list==null||list.size()==0) return ;
		for(int i = 0 ; i < list.size() ; i++){
			 User user = (User) list.get(i);
			 System.out.println( "  name = " + user.getName());
		}
	}
	
	
	
	/**
	 * 按HQL查询对象列表.
	 * 
	 * @param values 数量可变的参数,按顺序绑定.
	 */
	
	@Test
	public void testFindByHQL() {
		String hql = " from User u where u.name=? and u.age = ?";
		Object[] array = new Object[2];
		array[0]="zhangsan";
		array[1]=0;
		List<User> list = (List<User>)this.userService.findByHQL(hql, array);
		if(list==null||list.size()==0) return ;
		for(int i = 0 ; i < list.size() ; i++){
			 User user = (User) list.get(i);
			 System.out.println(
						"name = " + user.getName()
					+ "  age = " + user.getAge()
				);
		}
	}
	
	/**
	 * 按sql查询对象列表.
	 * 返回list={user1,user2,user3}
	 * 
	 */
	@Test
	public void testfindBySql(){
		String sql = " SELECT NAME,age FROM USER u WHERE u.name='zhangsan' ";
		String[] fields = { "name","age" };
		List<User> list = (List<User>)this.userService.findBySql(sql, User.class, fields);
		if(list==null||list.size()==0) return ;
		for(int i = 0 ; i < list.size() ; i++){
			 User user = (User) list.get(i);
			 System.out.println(
						"name = " + user.getName()
					+ "  age = " + user.getAge()
				);
		}
		
	}
	
	/**
	 * 按sql查询对象列表.
	 * map1={name1=zhangsan1,age=1},map2={name2=zhangsan2,age=2},map3={name3=zhangsan3,age=3}
	 * 返回list={map1,map2,map3}
	 * 
	 */
	@Test
	public void testfindBySql2(){
		String sql = " SELECT NAME,age FROM USER u WHERE u.name='zhangsan' ";
		String[] fields = { "name","age" };
		List<Map<String,Object>> list = this.userService.findBySql(sql, fields);
		if(list==null||list.size()==0) return ;
		for(int i = 0 ; i < list.size() ; i++){
			 Map map = list.get(i);
			 System.out.println( " i = "+i+"  age = " + map.get("age") +"  name = " + map.get("name") );
		}
		
	}
	
	/**
	 * 根据sql插入或者更新
	 * */
	@Test
	public void testInsertOrUpdateBySql(){
		String sql = " INSERT INTO USER(id,NAME,age)VALUES(2,'name',33) ";
		this.userService.insertOrUpdateBySql(sql);
		
		
	}
	
	
	
}

 源码介绍

 案例结构图

 动态sql和hql

实现原理参考以下博客

http://blog.csdn.net/crazycoder2010/article/details/7414152

 详细代码

     maven 配置pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>02_curd</groupId>
  <artifactId>curd</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>curd Maven Webapp</name>
  <url>http://maven.apache.org</url>
  
  
  
  <properties>
  
    
    
    <spring.version>4.1.6.RELEASE</spring.version>
    
    <hibernate.version>4.1.10.Final</hibernate.version>
    
    <cglib.version>2.2.2</cglib.version>
     
  </properties>
  
  <dependencies>
  
	 <!-- log4j -->
	<dependency>
	    <groupId>log4j</groupId>
	    <artifactId>log4j</artifactId>
	    <version>1.2.17</version>
	</dependency>
  
   <!-- mail -->
  	<dependency>
		<groupId>javax.mail</groupId>
		<artifactId>mail</artifactId>
		<version>1.4.1</version>
	</dependency>
	
	
    <!--junit --> 
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.9</version>
      <scope>test</scope>
    </dependency>  
    
    <!--hibernate-core -->
	<dependency>
	    <groupId>org.hibernate</groupId>
	    <artifactId>hibernate-core</artifactId>
	    <version>${hibernate.version}</version> 
	</dependency>
	  
	<!-- spring-context-support -->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-context-support</artifactId>
	    <version>${spring.version}</version>
	</dependency>
	
    
     <!-- spring-context   -->
    <dependency>
		 <groupId>org.springframework</groupId>
		 <artifactId>spring-context</artifactId>
		 <version>${spring.version}</version>
	</dependency>  
    
 
	
	<!-- spring-orm -->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-orm</artifactId>
	    <version>${spring.version}</version>
	</dependency>
	
	<!-- aspectjweaver -->
    <dependency>
      <groupId>org.aspectj</groupId>
	  <artifactId>aspectjweaver</artifactId>
	  <version>1.5.4</version>
    </dependency>
    
    <!-- spring-aspects -->
    <dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-aspects</artifactId>
		<version>${spring.version}</version>
	</dependency>
    
    <!-- spring-aop -->
    <dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-aop</artifactId>
		<version>${spring.version}</version>
	</dependency>
    
     <!-- spring-jdbc -->
    <dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-jdbc</artifactId>
		<version>${spring.version}</version>
	</dependency>
    
    <!-- spring-core  -->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-core</artifactId>
	    <version>${spring.version}</version>
	</dependency>
   
    <!-- mysql-connector -->
	<dependency>
	    <groupId>mysql</groupId>
	    <artifactId>mysql-connector-java</artifactId>
	    <version>5.1.18</version>
	</dependency>
    
    <!-- druid -->
	<dependency>
	    <groupId>com.alibaba</groupId>
	    <artifactId>druid</artifactId>
	    <version>1.0.14</version>
	</dependency>
	
     <!-- persistence-api -->
    <dependency>
      <groupId>javax.persistence</groupId>
      <artifactId>persistence-api</artifactId>
      <version>1.0</version>
    </dependency>
    
    <!-- cglib  -->
    <dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>
      <version>2.2</version>
    </dependency>
    
    <!-- freemarker  -->
    <dependency>
		<groupId>org.freemarker</groupId>
		<artifactId>freemarker</artifactId>
		<version>2.3.20</version>
	</dependency>
    
    <!-- ehcache  -->
    <dependency>
      <groupId>net.sf.ehcache</groupId>
      <artifactId>ehcache</artifactId>
      <version>1.2.3</version>
    </dependency>
    
     <!-- jtds  -->
    <dependency>
	    <groupId>net.sourceforge.jtds</groupId>
	    <artifactId>jtds</artifactId>
	    <version>1.2.4</version>
	</dependency>
    
    <!-- org.slf4j  -->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.5.8</version>
    </dependency>
    
     <!-- commons-lang  -->
     <dependency>
    	<groupId>commons-lang</groupId>
		<artifactId>commons-lang</artifactId>
		<version>2.6</version>
	</dependency>
    
    <!-- spring-test -->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-test</artifactId>
	    <version>${spring.version}</version>
	</dependency>
    
    
  </dependencies>
  
  
  <build>
    <finalName>curd</finalName>
    <defaultGoal>compile</defaultGoal>
  </build>
  
</project>

    spring配置信息applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<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: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.2.xsd 
	http://www.springframework.org/schema/context 
	http://www.springframework.org/schema/context/spring-context-4.2.xsd
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
	http://www.springframework.org/schema/aop 
	http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
	
	<!-- 引入属性文件 --> 
	<context:property-placeholder location="db.properties" /> 
	 
	<!-- 自动扫描 -->
	<context:component-scan base-package="com.system.hibernate"/>
	<context:component-scan base-package="com.business.dao"/>
	<context:component-scan base-package="com.business.service"/>
	
	
	
	<!-- druid数据源 -->
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="driverClassName" value="${driver_class_name}" />
        <property name="url" value="${jdbc_url}" />
        <property name="username" value="${jdbc_username}" />
        <property name="password" value="${jdbc_password}" />
    </bean> 
	
	<!-- sessionFactory -->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean" lazy-init="false">
        <!-- 注入datasource，给sessionfactoryBean内setdatasource提供数据源 -->
        <property name="dataSource" ref="dataSource" />
        <property name="configLocation" value="classpath:hibernate.cfg.xml" />
    </bean>  
	

    <!-- hibernateTemplate -->
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate4.HibernateTemplate">
		<property name="sessionFactory" ref="sessionFactory"/>
	</bean>
    
    
    
    <!-- 事务的配置 -->  
    <bean id="txManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">  
  		 <property name="sessionFactory" ref="sessionFactory" />  
  	</bean>
    
    <!-- 业务逻辑层切面配置 -->
    <aop:config>  
  		<aop:pointcut id="servicePointcut" expression="execution( * com.business.service..*.*(..) )" />  
  		<aop:advisor pointcut-ref="servicePointcut"  advice-ref="txAdvice" />  
  	</aop:config>
  	<!-- 系统hibernate层切面配置 -->
  	<aop:config>  
  		<aop:pointcut id="hibernatePointcut" expression="execution( * com.system.hibernate..*.*(..) )" />  
  		<aop:advisor pointcut-ref="hibernatePointcut"  advice-ref="txAdvice" />  
  	</aop:config>    
    
   <!--  配置事务传播特性 -->
    <tx:advice id="txAdvice" transaction-manager="txManager">  
  		  <tx:attributes>  
  			  <tx:method name="save*" propagation="REQUIRED"/>
  			  <tx:method name="add*" propagation="REQUIRED"/>
		      <tx:method name="del*" propagation="REQUIRED"/>
		      <tx:method name="update*" propagation="REQUIRED"/>
		      <tx:method name="find*" propagation="REQUIRED"/>
		      <tx:method name="get*" propagation="REQUIRED"/>
		      <tx:method name="*" read-only="true" rollback-for="Exception"/>  
  		  </tx:attributes>  
   </tx:advice> 
    
   <!-- dynamicStatementBuilder -->
    <bean id="dynamicStatementBuilder" class="com.system.hibernate.DefaultDynamicHibernateStatementBuilder">  
        <property name="fileNames">  
            <list>  
                <value>classpath*:com/business/dynamicXml/*-dynamicHibernateSql.xml</value><!--这里我们指定要加载某个文件夹下所有以-dynamicHibernateSql.xml结尾的文件 -->  
            </list>  
        </property>  
    </bean>    

</beans>

    hibernate配置信息hibernate.cfg.xml

<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<!--声明Hibernate配置文件的开始-->  
<hibernate-configuration>
  <session-factory>
  
    <!-- SQL dialect -->
    <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
         
    <!-- Echo all executed SQL to stdout -->
    <property name="show_sql">true</property>
         
  	<!-- Drop and re-create the database schema on startup -->
    <property name="hbm2ddl.auto">update</property>
      
    <!--    
    <mapping resource="com/sunrise/jop/business/custmanager/reltemp/persistent/RelTemp.hbm.xml"/>
    -->  
     <!-- 
      	采用getCurrentSession()创建的session会绑定到当前线程中，而采用openSession()创建的session则不会。
		采用getCurrentSession()创建的session在commit或rollback时会自动关闭，而采用openSession()创建的session必须手动关闭。
		使用getCurrentSession()需要在hibernate.cfg.xml文件中加入如下配置：
		* 如果使用的是本地事务（jdbc事务）
		<property name="hibernate.current_session_context_class">thread</property>
		* 如果使用的是全局事务（jta事务）
		<property name="hibernate.current_session_context_class">jta</property>
		如果采用的时Hibernate4，使用getCurrentSession()必须配置事务，否则无法取到session 
	  -->
      <property name="current_session_context_class">org.springframework.orm.hibernate4.SpringSessionContext</property>
    
	    <!-- 映射文件 -->
	   <mapping resource="com/business/entity/User.hbm.xml"/> 
    
   
  </session-factory>
</hibernate-configuration>

    hibernate核心代码

           BaseDaoImpl.java

package com.system.hibernate;

import java.util.Collection;
import java.io.Serializable;
import java.io.StringReader;
import java.io.StringWriter;
import java.lang.reflect.Field;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Restrictions;
import org.hibernate.metadata.ClassMetadata;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate4.HibernateTemplate;
import org.springframework.stereotype.Repository;
import org.springframework.beans.factory.InitializingBean;


import freemarker.cache.StringTemplateLoader;
import freemarker.template.Configuration;
import freemarker.template.Template;

@Repository("baseDao")
public class BaseDaoImpl implements InitializingBean{
	
	private static final Logger logger = LoggerFactory.getLogger(BaseDaoImpl.class);

	@Autowired
	private SessionFactory sessionFactory;

	@Autowired
	private HibernateTemplate hibernateTemplate;
	
	private final int BATCH_NUMBER = 100;//批量操作数
	/**
	 * 模板缓存
	 */
	protected Map<String, StatementTemplate> templateCache;
	
	@Autowired
	protected DynamicHibernateStatementBuilder dynamicStatementBuilder;
	

	// ThreadLocal可以隔离多个线程的数据共享，因此不再需要对线程同步
	private ThreadLocal<Session> session = null;

	/**
	 * 创建session,需要手动关闭
	 * */
	public Session openSession() {
		return sessionFactory.openSession();
	}
	
	/**
	 * 根据sql插入或者更新
	 * */
	public void insertOrUpdateBySql(String sql){
		if(sql==null) return ;
		try{
			this.getCurrentSession().createSQLQuery(sql).executeUpdate();
		}catch(Exception e){
			e.printStackTrace();
		}
		
	}
	

	/**
	 * 保存对象
	 * */
	public boolean save(Object obj) {
		if(obj==null) return false;
		try {
			this.hibernateTemplate.save(obj);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}

	/**
	 * 保存所有对象
	 * */
	public boolean saveAll(Collection col) {
		if(col==null||col.size()==0) return false;
		Session session = this.openSession();
		Transaction tx = session.beginTransaction(); // 开启事物
		int count = 0;
		try {
			Iterator iterator = col.iterator();
			while(iterator.hasNext()){
				count++;
				session.save(iterator.next());
				if(count%this.BATCH_NUMBER==0){ //以每BATCH_NUMBER个数据作为一个处理单元
					session.flush(); //保持与数据库数据的同步
					session.clear();//清除内部缓存的全部数据，及时释放出占用的内存
				}
			}
			tx.commit(); // 提交事物  
			
		} catch (Exception e) {
			e.printStackTrace();
			tx.rollback();
			return false;
		}
		this.closeSession(session);
		return true;
	}

	/**
	 * 删除对象
	 * */
	public boolean delete(Object obj) {
		try {
			this.hibernateTemplate.delete(obj);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}
	
	/**
	 * 按id删除对象.
	 */
	
	public boolean delete(Class clazz,Serializable id) {
		try {
			this.hibernateTemplate.delete( this.get(clazz, id) );
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		
	}

	/**
	 * 按id列表获取对象列表.
	 */
	public List get(Class clazz,Collection ids) {
		if(clazz==null||ids==null||ids.size()==0) return null;
		return find(clazz,Restrictions.in(getIdName(clazz), ids));
	}
	
	/**
	 * 按Criteria查询对象列表.
	 * 
	 * @param criterions 数量可变的Criterion.
	 */
	@SuppressWarnings("unchecked")
	public List find(Class clazz,final Criterion... criterions) {
		return createCriteria(clazz,criterions).list();
	}
	
	/**
	 * 根据Criterion条件创建Criteria.
	 * 与find()函数可进行更加灵活的操作.
	 * @param criterions 数量可变的Criterion.
	 */
	public Criteria createCriteria(Class clazz,final Criterion... criterions) {
		Criteria criteria = this.getCurrentSession().createCriteria(clazz);
		for (Criterion c : criterions) {
			criteria.add(c);
		}
		return criteria;
	}
	
	/**
	 * 取得对象的主键名.
	 */
	public String getIdName(Class clazz) {
		if(clazz==null) return null;
		ClassMetadata meta = this.sessionFactory.getClassMetadata(clazz);
		return meta.getIdentifierPropertyName();
	}
	
	
	/**
	 * 删除所有对象
	 * */
	public boolean deleteAll(Collection col) {
		if(col==null||col.size()==0) return false;
		Session session = this.openSession();
		Transaction tx = session.beginTransaction(); // 开启事物
		int count = 0;
		try {
			Iterator iterator = col.iterator();
			while(iterator.hasNext()){
				count++;
				session.delete(iterator.next());
				if(count%this.BATCH_NUMBER==0){ //以每BATCH_NUMBER个数据作为一个处理单元
					session.flush(); //保持与数据库数据的同步
					session.clear();//清除内部缓存的全部数据，及时释放出占用的内存
				}
			}
			tx.commit(); // 提交事物  
			
		} catch (Exception e) {
			e.printStackTrace();
			tx.rollback();
			return false;
		}
		this.closeSession(session);
		return true;
	}

	/**
	 * 更新对象
	 * */
	public boolean update(Object obj) {
		if(obj==null) return false;
		try {
			this.hibernateTemplate.update(obj);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 更新所有对象
	 * */
	public boolean updateAll(Collection col) {
		if(col==null||col.size()==0) return false;
		Session session = this.openSession();
		Transaction tx = session.beginTransaction(); // 开启事物
		int count = 0;
		try {
			Iterator iterator = col.iterator();
			while(iterator.hasNext()){
				count++;
				session.update(iterator.next());
				if(count%this.BATCH_NUMBER==0){ //以每BATCH_NUMBER个数据作为一个处理单元
					session.flush(); //保持与数据库数据的同步
					session.clear();//清除内部缓存的全部数据，及时释放出占用的内存
				}
			}
			tx.commit(); // 提交事物  
			
		} catch (Exception e) {
			e.printStackTrace();
			tx.rollback();
			return false;
		}
		this.closeSession(session);
		return true;
	}

	/**
	 * 保存或更新
	 * */
	public boolean saveOrUpdate(Object obj) {
		try {
			this.hibernateTemplate.saveOrUpdate(obj);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 保存或更新所有实体
	 * */
	public boolean saveOrUpdateAll(Collection col) {
		Session session = this.openSession();
		Transaction tx = session.beginTransaction(); // 开启事物
		int count = 0;
		try {
			Iterator iterator = col.iterator();
			while(iterator.hasNext()){
				count++;
				session.saveOrUpdate(iterator.next());
				if(count%this.BATCH_NUMBER==0){ //以每BATCH_NUMBER个数据作为一个处理单元
					session.flush(); //保持与数据库数据的同步
					session.clear();//清除内部缓存的全部数据，及时释放出占用的内存
				}
			}
			tx.commit(); // 提交事物  
			
		} catch (Exception e) {
			e.printStackTrace();
			tx.rollback();
			return false;
		}
		this.closeSession(session);
		return true;
	}

	/**
	 * 得到Session ,spring自动管理session,不需要手动关闭
	 * */
	public Session getCurrentSession() throws HibernateException {
//		return this.hibernateTemplate.getSessionFactory().getCurrentSession();
		return this.hibernateTemplate.getSessionFactory().openSession();
	}

	/**
	 * 根据原生sql语句进行查询,返回对象集合 
	 * String sql 原生sql语句
	 *  Class clazz 为类 String[] fields
	 * 必需为对象字段属性 
	 * 例子: Sql : select username as name ,userage as age from user;
	 * User : private String name , private int age 
	 * clazz = User.class 
	 * fields ={ "name","age" }; //注意 sql和fields必需一致,并且fields为User的字段属性 
	 * 返回格式 list = { user1,user2,user3... }
	 * 
	 * */
	public List<Object> findBySql(String sql, Class clazz, String[] fields) {
		return parseObjectToList(this.getCurrentSession().createSQLQuery(sql).list(), clazz, fields);
	}

	/**
	 * 根据原生sql语句进行查询,返回对象集合 
	 * String sql 原生sql语句 
	 * String[] fields 可以不为对象字段属性 
	 * 例子:
	 * Sql : select username ,userage from user; 
	 * fields = { "name","age" }; 
	 * 返回
	 * map1 = { name="张三",age=30}; map2 = { name="李四",age=18}; 
	 * list = { map1 ,map2}
	 * 
	 * */
	public List<Map<String,Object>> findBySql(String sql, String[] fields) {
		return parseObjectToMap(this.getCurrentSession().createSQLQuery(sql).list(), fields);
	}

	/**
	 * 对hibernate查询到object[]数组进行解析,并返回List<Map>集合
	 * */
	private List parseObjectToMap(List dataList, String[] fields) {
		if (dataList == null || dataList.size() == 0 || fields == null
				|| fields.length == 0)
			return null;
		try {
			List list = new ArrayList();
			if (dataList != null && dataList.size() > 0) {
				for (int i = 0; i < dataList.size(); i++) {
					Map map = new HashMap();
					if(! dataList.get(i).getClass().isArray() ){
						for (int j = 0; j < fields.length; j++) {
							map.put(fields[j], dataList.get(i));
						}
						
					}else{
						Object[] dataObj = (Object[]) dataList.get(i);
						for (int j = 0; j < fields.length; j++) {
							String currentValue = null;
							try {
								currentValue = dataObj[j] + "";
							} catch (Exception e) {
								currentValue = null;
							}
							if (fields.length > j && fields[j] != null) {
								map.put(fields[j], currentValue);
							}
						}
					}
					
					
					list.add(map);
				}
			}
			return list;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}

	}

	/**
	 * 对hibernate查询到object[]数组进行解析,并返回List<clazz>集合
	 * */
	private List parseObjectToList(List dataList, Class clazz, String[] fields) {
		if(dataList==null||dataList.size()==0||clazz==null||fields==null||fields.length==0) return null;
		try {
			List list = new ArrayList();
			if (dataList != null && dataList.size() > 0) {
				for (int i = 0; i < dataList.size(); i++) {
					Object clazzObj = clazz.newInstance();
					if(! dataList.get(i).getClass().isArray() ){
						Field field = clazz.getDeclaredField(fields[0]);
						field.setAccessible(true);
						Object currentValue = null;
						try {
							currentValue = dataList.get(i);
						} catch (Exception e) {
							currentValue = null;
						}
						this.setFiled(clazzObj, field, currentValue);
					}else{
						
						Object[] dataObj = (Object[]) dataList.get(i);
						for (int j = 0; j < fields.length; j++) {
							Field field = clazz.getDeclaredField(fields[j]);
							field.setAccessible(true);
							Object currentValue = null;
							try {
								currentValue = dataObj[j];
							} catch (Exception e) {
								currentValue = null;
							}
//							if (field.getGenericType().toString().equals("class java.lang.String")) {
//								field.set(clazzObj, currentValue + "");
//							} else if (field.getGenericType().toString().equals("class java.lang.Integer")) {
//								field.set(clazzObj, currentValue == null ? null: Integer.parseInt(currentValue + ""));
//							} else if (field.getGenericType().toString().equals("class java.lang.Double")) {
//								field.set(clazzObj, currentValue == null ? null: Double.parseDouble(currentValue + ""));
//							} else if (field.getGenericType().toString().equals("class java.util.Date")) {
//								field.set(clazzObj,currentValue == null ? null: new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(currentValue.toString()));
//							} else if (field.getGenericType().toString().equals("class java.lang.Short")) {
//								field.set(clazzObj, currentValue == null ? null: Short.parseShort(currentValue.toString()));
//							} else {
//								field.set(clazzObj, currentValue);
//							}
							this.setFiled(clazzObj, field, currentValue);
						}
						
						
					}
					

					list.add(clazzObj);
				}
			}
			return list;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}

	}
	
	private void setFiled(Object clazzObj,Field field,Object value){
		if(clazzObj==null||field==null) return ;
		try{
			if (field.getGenericType().toString().equals("class java.lang.String")) {
				field.set(clazzObj, value + "");
			} else if (field.getGenericType().toString().equals("class java.lang.Integer")) {
				field.set(clazzObj, value == null ? null: Integer.parseInt(value + ""));
			} else if (field.getGenericType().toString().equals("class java.lang.Double")) {
				field.set(clazzObj, value == null ? null: Double.parseDouble(value + ""));
			} else if (field.getGenericType().toString().equals("class java.util.Date")) {
				field.set(clazzObj,value == null ? null: new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(value.toString()));
			} else if (field.getGenericType().toString().equals("class java.lang.Short")) {
				field.set(clazzObj, value == null ? null: Short.parseShort(value.toString()));
			} else {
				field.set(clazzObj, value);
			}
		}catch(Exception e ){
			e.printStackTrace();
		}
	
	}

	/**
	 * 根据原生sql语句查询 entity必须为hibernate映射的实体
	 * */
	public List<Object> findBySql(String sql, Class entity) {
		return this.getCurrentSession().createSQLQuery(sql).addEntity(entity).list();
	}

	/**
	 * 根据hql查询
	 * */
	public List findByHql(String hql) {
		return this.hibernateTemplate.find(hql);
	}

	/**
	 * 根据id查询
	 * */
	public Object get(Class c, Serializable id) {
		if(c==null||id==null) return null;
		return (Object) this.hibernateTemplate.get(c, id);
	}

	/**
	 * 根据id查询
	 * */
	public Object load(Class c, Serializable id) {
		return (Object) this.hibernateTemplate.load(c, id);
	}

	/**
	 * 根据Id更新对象指定的属性
	 * */
	public boolean updateOneByProperty(Class clazz, Serializable id,
			String pName, Object pValue) {
		String hql = "update " + clazz.getName() + " entity set entity."
				+ pName + " = '" + pValue + "' where entity.id = " + id;
		try {
			this.hibernateTemplate.bulkUpdate(hql);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}

	/**
	 * 根据Id更新指定的多个属性
	 * */
	public boolean updateOneByPropertys(Class clazz, Serializable id,
			List<String> pName, List pValue) {
		if(clazz==null||id==null||pName==null||pName.size()==0||pValue==null||pValue.size()==0) return false;
		String hql = "update " + clazz.getName() + " entity set entity.";
		int maxIndex = pName.size() - 1;
		for (int i = 0; i < maxIndex; i++) {
			hql += pName.get(i) + " = '" + pValue.get(i) + "', entity.";
		}
		hql += pName.get(maxIndex) + " = '" + pValue.get(maxIndex)
				+ "'where entity.id = " + id;
		try {
			this.hibernateTemplate.bulkUpdate(hql);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}
	
	/**
	 * 根据id更新多个属性
	 * */
	public boolean updateOneByPropertys(Class clazz, Serializable id,Map<String,Object> map) {
		if(clazz==null||id==null||map==null||map.size()==0) return false;
//		String[] clazzNameArray = clazz.getName().replace(".", "#").split("#");
//		String clazzName = clazzNameArray[clazzNameArray.length-1];
		String hql = "update " + clazz.getName() + " entity set entity.";
		Set set = map.entrySet();
		if (set != null) {
			Iterator iterator = set.iterator();
			int i = 0;
			while (iterator.hasNext()) {
				Entry entry = (Entry) iterator.next();
				Object key =  entry.getKey();
				Object value =  entry.getValue();
				hql += key + " = '" + value + "' , entity.";
				i++;
				if(i==set.size()-1) break;
			}
			Entry entry = (Entry) iterator.next();
			Object key =  entry.getKey();
			Object value =  entry.getValue();
			hql += key + " = '" + value + "' ";
		}
		hql += " where entity.id = " + id;
		try {
			this.hibernateTemplate.bulkUpdate(hql);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}   

	
	/**
	 * 动态命名查询,返回对象集合 
	 * final String queryName 为sql或者hql命名查询
	 * String[] fields  必需为查询字段
	 * 例子: queryName : select username as name ,userage as age from user;
	 * User : private String name , private int age 
	 * clazz = User.class 
	 * fields ={ "name","age" }; //注意 sql和fields必需一致,并且fields为User的字段属性 
	 * Map<String, ?> parameters 为参数{name=zhangsan,age=3}
	 * 返回格式
	 * map1 = { name=zhangsan,age=1 }, map2 = { name=zhangsan2,age=2 }, map3 = { name=zhangsan3,age=3 }
	 * list = {map1,map2,map3}
	 * 
	 * */
	public List<Map<String, Object>> findByNamedQuery(final String queryName, final String[] fields,final Map<String, ?> parameters) {
		if( queryName==null || parameters==null || parameters.size()==0 ||fields==null||fields.length == 0) return null;
		StatementTemplate statementTemplate = templateCache.get(queryName);
		String statement = processTemplate(statementTemplate,parameters);
		if(statementTemplate.getType() == StatementTemplate.TYPE.HQL){
			return this.parseObjectToMap(this.findByHQL(statement), fields) ;
		}
		else{
			return this.parseObjectToMap(this.findBySql(statement),fields);
		}
	}
	
	/**
	 * 动态命名查询,返回对象集合 
	 * final String queryName 为sql或者hql命名查询
	 * Class clazz 为类对象
	 * String[] fields  必需为查询字段
	 * Map<String, ?> parameters 为参数{name=zhangsan,age=3}
	 * 例子: queryName : select username as name ,userage as age from user;
	 * User : private String name , private int age 
	 * clazz = User.class 
	 * fields ={ "name","age" }; //注意 sql和fields必需一致,并且fields为User的字段属性 
	 * 返回格式 list = { user1,user2,user3... }
	 * 
	 * */
	public List<Object> findByNamedQuery(final String queryName,Class clazz, final String[] fields,final Map<String, ?> parameters) {
		if( queryName==null || clazz==null || fields==null || fields.length ==0  || parameters==null || parameters.size()==0 ) return null;
		StatementTemplate statementTemplate = templateCache.get(queryName);
		String statement = processTemplate(statementTemplate,parameters);
		if(statementTemplate.getType() == StatementTemplate.TYPE.HQL){
			return this.parseObjectToList(this.findByHQL(statement), clazz, fields);
		}
		else{
			return this.parseObjectToList(this.findBySql(statement), clazz, fields);
		}
	}
	
	private  String processTemplate(StatementTemplate statementTemplate,Map<String, ?> parameters){
		StringWriter stringWriter = new StringWriter();
		try {
			statementTemplate.getTemplate().process(parameters, stringWriter);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return stringWriter.toString();
	}
	
	
	/**
	 * 按HQL查询对象列表.
	 * 
	 * @param values 数量可变的参数,按顺序绑定.
	 */
	@SuppressWarnings("unchecked")
	public List findByHQL(final String hql, final Object... values) {
		List list = createHQLQuery(hql, values).list();
		return list;
	}
	
	/**
	 * 按sql查询对象列表.
	 * 
	 * @param values 命名参数,按名称绑定.
	 */
	@SuppressWarnings("unchecked")
	public List  findBySql(final String sql, final Object... values) {
		return createSQLQuery(sql, values).list();
	}
	
	
	/**
	 * 根据查询SQL与参数列表创建Query对象.
	 * 与find()函数可进行更加灵活的操作.
	 * @param sqlQueryString sql语句
	 * 
	 * @param values 数量可变的参数,按顺序绑定.
	 */
	private Query createSQLQuery(final String sqlQueryString, final Object... values) {
		Query query = this.getCurrentSession().createSQLQuery(sqlQueryString);
		if (values != null) {
			for (int i = 0; i < values.length; i++) {
				query.setParameter(i, values[i]);
			}
		}
		return query;
	}
	
	/**
	 * 根据查询HQL与参数列表创建Query对象.
	 * 与find()函数可进行更加灵活的操作.
	 * 
	 * @param values 数量可变的参数,按顺序绑定.
	 */
	private Query createHQLQuery(final String queryString, final Object... values) {
		Query query = this.getCurrentSession().createQuery(queryString);
		if (values != null) {
			for (int i = 0; i < values.length; i++) {
				query.setParameter(i, values[i]);
			}
		}
		return query;
	}
	
	
	/**
	 * 关闭session
	 * */
	public void closeSession(Session session) {
		if (session != null) {
			try {
				session.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
			session = null;
		}
	}

	@Override
	public void afterPropertiesSet() throws Exception {
		templateCache = new HashMap<String, StatementTemplate>();
		if(this.dynamicStatementBuilder == null){
			this.dynamicStatementBuilder = new DefaultDynamicHibernateStatementBuilder();
		}
		dynamicStatementBuilder.init();
		Map<String,String> namedHQLQueries = dynamicStatementBuilder.getNamedHQLQueries();
		Map<String,String> namedSQLQueries = dynamicStatementBuilder.getNamedSQLQueries();
		Configuration configuration = new Configuration();
		configuration.setNumberFormat("#");
		StringTemplateLoader stringLoader = new StringTemplateLoader();
		for(Entry<String, String> entry : namedHQLQueries.entrySet()){
			stringLoader.putTemplate(entry.getKey(), entry.getValue());
			templateCache.put(entry.getKey(), new StatementTemplate(StatementTemplate.TYPE.HQL,new Template(entry.getKey(),new StringReader(entry.getValue()),configuration)));
		}
		for(Entry<String, String> entry : namedSQLQueries.entrySet()){
			stringLoader.putTemplate(entry.getKey(), entry.getValue());
			templateCache.put(entry.getKey(), new StatementTemplate(StatementTemplate.TYPE.SQL,new Template(entry.getKey(),new StringReader(entry.getValue()),configuration)));
		}
		configuration.setTemplateLoader(stringLoader);
		
	} 
    
}

          BaseServiceImpl.java

package com.system.hibernate;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.criterion.Criterion;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;



@Service("baseService")
public class BaseServiceImpl  {

	@Resource(name="baseDao")
	private BaseDaoImpl baseDao;
	
	/**
	 * 根据sql插入或者更新
	 * */
	public void insertOrUpdateBySql(String sql){
		this.baseDao.insertOrUpdateBySql(sql);
	}
	
	
	/**
	 * 保存对象
	 * */
	public boolean save(Object obj) {
		return this.baseDao.save(obj);
	}

	/**
	 * 保存所有对象
	 * */
	public boolean saveAll(Collection col) {
		return this.baseDao.saveAll(col);
	}

	/**
	 * 删除对象
	 * */
	public boolean delete(Object obj) {
		return this.baseDao.delete(obj);
	}

	/**
	 * 按id删除对象.
	 */
	public boolean delete(Class clazz, Serializable id) {
		return this.baseDao.delete(clazz, id);
	}

	/**
	 * 按id列表获取对象列表.
	 */
	public List get(Class clazz, Collection ids) {
		return this.baseDao.get(clazz, ids);
				
	}

	/**
	 * 按Criteria查询对象列表.
	 * 
	 * @param criterions 数量可变的Criterion.
	 */
	public List find(Class clazz, Criterion... criterions) {
		return this.baseDao.find(clazz, criterions);
	}

	/**
	 * 根据Criterion条件创建Criteria.
	 * 与find()函数可进行更加灵活的操作.
	 * @param criterions 数量可变的Criterion.
	 */
	public Criteria createCriteria(Class clazz, Criterion... criterions) {
		return this.baseDao.createCriteria(clazz, criterions);
	}

	/**
	 * 取得对象的主键名.
	 */
	public String getIdName(Class clazz) {
		return this.baseDao.getIdName(clazz);
	}

	/**
	 * 删除所有对象
	 * */
	public boolean deleteAll(Collection col) {
		return this.baseDao.deleteAll(col);
	}

	/**
	 * 更新对象
	 * */
	public boolean update(Object obj) {
		return this.baseDao.update(obj);
	}

	/**
	 * 更新所有对象
	 * */
	public boolean updateAll(Collection col) {
		return this.baseDao.updateAll(col);
	}

	/**
	 * 保存或更新
	 * */
	public boolean saveOrUpdate(Object obj) {
		return this.baseDao.saveOrUpdate(obj);
	}

	/**
	 * 保存或更新所有实体
	 * */
	public boolean saveOrUpdateAll(Collection col) {
		return this.baseDao.saveOrUpdateAll(col);
	}

	/**
	 * 根据原生sql语句进行查询,返回对象集合 
	 * String sql 原生sql语句
	 *  Class clazz 为类 String[] fields
	 * 必需为对象字段属性 
	 * 例子: Sql : select username as name ,userage as age from user;
	 * User : private String name , private int age 
	 * clazz = User.class 
	 * fields ={ "name","age" }; //注意 sql和fields必需一致,并且fields为User的字段属性 
	 * 返回格式 list = { user1,user2,user3... }
	 * 
	 * */
	public List findBySql(String sql, Class clazz, String[] fields) {
		return this.baseDao.findBySql(sql, clazz, fields);
	}

	/**
	 * 根据原生sql语句进行查询,返回对象集合 
	 * String sql 原生sql语句 
	 * String[] fields 可以不为对象字段属性 
	 * 例子:
	 * Sql : select username ,userage from user; 
	 * fields = { "name","age" }; 
	 * 返回
	 * map1 = { name="张三",age=30}; map2 = { name="李四",age=18}; 
	 * list = { map1 ,map2}
	 * 
	 * */
	public List<Map<String,Object>> findBySql(String sql, String[] fields) {
		return this.baseDao.findBySql(sql, fields);
	}

	/**
	 * 根据原生sql语句查询 entity必须为hibernate映射的实体
	 * */
	public List findBySql(String sql, Class entity) {
		return this.baseDao.findBySql(sql, entity);
	}

	/**
	 * 根据hql查询
	 * */
	public List findByHql(String hql) {
		return this.baseDao.findByHql(hql);
	}

	/**
	 * 根据id查询
	 * */
	public Object get(Class c, Serializable id) {
		return this.baseDao.get(c, id);
	}

	/**
	 * 根据id查询
	 * */
	public Object load(Class c, Serializable id) {
		return this.baseDao.load(c, id);
	}

	/**
	 * 根据Id更新对象指定的属性
	 * */
	public boolean updateOneByProperty(Class clazz, Serializable id,
			String pName, Object pValue) {
		return this.baseDao.updateOneByProperty(clazz, id, pName, pValue);
	}

	/**
	 * 根据Id更新指定的多个属性
	 * */
	public boolean updateOneByPropertys(Class clazz, Serializable id,
			List<String> pName, List pValue) {
		return this.baseDao.updateOneByPropertys(clazz, id, pName, pValue);
	}

	/**
	 * 根据id更新多个属性
	 * */
	public boolean updateOneByPropertys(Class clazz, Serializable id,
			Map<String, Object> map) {
		return this.baseDao.updateOneByPropertys(clazz, id, map);
	}

	

	/**
	 * 按HQL查询对象列表.
	 * 
	 * @param values 数量可变的参数,按顺序绑定.
	 */
	public List findByHQL(String hql, Object... values) {
		return this.baseDao.findByHQL(hql, values);
	}

	/**
	 * 根据sql查询
	 * */
	public List findBySql(String sql, Object... values) {
		return this.baseDao.findBySql(sql, values);
		
	}

	/**
	 * 动态命名查询,返回对象集合 
	 * final String queryName 为sql或者hql命名查询
	 * Class clazz 为类对象
	 * String[] fields  必需为查询字段
	 * Map<String, ?> parameters 为参数{name=zhangsan,age=3}
	 * 例子: queryName : select username as name ,userage as age from user;
	 * User : private String name , private int age 
	 * clazz = User.class 
	 * fields ={ "name","age" }; //注意 sql和fields必需一致,并且fields为User的字段属性 
	 * 返回格式 list = { user1,user2,user3... }
	 * 
	 * */
	public List<Object> findByNamedQuery(String queryName,
			Class clazz, String[] fields, Map<String, ?> parameters) {
		return this.baseDao.findByNamedQuery(queryName, clazz, fields, parameters);
	}

	/**
	 * 动态命名查询,返回对象集合 
	 * final String queryName 为sql或者hql命名查询
	 * String[] fields  必需为查询字段
	 * 例子: queryName : select username as name ,userage as age from user;
	 * User : private String name , private int age 
	 * clazz = User.class 
	 * fields ={ "name","age" }; //注意 sql和fields必需一致,并且fields为User的字段属性 
	 * Map<String, ?> parameters 为参数{name=zhangsan,age=3}
	 * 返回格式
	 * map1 = { name=zhangsan,age=1 }, map2 = { name=zhangsan2,age=2 }, map3 = { name=zhangsan3,age=3 }
	 * list = {map1,map2,map3}
	 * 
	 * */
	public List<Map<String, Object>> findByNamedQuery(String queryName,
			String[] fields, Map<String, ?> parameters) {
		return this.baseDao.findByNamedQuery(queryName, fields, parameters);
	}
	
}

           DefaultDynamicHibernateStatementBuilder.java

package com.system.hibernate;

import java.io.IOException;
import java.util.Map;

/**
 * 动态sql/hql语句组装器
 * @author WangXuzheng
 *
 */
public interface DynamicHibernateStatementBuilder {
	/**
	 * hql语句map
	 * @return
	 */
	public Map<String,String> getNamedHQLQueries();
	/**
	 * sql语句map
	 * @return
	 */
	public Map<String,String> getNamedSQLQueries();
	/**
	 * 初始化
	 * @throws IOException 
	 */
	public void init() throws IOException;
}

DynamicHibernateStatementBuilder.java

package com.system.hibernate;

import java.io.IOException;
import java.util.Map;

/**
 * 动态sql/hql语句组装器
 * @author WangXuzheng
 *
 */
public interface DynamicHibernateStatementBuilder {
	/**
	 * hql语句map
	 * @return
	 */
	public Map<String,String> getNamedHQLQueries();
	/**
	 * sql语句map
	 * @return
	 */
	public Map<String,String> getNamedSQLQueries();
	/**
	 * 初始化
	 * @throws IOException 
	 */
	public void init() throws IOException;
}

           DynamicStatementDTDEntityResolver.java

package com.system.hibernate;

import java.io.IOException;
import java.io.InputStream;
import java.io.Serializable;

import org.hibernate.internal.util.ConfigHelper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;


/**
 * hibernate动态sql dtd解析器
 * @author WangXuzheng
 *
 */
public class DynamicStatementDTDEntityResolver implements EntityResolver, Serializable{
	private static final long serialVersionUID = 8123799007554762965L;
	private static final Logger LOGGER = LoggerFactory.getLogger( DynamicStatementDTDEntityResolver.class );
	private static final String HOP_DYNAMIC_STATEMENT = "http://localhost:8080/dtd/";
//
//	public InputSource resolveEntity(String publicId, String systemId) {   
//		InputSource source = null; // returning null triggers default behavior
//		if ( systemId != null ) {
//			LOGGER.debug( "trying to resolve system-id [" + systemId + "]" );
//			if ( systemId.startsWith( HOP_DYNAMIC_STATEMENT ) ) {
//				LOGGER.debug( "recognized hop dyanmic statement namespace; attempting to resolve " );
//				source = resolveOnClassPath( publicId, systemId, HOP_DYNAMIC_STATEMENT );
//			}
//		}     
//		return source;
//	}
//
//	private InputSource resolveOnClassPath(String publicId, String systemId, String namespace) {
//		InputSource source = null;
//		String path = systemId.substring( namespace.length() );
//		InputStream dtdStream = resolveInHibernateNamespace( path );
//		if ( dtdStream == null ) {
//			LOGGER.debug( "unable to locate [" + systemId + "] on classpath" );
//			if ( systemId.substring( namespace.length() ).indexOf( "2.0" ) > -1 ) {
//				LOGGER.error( "Don't use old DTDs, read the Hibernate 3.x Migration Guide!" );
//			}
//		}
//		else {
//			LOGGER.debug( "located [" + systemId + "] in classpath" );
//			source = new InputSource( dtdStream );
//			source.setPublicId( publicId );
//			source.setSystemId( systemId );
//		}
//		return source;
//	}

	protected InputStream resolveInHibernateNamespace(String path) {
		return this.getClass().getClassLoader().getResourceAsStream( path );
	}

	protected InputStream resolveInLocalNamespace(String path) {
		try {
			return ConfigHelper.getUserResourceAsStream( path );
		}
		catch ( Throwable t ) {
			return null;
		}
	}

	@Override
	public InputSource resolveEntity(String publicId, String systemId)
			throws SAXException, IOException {
		// TODO Auto-generated method stub
		return null;
	}
}

          Reflections.java

package com.system.hibernate;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;


public class Reflections {
	/**   
     * 通过反射,获得定义Class时声明的父类的范型参数的类型.   
     * 如public BookManager extends GenricManager<Book>   
     *   
     * @param clazz The class to introspect   
     * @return the first generic declaration, or <code>Object.class</code> if cannot be determined   
     */  
    public static Class getSuperClassGenricType(Class clazz) {  
        return getSuperClassGenricType(clazz, 0);  
    }  
  
    /**   
     * 通过反射,获得定义Class时声明的父类的范型参数的类型.   
     * 如public BookManager extends GenricManager<Book>   
     *   
     * @param clazz clazz The class to introspect   
     * @param index the Index of the generic ddeclaration,start from 0.   
     */  
    public static Class getSuperClassGenricType(Class clazz, int index) throws IndexOutOfBoundsException {  
  
        Type genType = clazz.getGenericSuperclass();  
  
        if (!(genType instanceof ParameterizedType)) {  
            return Object.class;  
        }  
  
        Type[] params = ((ParameterizedType) genType).getActualTypeArguments();  
  
        if (index >= params.length || index < 0) {  
            return Object.class;  
        }  
        if (!(params[index] instanceof Class)) {  
            return Object.class;  
        }  
        return (Class) params[index];  
    }  
    
}

          StatementTemplate.java

package com.system.hibernate;
import freemarker.template.Template;


public class StatementTemplate {
	private Template template;
	
	private TYPE type;
	
	public StatementTemplate(TYPE type, Template template) {
		this.template = template;
		this.type = type;
	}

	public TYPE getType() {
		return type;
	}

	public void setType(TYPE type) {
		this.type = type;
	}

	public Template getTemplate() {
		return template;
	}

	public void setTemplate(Template template) {
		this.template = template;
	}

	public static enum TYPE {
		HQL,SQL
	}
	
	
}

         DynamicHibernateStatementBuilder.java

package com.system.hibernate;

import java.io.IOException;
import java.util.Map;

/**
 * 动态sql/hql语句组装器
 * @author WangXuzheng
 *
 */
public interface DynamicHibernateStatementBuilder {
	/**
	 * hql语句map
	 * @return
	 */
	public Map<String,String> getNamedHQLQueries();
	/**
	 * sql语句map
	 * @return
	 */
	public Map<String,String> getNamedSQLQueries();
	/**
	 * 初始化
	 * @throws IOException 
	 */
	public void init() throws IOException;
}

 业务层

   Dao层

        UserDao.java

package com.business.dao;

import java.util.Collection;
import java.util.List;

import com.business.entity.User;

public interface UserDao {
	
	
}

        UserDaoImpl.java

package com.business.dao.impl;

import org.springframework.stereotype.Repository;

import com.business.dao.UserDao;
import com.business.entity.User;
import com.system.hibernate.BaseDaoImpl;

@Repository("userDao")
public class UserDaoImpl  extends BaseDaoImpl  implements UserDao {



}

    Service层

          UserService.java

package com.business.service;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;

import com.business.entity.User;

public interface UserService {

}

UserServiceImpl.java

package com.business.service.impl;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.business.dao.UserDao;
import com.business.dao.impl.UserDaoImpl;
import com.business.entity.User;
import com.business.service.UserService;
import com.system.hibernate.BaseServiceImpl;

@Service("userService")
public class UserServiceImpl extends BaseServiceImpl implements UserService {
	
	@Resource(name="userDao")
	private UserDao userDao;

	
	
}

    实体映射

        User.java

package com.business.entity;

import java.util.Date;

public class User {
	
	private int id;

	private String name; //姓名
 
	private Date birthday; //生日
	
	private String address ; //地址
	
	private int age ; //年龄
	

	public User(String name, Date birthday) {
		this.name = name;
		this.birthday = birthday;
	}

	public User() {
		
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
	
}

User.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 <hibernate-mapping>
 	<class table="user" name="com.business.entity.User" >
 		<id column="id" name="id"  type="java.lang.Integer">
 		 	<generator class="native"/>
 		</id>
 		<property column="name" name="name"  type="java.lang.String" />
 		<property column="address" name="address"  type="java.lang.String" />
 		<property column="age" name="age"  type="java.lang.Integer" />
 		<property column="birthday" name="birthday"  type="java.util.Date" />
 	</class>
 </hibernate-mapping>

    Dtd校验文件(dynamic-hibernate-statement-1.0.dtd)

<!-- HOP Hibernate Dynamic Statement Mapping DTD.

<!DOCTYPE dynamic-hibernate-statement SYSTEM ">

这个文件时用来定义动态参数语句，类似itabis

-->

<!--
	The document root.
 -->

<!ELEMENT dynamic-hibernate-statement (
	(hql-query|sql-query)*
)>
							<!-- default: none -->

<!-- The query element declares a named Hibernate query string -->

<!ELEMENT hql-query (#PCDATA)>
	<!ATTLIST hql-query name CDATA #REQUIRED>

<!-- The sql-query element declares a named SQL query string -->

<!ELEMENT sql-query (#PCDATA)>
	<!ATTLIST sql-query name CDATA #REQUIRED>

案例源码下载地址

http://download.csdn.net/detail/jianfpeng241241/9686192