hibernate深度学习游离状态 HQL

时间 2019-12-08

标签 hibernate 深度学习游离状态 hql 栏目 Hibernate 繁體版

原文原文链接

当我学完这个以后我仿佛都懂了 = =或许这就是 hibernate的力量吧.

操纵持久化对象（Session）

1.1. 在hibernate中java对象的状态

Hibernate 把对象分为 4 种状态:java

¨ 持久化状态,sql

¨ 临时状态,数据库

¨ 游离状态,数组

¨ 删除状态.缓存

Session 的特定方法能使对象从一个状态转换到另外一个状态session

1.2. 临时对象(transient)

¨ 在使用代理主键的状况下, OID 一般为 nullapp

¨ 不处于 Session 的缓存中函数

¨ 在数据库中没有对应的记录测试

1.2.1. 删除对象(Removed)

¨ OID 不为 nullspa

¨ 从一个 Session实例的缓存中删除

¨ Session 已经计划将其从数据库删除, Session 在清理缓存时, 会执行 SQL delete 语句, 删除数据库中的对应记录

¨ 通常状况下, 应用程序不应再使用被删除的对象

1.2.2. 持久化对象(也叫”托管”)（Persist）

1.2.3.

¨ OID 不为 null

¨ 位于 Session 缓存中

¨ 持久化对象和数据库中的相关记录对应

¨ Session 在清理缓存时, 会根据持久化对象的属性变化, 来同步更新数据库

¨ 在同一个 Session 实例的缓存中, 数据库表中的每条记录只对应惟一的持久化对象

1.2.4. 游离对象(也叫”脱管”)(Detached)

¨ OID 不为 null

¨ 再也不处于 Session 的缓存中

¨ 通常状况需下, 游离对象是由持久化对象转变过来的, 所以在数据库中可能还存在与它对应的记录

1.2.5. 对象的状态转换说明（图）

对象的状态转换图

测试hibernate中java对象的状态

程序代码	生命周期	状态
tx = session.beginTransaction(); Customer c = new Customer);	开始生命周期	临时状态
Session.save(c)	处于生命周期中	转变为持久化状态
Long id=c.getId(); c = null; Customer c2 = (Customer)session.load(Customer.class,id); tx.commit();	处于生命周期中	处于持久化状态
session.close();	处于生命周期中	转变为游离态
c2.getName();	处于生命周期中	处于游离态
c2 = null;	结束生命周期	结束生命周期

1.2.6. 对象的状态总结

	Session缓存存在对应的记录	数据中存在对应的记录
临时态	no	no
持久态	yes	可能有也可能没有
游离态	no	可能有(数据没有删除)也可能没有

1.2.7. 操纵持久化对象的方法（Session中）

1.2.8. save()

Session 的 save() 方法使一个临时对象转变为持久化对象。

¨ Session 的 save() 方法完成如下操做:

把 News 对象加入到 Session 缓存中, 使它进入持久化状态
选用映射文件指定的标识符生成器, 为持久化对象分配惟一的 OID. 在使用代理主键的状况下, setId() 方法为 News 对象设置 OID 使无效的.
计划执行一条 insert 语句,把Customer对象当前的属性值组装到insert语句中

¨ Hibernate 经过持久化对象的 OID 来维持它和数据库相关记录的对应关系. 当 News 对象处于持久化状态时, 不容许程序随意修改它的 ID

@Test

    public void save() throws Exception{

      

       Session session = sessionFactory.openSession();

   

       Transaction tc = null;

       User user = null;

       try {

           tc = session.beginTransaction();

           user = new User();//临时状态

           user.setName("张张");

           session.save(user);//持久化状态

           tc.commit();

       } catch (Exception e) {

           tc.rollback();

           throw e;

       }finally{

           session.close();

       }

       user.setName("王王");//游离状态

       System.out.println(user.getName());

      

    }

1.2.9. update()

Session 的 update() 方法使一个游离对象转变为持久化对象, 而且计划执行一条 update 语句。

@Test

    public void update() throws Exception{

      

       Session session = sessionFactory.openSession();

   

       Transaction tc = null;

       User user = null;

       try {

           tc = session.beginTransaction();

           user = (User) session.get(User.class, 1);

           //session.clear();

           //session.evict(user);//清楚某一个对象。

           user.setName("冯芬1");

 

           //session.update(user);//执行完才提交给数据库

           session.flush();//一执行当即提交

           System.out.println("执行");

           tc.commit();

       } catch (Exception e) {

           tc.rollback();

           throw e;

       }finally{

           session.close();

       }

    

  }Session 的 update() 方法使一个游离对象转变为持久化对象, 而且计划执行一条 update 语句。

