hibernate 技术总结

一、使用hibernate进行开发的步骤：
1、读取并解析配置文件
2、获取SessionFactory对象
3、打开Session
4、开启事务
5、持久化操作
6、提交事务
7、关闭Session

二、对应数据库操作的增，改，删：
Session.save(Object o)  
Session.update(Object o)
Session.delete(Object o)
Session.saveOrUpdate(Object o)

三、hibernate中的查询可以使用以下方法：
1、HQL语句
（1）构造查询的HQL语句
（2）使用Session的createQuery(String HQL)生成Query对象。
（3）使用Query对象的setString(0,"Tom")方法为HQL语句的占位符赋值。
（4）使用Query的list()方法获得查询结果集。
2、使用load()或get()方法来通过OID加载一个持久化对象
load()或get()方法区别：
（1）当指定的OID对象不存在，load()会抛出异常，而get()方法会返回一个null。
（2）load()默认使用延时检索策略，除非在类的映射配置文件中的class节点加入laze="false"属性，而get()方法无论如何都会使用立即检索策略。
（3）当加载对象是为了使用它的各个属性的时候就使用get()方法，而如果只是为了删除对象或者建立与其它对象的关联，则使用load()对象。
3、通过Criteria等接口和类进行查询
(1)详细内容看知识点三十四。
4、使用原生SQL语言进行查询
5、使用对象导航进行查询

四、Query对象返回唯一结果方法：
Object Query.uniqueResult();

五、主键生成策略中generator的class属性的常用四种取值：
assigned   指定 
identity   MSSQL自动生成主键
sequence   Oracle序列生成主键
increment  由hibernate生成主键
native  根据数据库自行选择生成方式

六、使用hibernate的基本语句
//读取并解析配置文件
Configuration config = new Configuration().configure();
//获取SessionFactory对象
SessionFactory factory = config.buildSessionFactory();
//打开Session
Session session = factory.openSession();
//开启事务
Transaction tran = session.beginTransaction();
//持久化操作
session.save(new Object());
//提交事务
tran.commit();
//关闭Session
session.close();

七、hibernate的三种加锁方法
1、Query.setLockMode(String 对象别名,LockMode arg1);
2、Criteria.setLockMode(LockMode arg1);
3、Session.lock(Object arg1,LockMode arg2);

Hibernate 的加锁模式有：
LockMode.NONE ： 无锁机制。
LockMode.WRITE ： Hibernate 在 Insert 和 Update 记录的时候会自动 获取。
LockMode.READ ： Hibernate 在读取记录的时候会自动获取。 以上这三种锁机制一般由 Hibernate 内部使用，如 Hibernate 为了保证 Update过程中对象不会被外界修改，会在 save 方法实现中自动为目标对象加上 WRITE 锁。
LockMode.UPGRADE ：利用数据库的 for update 子句加锁。
LockMode. UPGRADE_NOWAIT ： Oracle 的特定实现，利用 Oracle 的 forupdate nowait 子句实现加锁。

八、实体对象的三种状态：
1、自由状态   没有与任何Session对象关联
2、持久状态   与某个Session对象关联，在数据库中有相应记录
3、游离状态   没有与任何Session对象关联，但在数据库中有相应记录

九、使用ThreadLocal对象对Session对象进行管理。
由于Session不支持多线程共享，所以为了减少Session的频繁创建和销毁，可以使用ThreadLocal对象对Session对象进行管理。ThreadLocal对象不是线程对象的实例，它的作用是创造和分配Session对象的副本。以下代码就是使用ThreadLocal对象的关键代码：
//创建ThreadLocal对象
private static final ThreadLocal s = new ThreadLocal();
//分配Session对象副本
session = (Session)s.get();
//如果ThreadLocal对象当前没有包含Session对象
if(session==null){
//开启一个Session对象
session = factory.openSession();
//放到ThreadLocal对象中
s.set(session);
}
 
十、openSession()和getCurrentSession()方法的区别：
1、要使用getCurrentSession()方法需要在hibernate.cfg.xml配置文件中添加以下配置
<property name="hibernate.current_session_context_class">thread</property>
2、getCurrentSession()方法创建的Session会自动绑定当前线程，而openSession()则不会。
3、openSession()创建的Session需要手动关闭，而getCurrentSession()方法创建的Session会在事务提交或回滚的时候自动关闭。
4、getCurrentSession()方法是首选获得Session的方法。

