Hibernate_core_method

/**
*CreatedbyAdministratoron2015/11/30.
*HibernateUtil
*/
publicclassHibernateUtil{

privatestaticfinalThreadLocal<Session>threadLocal=newThreadLocal<>();

privatestaticSessionFactorysessionFactory=null;

static{
try{
Configurationconfiguration=newConfiguration().configure();

ServiceRegistryserviceRegistry=newServiceRegistryBuilder()
.applySettings(configuration.getProperties())
.buildServiceRegistry();//你麻痹你就不能写个类把这些方法包装起来！！！

sessionFactory=configuration.buildSessionFactory(serviceRegistry);

}catch(Exceptione){
System.out.println("创建会话工厂失败！");
e.printStackTrace();
}
}

publicstaticSessiongetSession()throwsHibernateException{
Sessionsession=(Session)threadLocal.get();
if(session==null||!session.isOpen()){
if(sessionFactory==null)
rebuildSessionFactory();
session=(sessionFactory!=null)?sessionFactory.openSession():null;
threadLocal.set(session);
}
returnsession;
}

publicstaticvoidrebuildSessionFactory(){
try{
Configurationconfiguration=newConfiguration().configure();
ServiceRegistryserviceRegistry=newServiceRegistryBuilder().applySettings(configuration.getProperties())
.buildServiceRegistry();
sessionFactory=configuration.buildSessionFactory(serviceRegistry);
}catch(Exceptione){
System.out.println("创建会话工厂失败！");
e.printStackTrace();
}
}

publicstaticSessionFactorygetSessionFactory(){
returnsessionFactory;
}

publicstaticvoidcloseSession()throwsHibernateException{
Sessionsession=(Session)threadLocal.get();
threadLocal.set(null);
if(session!=null)
session.close();
}
}

publicclassTest_save{
publicstaticvoidmain(String[]args){
Book2book2=newBook2();
book2.setId(100077);
book2.setBookCount(2000);
book2.setPrice(3000);
book2.setAuthor("zzy");
book2.setName("javaweb");
try{
Sessionsession=HibernateUtil.getSession();
session.beginTransaction();
session.save(book2);
//session.persist(book2);
/****执行save方法使一个临时对象变为持久化对象，且如果是自动生成ID策略，
*save方法后会为对象分配ID。
*在save方法之前设置的ID是无效的。（自动生成ID策略，）
*在save方法之后，即持久化对象的ID是不能被修改的。
*
*和save方法很相似的一个方法是session.persist(book2);
*在peisist方法之前若对象已经有ID了，则不会执行insert，
*而是抛出一个异常。而save方法不会抛出异常
*****/
session.getTransaction().commit();
}catch(Exceptione){
System.out.println("youwanttoinsertisexist!");
e.getMessage();
//return;
}finally{
HibernateUtil.closeSession();
}
System.out.println("successtodoit");
}
}

publicclassTest_get_load{
publicstaticvoidmain(String[]args){
Book2book21;
Sessionsession=HibernateUtil.getSession();
session.beginTransaction();
Book2book2=(Book2)session.get(Book2.class,100002);
System.out.println(book2);
session.getTransaction().commit();
/***load是懒加载，若没用到这个对象，即不会立即执行查询操作。
*get方法是立即加载一个对象。
*使用get方法若数据表中没有对应的记录，则返回一个null值。
*若用load的方法查找，若对象不存在，抛出一个空指针异常。（它是使用代理对象）
*load方法可能会抛出懒加载异常
*****/
try{
session.beginTransaction();
book21=(Book2)session.load(Book2.class,100001);
System.out.println(book21);
session.getTransaction().commit();
}catch(Exceptione){
System.out.println("whatyouwanttoselectisnoexist!");
//return;
}
finally{
HibernateUtil.closeSession();
}
//session.getTransaction().commit();
}
}

publicclassTest_update{
publicstaticvoidmain(String[]args){
try{
/**
*若更新一个持久化对象不需要显示的调用update方法
*因为在session.getTransaction().commit();
*方法之前就会有flush方法对数据库中的数据进行强制刷新
*
*若更新的对象不是持久化对象，即对象不在Session缓存中，
*需要显示的调用Session的update方法。（跟新一个游离对象）
*可以使一个游离对象变成一个持久化对象
*
*无论要跟新的游离对象和数据表中的数据是否一致，都会
*有一条update语句发送。(当有触发器工作的时候就会发生问题。)
*可以在*.hbm.xml文件中class节点中设置一个属性select-before-update="true"
*这样就不会发送update了。
*但通常不需要设置该属性。多发一条select这样效率会变低。
*
*若是一个持久化对象则不会发送update语句。
*
*若数据表中没有对应的记录，还是调用了session的update方法，则会抛出一个异常
*
*在同一个Session实例的缓存中，数据库中的每条记录只对应唯一一个持久化对象。
***/
Sessionsession=HibernateUtil.getSession();
session.beginTransaction();
Book2book2=(Book2)session.get(Book2.class,100002);//此时book2是持久化对象。
book2.setName("zb");
book2.setBookCount(1222);
session.getTransaction().commit();
System.out.println("successtodoit!");
}catch(Exceptione){
System.out.println("whatyouwanttoupdateisnoexist!");
}
finally{
HibernateUtil.closeSession();
}
}
}