若但愿 Session 仅当修改了 News 对象的属性时, 才执行 update() 语句, 能够把映射文件中 <class> 元素的 select-before-update(更新以前先查询) 设为 true. 该属性的默认值为 false

当 update() 方法关联一个游离对象时, 若是在 Session 的缓存中已经存在相同 OID 的持久化对象, 会抛出异常

缘由是:两个不一样的对象拥有相同的OID

当 update() 方法关联一个游离对象时, 若是在数据库中不存在相应的记录, 也会抛出异常

1.2.10. saveOrUpdate()

该方法同时包含save和update方法，若是参数是临时对象就用save方法，若是是游离对象就用update方法，若是是持久化对象就直接返回。

断定对象为临时对象的标准

¨ Java 对象的 OID 为 null

¨ 映射文件中为 <id> 设置了 unsaved-value 属性, 而且 Java 对象的 OID 取值与这个 unsaved-value 属性值匹配(在hbn3中基本用不到了)

@Test

    public void saveOrUpdate() throws Exception {

       Session session = sessionFactory.openSession();

      

       Transaction tc = null;

       User user = null;

       try {

           tc = session.beginTransaction();

           //临时对象执行插入

//        user = new User();

//        user.setName("洋洋");

//        session.saveOrUpdate(user);

           //游离对象执行修改

//        user  = (User) session.get(User.class,1);

//        session.evict(user);

//        session.saveOrUpdate(user);

           //若是是持久化对象就直接返回,不执行操做

           user  = (User) session.get(User.class,1);

           session.saveOrUpdate(user);

          

           tc.commit();

       } catch (Exception e) {

           tc.rollback();

           throw e;

       }finally{

           session.close();

       }

      

    }

若是参数是临时对象就会用save方法

若是是游离对象就用update方法

若是是持久化对象就直接返回,不执行操做

断定对象为临时对象的标准

¨ Java 对象的 OID 为 null

¨ 映射文件中为 <id> 设置了 unsaved-value 属性, 而且 Java 对象的 OID 取值与这个 unsaved-value 属性值匹配,执行插入操做

根据以上判断临时对象的标准id=null是临时对象。但能够定义属性为int id

* 此时id默认值是0而不是null,应该执行更新操做

* 但实际咱们要执行的插入操做。这时,能够在id中设置unsaved-value=0(默认值)

1.2.11. get()、load()

均可以根据给定的 OID 从数据库中加载一个持久化对象

@Test

    public void getOrLoad() throws Exception {

       Session session = sessionFactory.openSession();

      

       Transaction tc = null;

       User user = null;

       try {

           tc = session.beginTransaction();

           //get方式会立刻执行sql语句

           user  = (User) session.get(User.class,1);

           System.out.println("aaaaa");

           System.out.println(user.getName());

           //load方式不会立刻执行sql语句

           user  = (User) session.load(User.class,2);

           System.out.println("bbbbbbbbbbbb");

           System.out.println(user.getName());

           tc.commit();

       } catch (Exception e) {

           tc.rollback();

           throw e;

       }finally{

           session.close();

       }

      

            }

区别:

¨ 当数据库中不存在与 OID 对应的记录时, load() 方法抛出 ObjectNotFoundException 异常, 而 get() 方法返回 null

¨ 二者采用不一样的延迟检索策略

get()：获取数据，是持久化状态

1. 会生成：select ... where id=?

2. 会立刻执行sql语句

3. 若是数据不存在，就返回null

load()：获取数据，是持久化状态

1.会生成：select ... where id=?

2. load()后返回的是一个代理对象，要求类不能是final的，不然不能生成子类代理，就不能使用懒加载功能了。

3.让懒加载失效的方式：1、把实体写成final的；2、在hbm.xml中写<class ... lazy="false">

4. 不会立刻执行sql语句，而是在第1次使用非id或class属性时执行sql。

5. 若是数据不存在，就抛异常：ObjectNotFoundException

1.2.12. delete()

Session 的 delete() 方法既能够删除一个游离对象, 也能够删除一个持久化对象。