十一、save()方法和persist()方法区别
1、save()方法中的自增主键是在调用该方法的时候就已经分配，而persist()方法则可能是在提交事务时才分配。（后者适合长事务）
2、save()方法放在开启事务语句之前或之后，在提交事务时都会产生插入语句，而persist()方法如果放在开启事务语句之前则不会产生插入语句。

十二、hibernate处理Blob类型数据的方法。
1、输入Blob数据
//创建输入流
InputStream in = this.getClass().getResourceAsStream("FilePath");
//创建用于存放二进制数据的字节数组
byte[] buffer = new byte[in.available];
//把二进制数据读入字节数组
in.read(buffer);
//关闭输入流
in.close();
2、输出Blob数据
//从对象中获得Blob类型的数据
Blob image = Login.getImage();
//建立一个输入流
InputStream in = image.getBinaryStream();
//建立一个输出流
OutputStream out = new FileOutputStream("filepath");
//把输入流的数据输出到指定的文件中
int n = -1 ;
while((n = in.read())!=-1){
 out.write(n);
}
//关闭流对象
in.close();
out.close();

十三、hibernate处理Clob数据类型的方法
1、使用hibernate提供的字符串转换为Clob类型方法即可实现保存Clob数据：
Clob Hibernate.createClob(String Description);
2、把Clob类型的数据转换为字符串需要借助Reader对象：
Clob desc = login.getDescription();  //获取Clob数据
Reader rd = desc.getCharacterStream(); //把Clob数据转换成Reader对象
BufferedReader br = new BufferedReader(rd); //包装Reader对象
String sdesc = br.readLine();  //读取Reader对象到字符串中

十四、Set对象的特性
1、HashSet对象的存储特性
把"hello","hello","goodbye"三个字符串存到HashSet对象中时，实际上存到对象中的数据只有两个，因为Set是无序不重复集合，所以当数据存到Set集合中时，它就会先调用equals方法来对比该数据是否已存在集合中，如果发现该数据和集合中的某个数据相等，就不会把该数据插入到集合中。
2、TreeSet对象具有排序功能（自然排序或者客户化排序）
（1）插入到TreeSet中的对象都必须是实现Comparable接口的相同数据类型的对象。（可比较的对象）
（2）要想实现客户化排序，则对象需要实现comparator接口，该接口中有个compare方法，我们通过实现这个方法来定义我们客户化的排序规则。

十五、持久化对象中包含Set集合类型属性的映射文件配置方法：
（1）在持久化对象的映射文件中加入以下内容，代替原来的<property>...</property>
<set name="images" table="IMAGE" laze="true">
 <key column="USERID"/>
 <!--FILENAME是IMAGE表与images属性的关联字段-->
 <element column="FILENAME" type="string" not-null="true" />
</set>
（2）为什么不使用<one-to-many>等标签：
这是因为IMAGE不是一个单独的持久化对象，所以他们之间没有一对多等关系。一对多，多对一是针对持久化对象之间而言的。

十六、持久化对象中包含List集合类型属性的映射文件配置方法：
与Set集合类似，但需要在<list>节点下增加<list-index column="数据库对应字段名" /> ,完整配置语句如下：
<list name="images" table="IMAGE" laze="true">
 <key column="USERID"/>
 <!--FILENAME是IMAGE表与images属性的关联字段-->
 <list-index column="数据库对应字段名" />
 <element column="FILENAME" type="string" not-null="true" />
</list>

十七、持久化对象中包含Map集合类型属性的映射文件配置方法：
与Set集合类似，但需要在<Map>节点下增加<Map-key column="数据库对应字段名" type="" /> ,完整配置语句如下：
<map name="images" table="IMAGE" laze="true">
 <key column="USERID"/>
 <!--FILENAME是IMAGE表与images属性的关联字段-->
 <Map-key column="数据库对应字段名" type="" />
 <element column="FILENAME" type="string" not-null="true" />
</map>
注意：map集合对象不能够进行迭代输出，必须转换成Set等集合对象才可以。map集合对象有一个keySet()方法，可以返回键的Set集合。

十八、主动方和被动方的区分：
主动方和被动方可以通过数据库来区分，具有外键的表就是被动方。

十九、一对多单向关联操作步骤如下：
1、在持久化类中添加一个集合对象。
2、在对应的映射文件的class节点下增加如下内容：
<set name="集合属性名" >
     <key column="该对象的主键" />
     <one-to-many class="集合属性对应的全限定类名"  />
