Hibernate

HeChuangJun约 4594 字大约 15 分钟

hibernate

1. hibernate介绍
2. hibernate框架5.0的搭建
3. hibernate-API
4. hibernate对象状态（3种）
5. hibernate一级缓存+快照
6. hibernate事务
7. no-session问题及其解决方案
8. hibernate关系映射
- 8.1. 一对多|多对一
- 8.2. 多对多
9. 查询总结(session)
10. 查询优化
11. hibernate持久层抽取

1. hibernate介绍

hibernate是一款orm（orm:object relationg mapping. 对象关系映射）框架
其主要作用是在编程中，把面向对象的概念跟数据库中表的概念对应起来
hibernate官网http://hibernate.org/open in new window
hibernate文档http://hibernate.org/orm/documentation/5.4/open in new window
操作数据库的时候,可以以面向对象的方式来完成.不需要书写SQL语句
orm分4级：hibernate属于完全面向对象操作数据库、mybatis属于2级、dbutils属于1级

2. hibernate框架5.0的搭建

导包：web-content -->web-INF-->lib
hibernate-commons-annotations-5.0.1.Final.jar
hibernate-core-5.0.7.Final.jar
hibernate-jpa-2.1-api-1.0.0.Final.jar
jandex-2.0.0.Final.jar
javassist-3.18.1-GA.jar
jboss-logging-3.3.0.Final.jar
antlr-2.7.7.jar
dom4j-1.6.1.jar
geronimo-jta_1.1_spec-1.1.1.jar
mysql驱动包mysql-connector-java-5.1.7-bin.jar

建库建表，创建实体src目录的domain包下创建实体对象类(遵循以下规则)
- 不要用final修饰class,hibernate用cglib代理生成代理对象.代理对象是继承被代理对象.若被final修饰.将无法生成代理
- 成员变量私有,属性使用包装类型
- 提供get/set方法访问.需提供属性			
- 提供无参数构造
- 持久化类需要提供oid.与数据库中的主键列对应

orm元数据配置表与实体对象的关系配置文件src->表名.hbm.xml
- 导入mapping约束 window菜单--> preference-->cata
- 位置：Web App Libraries--hibernate-core-5.0.7.final.jar-org.hibernate-hibernate-mapping-3.0.dtd
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- package属性:填写一个包名.在元素内部凡是需要书写完整类名的属性,可以直接写简单类名了. -->
<hibernate-mapping package="" >
	<!--class元素: 配置实体与表的对应关系的 name: 完整类名 table:数据库表名-->
	<class name="" table="" >
		<!-- id元素:配置主键映射的属性 name: 填写主键对应属性名
			column(可选): 填写表中的主键列名.默认值:列名会默认使用属性名
			type(可选):填写列(属性)的类型.hibernate会自动检测实体的属性类型.
					每个类型有三种填法: java类型|hibernate类型|数据库类型
			not-null(可选):配置该属性(列)是否不能为空. 默认值:false
			length(可选):配置数据库中列的长度. 默认值:使用数据库类型的最大长度-->
		<id name=""  column="">//属性名和列名
			<generator class="native"></generator>
			<!--generator主键生成策略
			代理主键：
			identity : 主键自增.由数据库来维护主键值.录入时不需要指定主键.
			sequence: Oracle中的主键生成策略.
			hilo(了解): 高低位算法.主键自增.由hibernate来维护.开发时不使用.
			native:hilo+sequence+identity 自动三选一策略.（使用这个换数据库不用改）
			increment(了解): 主键自增.由hibernate来维护.每次插入前先查询表中id最大值+1作为新主键值.线程不安全，效率低开发不使用
			uuid: 产生随机字符串作为主键. 主键类型必须为string 类型.

			自然主键：assigned:自然主键生成策略. hibernate不会管理主键值.录入时指定主键. -->
		</id>
		<property name="" column="" ></property><!--与上面差不多-->
	</class>
</hibernate-mapping>