publicclassTest_delete{
publicstaticvoidmain(String[]args){
try{
Sessionsession=HibernateUtil.getSession();
session.beginTransaction();
Book2book2=(Book2)session.get(Book2.class,100066);
/**
*只要OID在数据表中有对应的记录则删除这个对象在数据库中的记录。
*不管是游离对象还是持久化对象都会删除。
*若OID在数据表中没有对应的记录则会抛出一个异常。
*可以通过设置hibernate配置文件的一个属性
*<propertyname="use_identifier_rollback">true</property>
*使对象删除后，OID置为空。（实际开发并不常用，所以只是说一下）
**/
session.delete(book2);
//在这里只是准备发送一条delete，而并没有提交事务。所以OID还不为null
session.getTransaction().commit();
//若要删除的对象为空，则抛出一个空指针异常
}catch(Exceptione){
System.out.println("whatyouwanttodeleteisnoexist!");
//return;
}finally{
HibernateUtil.closeSession();
}
}
}

publicclassTest_saveOrUpdate{
publicstaticvoidmain(String[]args){
Book2book2=newBook2();
book2.setId(222223);
book2.setBookCount(2000);
book2.setPrice(3000);
book2.setAuthor("mm");
book2.setName("mm");
try{
Sessionsession=HibernateUtil.getSession();
session.beginTransaction();
/**
*注意，若OID不为空但数据表中还没有和其对应的记录则会抛出一个异常
*OID为空的对象，则执行一个insert操作即save方法。
*若OID不为空，数据表中有对应的记录则执行一个update操作
***/
session.saveOrUpdate(book2);
session.getTransaction().commit();
}catch(Exceptione){
System.out.println("youwanttoinsertisexist!");
e.getMessage();
//return;
}finally{
Hibernate.Hibernate_core_method.HibernateUtil.closeSession();
}
System.out.println("successtodoit");
}
}

publicclassTest_evict{
publicstaticvoidmain(String[]args){
Sessionsession=HibernateUtil.getSession();
session.beginTransaction();
Book2book2=(Book2)session.get(Book2.class,100001);
Book2book22=(Book2)session.get(Book2.class,100002);
book2.setName("lll");
book22.setName("lll");
/**
*从session缓存中把指定的对象移除。。
*则缓存中没有了这个对象，就不发送sql语句了，
*就没有更新。
**/
session.evict(book22);
session.getTransaction().commit();
HibernateUtil.closeSession();
}
}

publicclassTest_connection{
publicstaticvoidmain(String[]args){
Sessionsession=HibernateUtil.getSession();
session.doWork(newWork(){
@Override
publicvoidexecute(Connectionconnection)throwsSQLException{
System.out.print(connection);
///这样就可以使用原生的connection。想干嘛干嘛去。
//可以调用存储过程和批量操作。
}
});
}
}

publicclassTset_Hql{
publicstaticvoidmain(String[]args){
Sessionsession=HibernateUtil.getSession();
List<Book2>zzy=newArrayList<Book2>();
StringHQL="fromBook2bo";
//查询语句.
QueryW=session.createQuery(HQL);
zzy=W.list();
Iterator<Book2>iterator=zzy.iterator();
while(iterator.hasNext())
System.out.println(iterator.next());
}
}

关于hibernate的一级缓存：
flush：是数据表中的记录和Session缓存的对象保持一致，为了保持一致则可能发送对应的sql语句。
1：在Transaction的commit()方法中，先调用Session的flush方法，再提交事务。
2：flush()方法可能会发送sql语句，但是不会提交事务。
3：在未提交事务或显示调用Session.flush方法之前，也可能调用flush()操作。
1）执行HQL或QBC查询，会先进行flush操作以得到最新的记录。
2）若记录的ID由底层数据库的自增方式生成的，则在调用save方法后会立即发送insert语句
因为save方法后必须保持ID是存在的。

默认调用flush方法的情况：
1）显示调用Session的flush方法
2）Transaction的commit()方法中，先调用Session的flush方法，再提交事务。
3）执行HQL,QBC

refresh():会强制发送select语句，以使缓存状态中的对象和数据库表中的数据保持一致。

clear():清空缓存。

临时对象。
不在Session缓存中，在数据库中没有对应的记录。

持久化对象（托管）。
OID不为null，位于Session缓存中，
若在数据库中已经有相对应的记录，持久化对象和数据库中的相关记录对应
Session的flush缓存时，会根据持久化对象的属性变化，来同步跟新数据库。
在同一个Session实例的缓存中，数据库中的每条记录只对应唯一一个持久化对象。

删除对象
在数据库中没有和其对应的OID
不再处于Session缓存中
一般情况下，应用程序不该再使用被删除的对象

游离对象.（脱管）
OID不为null
不在Session缓存中
数据库中可能有其对应的记录。