</set>

二十、多对一单项关联操作步骤如下：
1、在持久化类中添加一个该类型（“一”对应的类型）的属性。
2、在对应的映射文件的class节点下增加如下内容：
<many-to-one name="属性名" class="属性对应的全限定类名">
     <column name="外键名称" />
</many-to-one>

二十一、级联操作属性设置：
1、对于一对多或者多对一的两个持久化对象，在建立了两个对象的关联关系之后，在没有使用级联操作的时候，我们是需要调用session对象的save()方法对两个对象进行分别持久化保存操作，但是因为这两个对象是有关系的，所以我们可以使用级联属性cascade来简化我们的操作，cascade属性有四个取值：none(默认)，save-update(只在保存和更新操作才使用级联)，delete(在删除操作中使用级联），all(在所有情况下都使用级联)。
2、inverse属性是“反转”的意思，它的取值有两个true和false，当取值为false(默认)时，则不放弃维护关联关系责任，取值为true时则会放弃维护关联关系责任，那样就不会产生多余的更新语句。
3、cascade属性可以放在<set>标签中，也可以放在<many-to-one>标签中。而inverse属性只能放在集合的标签中，所以inverse只能放在<set>中。

二十二、一对一双向关联操作步骤如下：
1、首先需要在两个持久化类中添加对方类型的属性。
2、然后在主动方映射文件的<class>节点下加入以下内容：
<one-to-one name="添加属性的名称" class="该属性对应的全限定类名"  property-ref="主动方属性名"/>
其中的property-ref属性可选，但是如果不添加该属性，则通过主动方不能导航到被动方。
3、在被动方的映射文件中的<class>节点添加如下内容：
<many-to-one name="添加属性的名称" class="该属性对应的全限定类名" unique="true" >
   <column name="外键名称" />
</many-to-one>

二十三、多对多双向关联操作步骤如下：
1、首先需要在两个持久化类中添加集合的属性。
2、然后在映射文件中的<class>节点下添加如下内容：
<set name="添加的属性" table="中间表"  >
   <key column="与中间表发生关系的该映射文件对象主键" >
   <many-to-many class="添加属性的全限定类名"  column="与中间表发生关系的前面类的主键" />
</set>

二十四、query类的三个返回结果的方法：
1、list();  返回list集合
2、iterate(); 返回迭代对象
3、uniqueResult;返回唯一结果对象
list()和iterate()方法区别？
list()方法会一次在数据库中把符合条件的对象的所有属性都查询出来；
iterate()方法则会把符合条件的对象的id字段查询出来，然后在缓存中查询这些id的对象，如果查询不到，才会在数据库中查询。
两种方法应该如何选择？
首先list()方法
如果要查询的对象属性较多，或者大部分数据已经存在缓存中，则可以选择使用iterate()方法。

二十五、查询对象的部分属性的方法：
1、在hql语句中指定要查询的属性：String hql = "select sid,sname from student" ;
使用该方法查询出来的结果是对象数组类型Object[],Object[0]为sid，Object[1]为sname 。
2、通过构造方法进行属性查询： String hql = "select new student(sid,sname) from student" ;
使用该方法查询出来的结果是对象student 。 使用该方法的前提是要在持久化类中添加相应的构造方法。

二十六、hql语句实现更新和删除：
1、语法和sql语句类似。
2、需要调用query的executeUpdate()方法，返回值是整型，代表影响的记录数。（和查询时调用的方法不一样）

二十七、hql添加参数的两种方法：
首先：命名参数
String hql = "from Student where sname=:sname" ; //命名参数需要使用冒号
query.setString("sname","小米");  //为命名参数赋值
其次：占位符
String hql = "from Student where sname=?" ; //使用?作为占位符
query.setString(0,"小米");  //下标从0开始
另外:
query.setParameter("sname","小米"); //绑定任意类型的参数。

二十八、hql排序
1、和sql排序基本相同
2、String hql = "from Student order by sname,sid desc" ; //首先按照sname进行升序排列，如果sname相同的则按照sid进行降序排列

二十九、使用query实现分页的步骤：
1、首先计算总的记录数：List.size();
2、计算总的页数：总记录数/每页记录数，整除就去取结果，不整除就取结果+1，最后一页不满页。
3、使用query.setFirstResult((页码-1)*每页记录数)
4、使用query.setMaxResults(每页记录数);
5、List results = query.list();

三十、hql语句连接查询：
1、和sql一样分为，内连接和外连接(左，右，全)
2、内连接语句：String hql = "from Grade g inner join g.students " ; //students是Grade类的集合属性。inner可以省略
3、外连接语句：String hql = "from Grade g left outer join g.students " ; //students是Grade类的集合属性。outer可以省略

三十一、检索的作用域：类级别和关联级别
1、类级别的检索是指针对当前对像，可以选择立即检索和延迟检索，默认延迟检索，这种级别的检索只对load()有效。使用get()方法对于当前对象总是立即加载，是否立即加载关联对象则需要根据配置中的lazy取值。
2、get()方法总是立即加载，返回实体类对象。load如果选择立即加载就直接返回实体类对象，如果选择延迟加载则返回实体的代理类实例，代理类实例是指，该实例拥有类的所有方法，而且该代理类初始化了实例的ID，当需要查询该对象的除ID外的信息，才通过ID对数据库进行查询。
3、关联级别的检索对get()、load()、HQL、QBC都有效。

三十二、batch-size的用法
如果选择立即加载，则可能每次会产生n+1条查询语句，但是通过在<set></set>节点中加入属性batch-size，则可以减少查询语句的数量，合理取值是2-10。当batch-size取值为3时，则会查询语句就会是这样子："from Student where s.gid in(1,2,3)"  。

三十三、fetch的作用和取值
1、fetch的作用是决定加载关联对象的采取的方法。
2、有三个取值:select 、subselect、join 。
（1）select（默认值）加载关联对象使用select语句。
（2）subselect加载关联对象使用带子查询的查询语句。"from Student s where s.gid in(select g.gid from Grade g) " ;
（3）join加载关联对象使用迫切左外连接，因此使用该取值的时候，一定是使用立即加载。lazy取值被忽略。使用该取值只能使用load或者get方法查询，而不能使用hql语句。

三十四、Criteria查询
1、与query类似，也是通过session对象创建sessio.createCriteria(查询对象.class) ; //得到一个Criteria对象
2、与query类似，通过Criteria对象的list()方法来获取List结果集。不添加查询条件时，就会得到该对象的全部数据。
3、如果需要加入条件则可以使用Criteria的add()方法和Restrictions的静态方法，
   例如:Criteria.add(Restrictions.eq("username","马达"));  //多个查询条件就通过多个add()语句。
4、要在Criteria查询中使用“或” ，则也可以使用Restrictions提供的or方法，例如：
Criteria.add(Restrictions.or(Restrictions.eq("username","马达"),Restrictions.like("username","马%"))）;
5、Criteria查询也支持直接添加sql语句条件，例如：
Criteria.add(Restrictions.sqlRestriction("username='马达' or username like '马%'")）;
6、结果集进行排序的方法：使用Criteria的addOrder()的方法，例如：
Criteria.addOrder(Order.asc("age")) ;  //对查询结果按照年龄升序排列。
7、还可以使用Example对象来构建查询条件：
Login login = new Login();
login.setAge(21);   //不能使用对象的主键
Criteria.add(Example.create(login)) ;
8、Criteria查询的分组，统计功能：
(1)统计记录行数：
Criteria.setProjection(Projections.rowCount());  //最终返回结果List()集合只有一个结果
(2)统计最大值、最小值、平均值
Criteria.setProjection(Projections.max("Age"));
Criteria.setProjection(Projections.min("Age")); 
Criteria.setProjection(Projections.avg("Age"));
(3)分组
Criteria.setProjection(Projections.groupProperty("userName")); //按照userName来分组
(4)统计某个字段的非空记录数
Criteria.setProjection(Projections.count("userName"));
(5)求和
Criteria.setProjection(Projections.sum("score"));
(6)一次统计多个结果
Criteria.setProjection(Projections.projectionList().add(Projections.sum("score")).add(Projections.count("userName")));
(7)分页
与query类似，利用Criteria.setFirstResult()和Criteria.setMaxResults()方法就可以实现分页

三十五、使用命名查询步骤：
（1）在配置文件中的<hibernate-mapping></hibernate-mapping>节点下添加<query name="命名"><![CDATA[HQL]]></query> ，上述内容需要和<class></class>并列 。
（2）利用session的getNamedQuery("命名HQL") 来获得Query对象 。
（3）其余步骤与普通HQL查询类似 。（参数赋值，获取结果，迭代输出）

三十六、本地SQL查询步骤：
1、使用本地SQL不能使用Query对象，需要使用SQLQuery对象，而且需要另外建立数据库表和对象的关联，SQLQuery对象也是通过Session对象产生：
String sql = "select {l.*} from Login l where l.username='马达'" ;  //注意{l.*}
SQLQuery query = session.createSQLQuery("sql").addEntity("l",Login.class);

三十七、命名本地SQL查询步骤：
(1)与命名HQL类似,在配置文件中的<hibernate-mapping>节点下添加以下内容：
<sql-query name="findUser">
<![CDATA[select {l.*} from Login l where l.username='马达']]>
<return alias="l" class="com.test.Login" />
</sql-query>
(2)与命名HQL一样，使用session.getNamedQuery("命名SQL") 获得 Query 对象，注意是Query对象，不是SQLQuery对象 。
(3)其余步骤与普通HQL查询类似 。（参数赋值，获取结果，迭代输出）

三十八、定制SQL
定制SQL就是重载session的save(),update(),delete()的方法，重载方法的定义是在配置文件中完成。
（1）对应上述三种方法：
<sql-insert>
 insert into login(password,age,username) values(?,?,?) ;
</sql-insert>

<sql-update>
update login set password=?,age=? where username=?
</sql-update>

<sql-delete>
delete from  login where username=?
</sql-delete>
(2) 其中insert和update 中属性的顺序要和配置文件的顺序一致，而且主键必须放在最后 。

三十九、hibernate批量处理(插入和更新)数据步骤：
1、在hibernate.cfg.xml配置文件中添加如下内容：（插入和更新都需要）
<!--设置JDBC单次批量处理的数目-->
<property name="hibernate.jdbc.batch_size">20</property>
<!--关闭第二级缓存-->
<property name="hibernate.cache.use_second_level_cache">false</property>
2、如果对象采用"identity"标识符生成器，则hibernate无法在JDBC层进行批量插入操作 。（只针对插入）
3、使用变量记录，当session中满20条记录就清理session缓存，提交插入语句 （插入和更新都需要）
if(i%20==0){
session.flush();
session.clear();
}
4、更新操作时，加入对象在数据库的记录特多，假如有十万条，我们就不能够全部加载到session缓存中了。所以要使用以下语句，当用到该对象时才加载：
ScrollableResults logins = session.createQuery("from Login").scroll(ScrollMode.FORWARD_ONLY) ;  //使用该语句可以获得指针

四十、使用hibernate调用存储过程(插入、更新、删除)步骤：
1、CallableStatement cst = session.connection().prepareCall("{call login_insert(?,?,?)}") ;  //获得CallableStatement对象
2、变量赋值  cst.setString(1,"aaa") ;  //注意下标从1开始
3、执行插入  cst.executeUpdate() ;
4、提交事务
5、关闭session

四十一、使用hibernate调用存储过程（查询）步骤：
1、首先存储过程应该是带有游标类型出参的。
2、也是调用session.connection().prepareCall()方法获得CallableStatement对象cst 。
3、注册存储过程出参的类型：
cst.registerOutParameter(1,oracle,jdbc,OracleTypes.CURSOR);
4、调用CallableStatement的execute()方法，cst.execute();
5、然后后的结果集 ResultSet rs = (ResultSet)cst.getObject(1);  //强制类型转换
6、遍历结果集输出rs.next() ,rs.getString("username") ;
7、提交事务
8、关闭session 。

四十二、命名SQL调用存储过程 。
1、对于更新，插入，删除功能的存储过程，其步骤和普通命名SQL类似 。
2、对于带有结果集返回的存储过程则如下所示：
<sql-query name="loginQuery" callable="true">
   {call login_query(?)}
   <return alias="l" class="com.test.Login" />
</sql-query>
3、使用session的getNamedQuery("loginQuery") 获得Query对象
4、然后使用Query对象的list()获得List集合。
5、迭代输出。
6、关闭session 。

四十三、hibernate缓存级别
1、一级缓存，又称为事务级别的缓存，由session来管理，主要作用有两方面：1、减少访问数据库 2、防止脏数据，每次加载对象的时候，session都会建立对象的副本，如果在事务处理过程中，对象发生了变化，和副本不一致了，当提交事务的时候，就算没有调用session的update方法，更新的对象也会提交到数据库中，使得数据库和缓存的对象保持一致 。
2、二级缓存，是针对进程和集群级别的缓存，hibernate并没有提供这个级别的缓存，需要借助外部jar包实现。