主配置文件(src目录-->hibernate.cfg.xml)
- 导入configuration约束window菜单--> preference-->cata
- 位置Web App Libraries--hibernate-core-5.0.7.final.jar-org.hibernate-hibernate-configuration-3.0.dtd
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
	<session-factory>
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> 
		<property name="hibernate.connection.url">jdbc:mysql:///hibernate</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password">1234</property>
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

		<property name="hibernate.show_sql">true</property>
		<property name="hibernate.format_sql">true</property>
		<!-- ## auto schema export  自动导出表结构. 自动建表
		create自动建表.每次框架运行都创建新表.以前表将会被覆盖,表数据会丢失.(开发测试使用)
		create-drop自动建表.每次框架运行结束都会将所有表删除.(开发环境中测试使用)
		update(推荐)自动生成表.如果已经存在不会再生成.如果表有变动.自动更新表(不删除任何数据)
		validate校验.不自动生成表.每次启动会校验数据库中表是否正确.校验失败.-->
		<property name="hibernate.hbm2ddl.auto">update</property>	
		<mapping resource="com/hechuangjun/domain/Customer.hbm.xml" />//引入orm元数据
		<!--指定数据库的隔离级别
		hibernate.connection.isolation 1|2|4|8		
		0001	1	读未提交
		0010	2	读已提交
		0100	4	可重复读（mysql）默认
		1000	8	串行化-->
		<property name="hibernate.connection.isolation">4</property>
		<!-- 指定session与当前线程绑定 -->
		<property name="hibernate.current_session_context_class">thread</property>
	</session-factory>
</hibernate-configuration>

测试
class Test Hibernate {
	@Test
	public void fun(){
		Configuration configuration = new Configuration().configure();
		SessionFactory sessionfactory = configuration.buildSessionFactory();
		Session session = sessionfactory.openSession();
		Transaction tx = session.beginTransaction();
		//-----------------
		Customer c=new Customer();
		c.setCust_name("xiaojun");
		session.save(c);
		//-----------------
		tx.commit();
		session.close();
		sessionfactory.close();
	}
}

3. hibernate-API

Configuration:用于加载主配置,orm元数据,创建sessionFactory对象
- Configuration conf = new Configuration().configure();默认加载src目录下的hibernate.cfg.xml
- sf = conf.buildSessionFactory();根据主配置信息,创建SessionFactory对象
SessionFactory:创建session,负责保存和使用所有配置信息.消耗内存资源非常大. 线程安全.保证在web项目中,只创建一个sessionFactory
- 获得一个新的session对象 sf.openSession();
- 获得一个与线程绑定的session对象 sf.getCurrentSession();//事务操作
Session:操作数据库的核心对象,与数据库之间的连接(会话)类似于JDBC的connection对象
- 开启事务并获得操作事务对象Transaction tx = session.beginTransaction();
- 增:Customer c = new Customer(); session.save(c);
- 删:Customer c = session.get(Customer.class, 1l); session.delete(c);
- 改:Customer c = session.get(Customer.class, 1l); session.update(c);
- 查:session.get(Customer.class, 1l);
Transaction：封装了事务的操作
- 打开事务：Transaction tx2 = session.beginTransaction();
- 提交事务：tx2.commit();
- 回滚事务：tx2.rollback();
- 释放资源：session.close(); sf.close();

	public class HibernateUtils {
		private static SessionFactory sf;
		static{
			Configuration conf = new Configuration().configure();
			 sf = conf.buildSessionFactory();
		}
		public static Session openSession(){
			Session session = sf.openSession();
			return session;
			
		}
		public static Session getCurrentSession(){
			Session session = sf.getCurrentSession();
			return session;
		}
	}


	Session session = HibernateUtils.openSession();
	Transaction tx = session.beginTransaction();
	//执行需要执行的操作
	tx.commit();
	session.close();

4. hibernate对象状态（3种）

瞬时状态：没有id,没有在session缓存中（注意是id、其他普通属性不算）delete
持久化状态：有id,在session缓存中与session有关（save update get）
游离/托管状态：有id,没有在session缓存中，与session无关联 close

5. hibernate一级缓存+快照

一级缓存.jpg
快照.jpg

6. hibernate事务

业务开始之前打开事务,业务执行之后提交事务. 执行过程中出现异常.回滚事务
在dao层操作数据库和service控制事务都需要使用session对象.要确保使用同一个session对象
调用sf.getCurrentSession()获得与当前线程绑定的session对象。事务提交时session会自动关闭.无需调用close关闭
必须在hibernate.cfg.xml中指定session与当前线程绑定<property name="hibernate.current_session_context_class">thread</property>

