Hibernate_core_method

/**
 * Created by Administrator on 2015/11/30.
 *HibernateUtil
 */
public class HibernateUtil {

    private static final ThreadLocal<Session>threadLocal=new ThreadLocal<>();

    private static SessionFactory sessionFactory=null;

    static {
        try {
            Configuration configuration = new Configuration().configure();

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

            sessionFactory=configuration.buildSessionFactory(serviceRegistry);

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

    public static Session getSession() throws HibernateException{
        Session session=(Session)threadLocal.get();
        if (session==null||!session.isOpen()) {
            if (sessionFactory == null)
                rebuildSessionFactory();
            session = (sessionFactory != null) ? sessionFactory.openSession() : null;
            threadLocal.set(session);
        }
        return session;
    }

    public static void rebuildSessionFactory(){
        try{
            Configuration configuration = new Configuration().configure();
            ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties())
                    .buildServiceRegistry();
            sessionFactory=configuration.buildSessionFactory(serviceRegistry);
        }catch (Exception e){
            System.out.println("创建会话工厂失败！");
            e.printStackTrace();
        }
    }

    public static SessionFactory getSessionFactory(){
        return sessionFactory;
    }

    public static void closeSession() throws HibernateException{
        Session session=(Session)threadLocal.get();
        threadLocal.set(null);
        if (session!=null)
            session.close();
    }
}

public class Test_save {
    public static void main(String[]args){
        Book2 book2=new Book2();
        book2.setId(100077);
        book2.setBookCount(2000);
        book2.setPrice(3000);
        book2.setAuthor("zzy");
        book2.setName("java web");
        try{
            Session session=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(Exception e){
            System.out.println("you want to insert is exist!");
            e.getMessage();
            //return;
        }finally {
            HibernateUtil.closeSession();
        }
        System.out.println("success to do it");
    }
}

public class Test_get_load {
    public static void main(String[]args){
        Book2 book21;
        Session session=HibernateUtil.getSession();
        session.beginTransaction();
        Book2 book2=(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 (Exception e){
            System.out.println("what you want to select is no exist!");
            //return;
        }
        finally {
            HibernateUtil.closeSession();
        }
        //session.getTransaction().commit();
    }
}

public class Test_update {
    public static void main(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实例的缓存中，数据库中的每条记录只对应唯一一个持久化对象。
             * **/
            Session session = HibernateUtil.getSession();
            session.beginTransaction();
            Book2 book2 = (Book2) session.get(Book2.class, 100002);//此时book2是持久化对象。
            book2.setName("zb");
            book2.setBookCount(1222);
            session.getTransaction().commit();
            System.out.println("success to do it!");
        }catch (Exception e){
            System.out.println("what you want to update is no exist!");
        }
        finally {
            HibernateUtil.closeSession();
        }
    }
}

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

public class Test_saveOrUpdate {
    public static void main(String[]args){
        Book2 book2=new Book2();
        book2.setId(222223);
        book2.setBookCount(2000);
        book2.setPrice(3000);
        book2.setAuthor("mm");
        book2.setName("mm");
        try{
            Session session=HibernateUtil.getSession();
            session.beginTransaction();
            /**
             * 注意，若OID不为空但数据表中还没有和其对应的记录则会抛出一个异常
             * OID为空的对象，则执行一个insert操作即save方法。
             * 若OID不为空，数据表中有对应的记录则执行一个update操作
             * **/
            session.saveOrUpdate(book2);
            session.getTransaction().commit();
        }catch(Exception e){
            System.out.println("you want to insert is exist!");
            e.getMessage();
            //return;
        }finally {
            Hibernate.Hibernate_core_method.HibernateUtil.closeSession();
        }
        System.out.println("success to do it");
    }
}

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

public class Test_connection {
    public static void main(String[]args) {
        Session session = HibernateUtil.getSession();
        session.doWork(new Work() {
            @Override
            public void execute(Connection connection) throws SQLException {
                System.out.print(connection);
                // /这样就可以使用原生的connection。想干嘛干嘛去。
                //可以调用存储过程和批量操作。
            }
        });
    }
}

public class Tset_Hql{
    public static void main(String[]args){
        Session session=HibernateUtil.getSession();
        List<Book2> zzy=new ArrayList<Book2>();
        String HQL="from  Book2 bo";
        //查询语句.
        Query W=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缓存中
数据库中可能有其对应的记录。