¨ 若是参数是持久化对象，就执行一个delete语句，若为游离对象，先使游离对象被session关联，使他变为持久化对象

¨ 计划执行一条 delete 语句

¨ 把对象从 Session 缓存中删除, 该对象进入删除状态.

1.2.13. 与触发器协同工做

Session.save(c);

Session.flush();

Session.refresh(c);

------------------------------------------------------

触发器的行为致使缓存与数据库中的数据不一致。解决办法是执行完

操做后，当即调用session的flush方法和refresh方法，迫使缓存与

数据库同步。

Session的update操做方法盲目的激活触发器

若是游离状态的对象的属性和数据库一致，则更新操做是多余的。

为避免这种状况：

……

</class>

1.2.14. DML（数据操做语言）风格的操做

，Hibernate 提供经过 Hibernate 查询语言（HQL）来执行大

批量 SQL 风格的 DML 语句的方法。

UPDATE 和 DELETE 语句的伪语法为：( UPDATE | DELETE ) FROM? EntityName (WHERE

where_conditions)?。

要注意的事项：

•在 FROM 子句（from-clause）中，FROM 关键字是可选的

•在 FROM 子句（from-clause）中只能有一个实体名，它能够是别名。若是实体名是别名，那么

任何被引用的属性都必须加上此别名的前缀；若是不是别名，那么任何有前缀的属性引用都是

非法的。

•不能在大批量 HQL 语句中使用 joins 链接（显式或者隐式的都不行）。不过在 WHERE 子句中

可使用子查询。能够在 where 子句中使用子查询，子查询自己能够包含 join。

•整个 WHERE 子句是可选的。

使用 Query.executeUpdate() 方法执行一个 HQL UPDATE语句

由 Query.executeUpdate() 方法返回的整型值代表了受此操做影响的记录数量

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

String hqlDelete = "delete Customer c where c.name = :oldName";

// or String hqlDelete = "delete Customer where name = :oldName";

int deletedEntities = s.createQuery( hqlDelete )

.setString( "oldName", oldName )

.executeUpdate();

tx.commit();

session.close();

6.HQL介绍

SQL(表和字段) HQL(对象和属性)

使用HQL查询

HQL: Hibernate Query Language.

特色：

1，与SQL类似，SQL中的语法基本上均可以直接使用。

2，SQL查询的是表和表中的列；HQL查询的是对象与对象中的属性。

3，HQL的关键字不区分大小写，类名与属性名是区分大小写的。

4，SELECT能够省略.

案例：

1，简单的查询

hql = "FROM Employee";

hql = "FROM Employee AS e"; 使用别名

hql = "FROM Employee e"; 使用别名，as关键字可省略

执行查询

List list = session.createQuery(hql).list();

显示结果

while(itr.hasNext()){

                                     //System.out.println(itr.next().getName());

                                     Object[] object =  (Object[]) itr.next();

                                     System.out.println(object[0]+":"+object[1]);

                            }

2，带上过滤条件的（可使用别名）：Where

 hql = "FROM Employee WHERE id<10";

                     hql = "FROM Employee e WHERE e.id<10";

                     hql = "FROM Employee e WHERE e.id<10 AND e.id>5";

3，带上排序条件的：Order By

        hql = "FROM Employee e WHERE e.id<10 ORDER BY e.name";

                     hql = "FROM Employee e WHERE e.id<10 ORDER BY e.name DESC";

                     hql = "FROM Employee e WHERE e.id<10 ORDER BY e.name DESC, id ASC";

4，指定select子句（不可使用select *）

   hql = "SELECT e FROM Employee e";   至关于"FROM Employee e"

                     hql = "SELECT e.name FROM Employee e";   只查询一个列，返回的集合的元素类型就是这个属性的类型

                     hql = "SELECT e.id,e.name FROM Employee e";   查询多个列，返回的集合的元素类型是Object数组

                     hql = "SELECT new Employee(e.id,e.name) FROM Employee e";   可使用new语法，指定把查询出的部分属性封装到对象中

5，执行查询，得到结果（list、uniqueResult、分页）

Query query = session.createQuery("FROM Employee e WHERE id<3");

                     query.setFirstResult(0);

                     query.setMaxResults(10);

                     List list = query.list();   查询的结果是一个List集合

                     Employee employee = (Employee) query.uniqueResult();  查询的结果是惟一的一个结果，当结果有多个，就会抛异常

                     System.out.println(employee);