7. no-session问题及其解决方案

hibernate使用了懒加载后会节省资源，发送要求到dao层，但此时的session已经关闭了，取不出相应的数据
解决方案：扩大session的作用范围

8. hibernate关系映射

8.1. 一对多|多对一

班级（一）与学生(多)
表中的表达：多方（学生从表）外键引用一方（班级主表）主键
实体中的表达private Set<多> 多(一方班级);private 一 一(多方学生);

	orm元数据中分别新建hbm.xml表达并在主配置引入orm数据源
	<!-- name:表达一对多的集合属性名column: 外键列名class: 关联对象完整类名（many）-->
	<!--
	cascade级联操作
	save-update: 级联保存更新（推荐）
	delete:级联删除，删除一的数据，多的外键还在
	all:save-update+delete
	
	inverse(反转)属性: 
	配置关系是否维护. 性能优化.提高关系维护的性能.
	true: 不维护关系
	false(默认值): 维护关系,删除一的数据，多的外键消失

	在保存时.当两方都会维护外键关系.关系维护两次,冗余了. 
	多余的维护关系语句,显然是一方在维护关系（通过更新外键来维护的）
	原则: 一对多关系中: 一的一方放弃.多的一方不能放弃.
	如果一方放弃维护与多方的关系. 维护关系的代码可以省略
	-->
	<set name=""  cascade="delete" inverse="true">
		<key column="" ></key>
		<one-to-many class="" />
	</set>
	
	<!-- name:表达多对一关系的属性名column: 外键列名class: 关联对象完整类名（one）-->
	<many-to-one name="" column="" class="" ></many-to-one>

java代码
//增
Customer c = session.get(Customer.class,1l);
LinkMan lm1 = new LinkMan();
lm1.setLkm_name("test");
c.getLinkMens().add(lm1);
lm1.setCustomer(c);
session.save(lm1);
//存
Customer c = new Customer();
c.setCust_name("test1");	
LinkMan lm1 = new LinkMan();
lm1.setLkm_name("test2");
LinkMan lm2 = new LinkMan();
lm2.setLkm_name("test3");

c.getLinkMens().add(lm1);
c.getLinkMens().add(lm2);

lm1.setCustomer(c);
lm2.setCustomer(c);
session.save(c);
session.save(lm1);
session.save(lm2);
//删
Customer c = session.get(Customer.class,1l);
LinkMan lm = session.get(LinkMan.class, 3l);
c.getLinkMens().remove(lm);
lm.setCustomer(null);
session.save(c);
session.save(lm);

8.2. 多对多

表中的表达：通过中间表（从表）两个外键引用两个表的（主表）主键
实体中的表达：private Set<多> 多; private Set<多> 多;

	orm元数据中分别新建hbm.xml表达注意在主配置引入orm数据源
	- 级联属性cascade级联操作:
		- save-update: 级联保存更新(建议)
		- delete:级联删除(注意使用)
		- all:级联保存更新+级联删除
	- 使用inverse属性
		- true: 放弃维护外键关系
		- false(默认值):维护关系		
		- 多对多关系.一定要选择一方放弃维护关系.(看业务方向)
	name: 集合属性名table: 配置中间表名
		key
		|-column:外键,别人引用"我"的外键列名
		class: 我与哪个类是多对多关系
		column:外键.我引用比人的外键列名
		<set name="" table="" >
		<key column="" ></key>
		<many-to-many class="" column="" ></many-to-many>
		</set>
		<set name="" table="" >
		<key column="" ></key>
		<many-to-many class="" column="" ></many-to-many>
		</set>

java代码
u1.getRoles().add(r1);
u1.getRoles().add(r2);

u2.getRoles().add(r1);
u2.getRoles().add(r2);
		
r1.getUsers().add(u1);
r1.getUsers().add(u2);
		
r2.getUsers().add(u1);
r2.getUsers().add(u2);
		
session.save(u1);
session.save(u2);
session.save(r1);
session.save(r2);

9. 查询总结(session)

9.1. oid查询-get

9.2. 对象属性导航查询

9.3. HQL查询-面向对象的查询语言(多表查询)

单表查询
基础语法
String hql = " from  cn.domain.Customer ";
Query query = session.createQuery(hql);
List list = query.list();//接受list结果    
//query.uniqueResult();//接收唯一的查询结果

排序
String hql1 = " from  cn.domain.Customer order by cust_id asc ";
String hql2 = " from  cn.domain.Customer order by cust_id desc ";
Query query = session.createQuery(hql2);	
List list = query.list();

聚合
String hql1 = " select count(*) from  cn.domain.Customer  ";
String hql2 = " select sum(cust_id) from  cn.domain.Customer  ";
String hql3 = " select avg(cust_id) from  cn.domain.Customer  ";
String hql4 = " select max(cust_id) from  cn.domain.Customer  ";
String hql5 = " select min(cust_id) from  cn.domain.Customer  ";		
Query query = session.createQuery(hql5);
Number number  = (Number) query.uniqueResult();

投影（查询一部分）
String hql1 = " select cust_name from  cn.domain.Customer";
//把列名封装到对象中，同时要在对象中写这个构造函数和无参构造
String hql3 = " select new Customer(id,name) from  cn.domain.Customer";
Query query = session.createQuery(hql3);
List list = query.list();

分页
String hql1 = " from cn.domain.Customer  ";
Query query = session.createQuery(hql1);//limit ?,? (当前页数-1)*每页条数
query.setFirstResult(2);
query.setMaxResults(2);	
List list = query.list();

条件
？占位符
String hql1 = " from  cn.domain.Customer where cust_id =? ";
Query query = session.createQuery(hql1);	
query.setParameter(0, 2l);	
Customer c=(Customer)query.uniqueResult();//接收唯一的查询结果

命名占位符
String hql = " from  cn.domain.Customer where cust_id = :id ";
Query query = session.createQuery(hql1);
query.setParameter("id", 2l);
Customer c=(Customer)query.uniqueResult();//接收唯一的查询结果

多表查询
原生SQL:交叉连接-笛卡尔积(避免)select * from A,B 

内连接
隐式内连接:select * from A,B  where b.aid = a.id
显式内连接:select * from A inner join B on b.aid = a.id

外连接
左外:select * from A left [outer] join B on b.aid = a.id
右外:select * from A right [outer] join B on b.aid = a.id

内连接：将连接的两端对象分别返回.放到数组中.
普通内连接
String hql = " from Customer c inner join c.linkMens ";
Query query = session.createQuery(hql);
List<Object[]> list = query.list();
for(Object[] arr : list){
	System.out.println(Arrays.toString(arr));
}
迫切内连接 => 帮我们进行封装.返回值就是一个对象
String hql = " from Customer c inner join fetch c.linkMens ";
Query query = session.createQuery(hql);
List<Customer> list = query.list();

外连接
左外链接（迫切）: 将连接的两端对象分别返回.放到数组中.
String hql = " from Customer c left join c.linkMens ";	
Query query = session.createQuery(hql);	
List<Object[]> list = query.list();	
for(Object[] arr : list){
	System.out.println(Arrays.toString(arr));
}
右外连接（迫切）：将连接的两端对象分别返回.放到数组中.
String hql = " from Customer c right join c.linkMens ";
Query query = session.createQuery(hql);
List<Object[]> list = query.list();
for(Object[] arr : list){
	System.out.println(Arrays.toString(arr));
}

9.4. 原生SQL：复杂的业务查询

基本查询
返回数组List
String sql = "select * from cst_customer";	
SQLQuery query = session.createSQLQuery(sql);
List<Object[]> list = query.list();
//query.uniqueResult();
for(Object[] objs : list){
	System.out.println(Arrays.toString(objs));
}

返回对象List
String sql = "select * from cst_customer";	
SQLQuery query = session.createSQLQuery(sql);
query.addEntity(Customer.class);
List<Customer> list = query.list();

条件查询
String sql = "select * from cst_customer where cust_id = ? ";
SQLQuery query = session.createSQLQuery(sql);
query.setParameter(0, 1l);
query.addEntity(Customer.class);	
List<Customer> list = query.list();