6，函数的使用

hql = "select count(id) from Department";

                            Number num =  (Number) session.createQuery(hql).uniqueResult();

                            System.out.println(num);

7，分组查询

hql = "select d.name,count(d.name) from Department d group by d.name";

hql = "select d.name,count(d.name) from Department d group by d.name having count(d.name)>5";

8，参数查询

第一种：使用“？”

hql = "from Department d where d.id between ? and ? ";

List list = session.createQuery(hql)

                            .setParameter(0, 2)

                            .setParameter(1, 8)

                            .list();

第二种：使用变量名

    hql = "FROM Employee e WHERE id BETWEEN :idMin AND :idMax";

                   List list = session.createQuery(hql)//

                   .setParameter("idMax", 15)//

                   .setParameter("idMin", 5)//

         .list();

第三种：当参数是集合时，使用setParameterList()设置参数值

      hql = "FROM Employee e WHERE id IN (:ids)";

                   List list = session.createQuery(hql)//

                   .setParameterList("ids", new Object[] { 1, 2, 3, 5, 8, 100 })//

                   .list();

9在映射文件配置HQL语句

为了使程序具备更大的灵活性，Hibernate能够在映射文件中配置HQL语句。以下所示为在Student.hbm.xml中的配置。

<hibernate-mapping>

     <class name="hibernate.ch06.Student" table="student" catalog="joblog">

          <!--此处省略了配置-->

     </class>

     <query name="searchStudent"><![CDATA[

     from Student s where s.sage>22

     ]]>（<![CDATA[  ]]>表示一些特殊字符不须要转义）

     </query>

</hibernate-mapping>

能够用以下代码访问配置文件中的HQL语句。

Session session=HibernateSessionFactory.currentSession();//建立Session

        Query query=session.getNamedQuery("searchStudent");                   //用getNamedQuery获得查询

        List list=query.list();                                                   //执行查询

        Iterator it=list.iterator();

       

        while(it.hasNext()){

               Student stu=(Student)it.next();

               System.out.println(stu.getSname());

        }

其中，getNamedQuery()函数用来访问映射文件Student.hbm.xml中配置的HQL语句，参数为配置的名称。

Select s.id,s.name, c.name from t_student s,t_classes c where c.id = s.classId

Select s.id,s.name, c.name from t_student s right join t_classes c on s.classtId = c.id;

10.链接查询

   //第一种：(内链接)

                            //hql = "select s.id,s.name,c.name from Student s join s.classes c";

                            //第二种：

                            //hql = "select s.id,s.name,s.classes.name from Student s";

                            //外链接：

hql = "select s.id,s.name,c.name from Student s right join s.classes c";

hql = "select s.id,s.name,c.name from Student s left join s.classes c";

11.更新

             //更新前：

                            Student student = (Student)session.get(Student.class, 2);

                            System.out.println(student.getName());

                            int num = session.createQuery("update Student s set s.name=? where s.id=2")

                            .setParameter(0,"好人1")

                            .executeUpdate();

                            System.out.println(num);

                            //更新后：

                            session.refresh(student);

                            System.out.println(student.getName());

12.删除

/*int num1 = session.createQuery("delete Student s  where s.id=1")

                            .executeUpdate();

                            System.out.println(num1);*/

Criteria查询方式

// 建立Criteria对象

         Criteria criteria = session.createCriteria(Student.class);

                            // 增长过滤条件

                            criteria.add(Restrictions.ge("id", 2));

                            criteria.add(Restrictions.le("id", 5));

 

                            // 增长排序条件

criteria.addOrder(Order.desc("id"));

                            criteria.addOrder(Order.desc("name"));

                                                        // 执行查询

                            // criteria.setFirstResult(0);

                            // criteria.setMaxResults(100);

                            // criteria.uniqueResult();

                            // criteria.list()

                            List list = criteria.list();

                            Iterator  itr = list.iterator();

                            while(itr.hasNext()){

                                    

                                     Student student = (Student)itr.next();

                                     System.out.println(student.getName()+":"+student.getScore());

                            }

写完了今天落枕了起床也是在床底睁开眼歪着脖子写了折磨一一篇, 真难受啊不过这质量算是我写过最棒的一篇了吧.

hibernate深度学习 游离状态 HQL

当我学完这个以后 我仿佛都懂了 = =或许这就是 hibernate的力量吧.