分页查询
String sql = "select * from cst_customer  limit ?,? ";
SQLQuery query = session.createSQLQuery(sql);
query.setParameter(0, 0);
query.setParameter(1, 1);
query.addEntity(Customer.class);
List<Customer> list = query.list();

9.5. Criteria：(单表条件查询)

基本
Criteria c = session.createCriteria(Customer.class);
List<Customer> list = c.list();

条件
//HQL语句中,不可能出现任何数据库相关的信息的
Criteria c = session.createCriteria(Customer.class);		
c.add(Restrictions.idEq(2l));//id专用
c.add(Restrictions.eq("cust_id",2l));//其他属性字段
List<Customer> list = c.list();   
Customer c = (Customer) criteria.uniqueResult();

分页limit ?,? 
Criteria c = session.createCriteria(Customer.class);
c.setFirstResult(0);
c.setMaxResults(2);		
List<Customer> list = c.list();

排序
Criteria c = session.createCriteria(Customer.class);	
c.addOrder(Order.asc("cust_id"));//升序
c.addOrder(Order.desc("cust_id"));//降序
List<Customer> list = c.list();	

统计(查询总记录数)
Criteria c = session.createCriteria(Customer.class);
c.setProjection(Projections.rowCount());//设置查询目标
List list = c.list();

离线查询
//Service/web层
DetachedCriteria dc  = DetachedCriteria.forClass(Customer.class);	
dc.add(Restrictions.idEq(6l));//拼装条件(全部与普通Criteria一致)		
//----------------------------------------------------
Session session = HibernateUtils.openSession();
Transaction tx = session.beginTransaction();
//----------------------------------------------------
Criteria c = dc.getExecutableCriteria(session);
List list = c.list();		
//----------------------------------------------------
tx.commit();
session.close();

方法名	说明
>	Restrictions.gtopen in new window
>=	Restrictions.geopen in new window
<	Restrictions.ltopen in new window
<=	Restrictions.le
==	Restrictions.eq
!=	Restrictions.neopen in new window
in	Restrictions.inopen in new window
between and	Restrictions.between
like	Restrictions.like
is not null	Restrictions.isNotNull
is null	Restrictions.isNull
or	or
and	and

10. 查询优化

类级别查询（原理：代理对象）
- get方法:没有任何策略.调用即立即查询数据库加载数据.
- load方法(默认):应用级别加载策略，是在执行时,不发送任何sql语句.返回一个对象.使用该对象时,才执行查询(建议)
- 在orm数据源中配置<class name="" table="" lazy="false" >
  - lazy(默认值):true, 查询类时,会返回代理对象（variable中有$.）会在使用属性时,根据关联的session查询数据库.加载数据.
  - lazy:false. load与get没有任何区别.调用时即加载数据.
- 注意:使用懒加载时要确保,调用属性加载数据时,session还是打开的.不然会抛出异常
关联级别查询
- 关联集合策略（one to many）在hbm.xml的set配置
  - lazy属性: 决定是否延迟加载
    - true(默认值): 延迟加载,懒加载
    - false: 立即加载
    - extra: 极其懒惰.与懒加载效果基本一致. 如果只获得集合的size.只查询集合的size(count语句)
  - fetch属性: 决定加载策略.使用什么类型的sql语句加载集合数据
    - select(默认值): 单表查询加载（不影响lazy）
    - join: 使用多表查询加载集合（能使lazy加载失效，立即加载）
    - subselect:使用子查询加载集合（不影响lazy）没子查询不要配置，加载批量子查询
- 关联属性策略（many to one）在hbm.xml的set配置
  - lazy属性：决定加载时机
    - false: 立即加载
    - proxy: 由customer的类级别加载策略决定.
  - fetch 决定加载的sql语句
    - select: 使用单表查询
    - join : 多表查询
为了提高效率.fetch的选择上应选择select. lazy的取值应选择true. 全部使用默认值.
批量抓取在hbm.xml的set配置
- batch-size: 抓取集合的数量为3.抓取客户的集合时,一次抓取几个客户的联系人集合.

11. hibernate持久层抽取

	package com.itheima.bos.dao.base.impl;
	import java.io.Serializable;
	import java.lang.reflect.ParameterizedType;
	import java.lang.reflect.Type;
	import java.util.List;

	import javax.annotation.Resource;

	import org.hibernate.Query;
	import org.hibernate.Session;
	import org.hibernate.SessionFactory;
	import org.hibernate.criterion.DetachedCriteria;
	import org.hibernate.criterion.Projections;
	import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
	import com.itheima.bos.dao.base.IBaseDao;
	import com.itheima.bos.utils.PageBean;
	/**
	 * 持久层通用实现
	 */
	public class BaseDaoImpl<T> extends HibernateDaoSupport implements IBaseDao<T> {
		//代表的是某个实体的类型
		private Class<T> entityClass;
		
		@Resource//根据类型注入spring工厂中的会话工厂对象sessionFactory
		public void setMySessionFactory(SessionFactory sessionFactory){
			super.setSessionFactory(sessionFactory);
		}
		
		//在父类（BaseDaoImpl）的构造方法中动态获得entityClass
		public BaseDaoImpl() {
			ParameterizedType superclass = (ParameterizedType) this.getClass().getGenericSuperclass();
			//获得父类上声明的泛型数组
			Type[] actualTypeArguments = superclass.getActualTypeArguments();
			entityClass = (Class<T>) actualTypeArguments[0];
		}
		
		public void save(T entity) {
			this.getHibernateTemplate().save(entity);
		}
		
		public void delete(T entity) {
			this.getHibernateTemplate().delete(entity);
		}
		
		public void update(T entity) {
			this.getHibernateTemplate().update(entity);
		}

		public T findById(Serializable id) {
			return this.getHibernateTemplate().get(entityClass, id);
		}

		public List<T> findAll() {
			String hql = "FROM " + entityClass.getSimpleName();
			return (List<T>) this.getHibernateTemplate().find(hql);
		}

		//执行更新，批量删除
		public void executeUpdate(String queryName, Object... objects) {
			Session session = this.getSessionFactory().getCurrentSession();
			Query query = session.getNamedQuery(queryName);
			int i = 0;
			for (Object object : objects) {
				//为HQL语句中的？赋值
				query.setParameter(i++, object);
			}
			//执行更新
			query.executeUpdate();
		}
		//executeUpdate使用queryName为user.editpassword
		<query name="user.editpassword">
			UPDATE User SET password = ? WHERE id = ?
		</query>

		/**
		 * 通用分页查询方法
		 */
		public void pageQuery(PageBean pageBean) {
			int currentPage = pageBean.getCurrentPage();
			int pageSize = pageBean.getPageSize();
			DetachedCriteria detachedCriteria = pageBean.getDetachedCriteria();
			
			//查询total---总数据量
			detachedCriteria.setProjection(Projections.rowCount());
			//指定hibernate框架发出sql的形式----》select count(*) from bc_staff;
			List<Long> countList = (List<Long>) this.getHibernateTemplate().findByCriteria(detachedCriteria);
			Long count = countList.get(0);
			pageBean.setTotal(count.intValue());
			
			//查询rows---当前页需要展示的数据集合
			detachedCriteria.setProjection(null);//指定hibernate框架发出sql的形式----》select * from bc_staff;
			//指定hibernate框架封装对象的方式
			detachedCriteria.setResultTransformer(DetachedCriteria.ROOT_ENTITY);
			int firstResult = (currentPage - 1) * pageSize;
			int maxResults = pageSize;
			List rows = this.getHibernateTemplate().findByCriteria(detachedCriteria, firstResult, maxResults);
			pageBean.setRows(rows);
		}

		public void saveOrUpdate(T entity) {
			this.getHibernateTemplate().saveOrUpdate(entity);
		}

		public List<T> findByCriteria(DetachedCriteria detachedCriteria) {
			return (List<T>) this.getHibernateTemplate().findByCriteria(detachedCriteria);
		}
	}


	hiebernate分页的封装
	public class PageBean {
		private int currentPage;//当前页码
		private int pageSize;//每页显示的记录数
		private DetachedCriteria detachedCriteria;//查询条件
		private int total;//总记录数
		private List rows;//当前页需要展示的数据集合
		set/get方法;
	}