1. Hibernate的关联关系映射:(多对多)

1.1 多对多的配置:

步骤一创建实体和映射:

Student:
public class Student {
    private Integer sid;
    private String sname;
    // 学生选择多门课程.
    private Set<Course> courses = new HashSet<Course>();
...
}

Course:
public class Course {
    private Integer cid;
    private String cname;
    // 课程可以被多个学生选择:
    private Set<Student> students = new HashSet<Student>();
...
}

Student.hbm.xml
<hibernate-mapping>
    <class name="cn.demo3.Student" table="student">
        <id name="sid" column="sid">
            <generator class="native"/>
        </id>
        <property name="sname" column="sname"/>
        <!-- 配置多对多关联关系 -->
        <set name="courses" table="stu_cour">
            <key column="sno"/>
            <many-to-many class="cn. demo3.Course" column="cno"/>
        </set>
    </class>
</hibernate-mapping>

Course.hbm.xml
<hibernate-mapping>
    <class name="cn. demo3.Course" table="course">
        <id name="cid" column="cid">
            <generator class="native"/>
        </id>
                <property name="cname" column="cname"/>

        <!-- 配置多对多关联关系映射 -->
        <set name="students" table="stu_cour">
            <key column="cno"/>
            <many-to-many class="cn.itcast. demo3.Student" column="sno"/>
        </set>
    </class>
</hibernate-mapping>

2 抓取策略（优化）

2.1 检索方式

立即检索：立即查询，在执行查询语句时，立即查询所有的数据。
延迟检索：延迟查询，在执行查询语句之后，在需要时在查询。（懒加载）

2.2 检查策略

类级别检索：当前的类的属性获取是否需要延迟。

关联级别的检索：当前类关联另一个类是否需要延迟。

2.3 类级别检索

get：立即检索。get方法一执行，立即查询所有字段的数据。
load：延迟检索。默认情况，load方法执行后，如果只使用OID的值不进行查询，如果要使用其他属性值将查询。

 Customer.hbm.xml  <class  lazy="true | false">   
 lazy 默认值true，表示延迟检索，如果设置false表示立即检索。

@Test
    public void demo02() {
        //类级别
        Session session = factory.openSession();
        session.beginTransaction();

        //1立即
//      Customer customer = (Customer) session.get(Customer.class, 1);
        //2延迟
        Customer customer = (Customer) session.load(Customer.class, 1);



        //打印
        System.out.println(customer.getCid());
        System.out.println(customer.getCname());

        session.getTransaction().commit();
        session.close();
    }

2.4 关联级别检索

2.4.1 一对多或多对多

2.4.1.1 介绍


容器提供两个属性：fetch、lazy
fetch：确定使用sql格式
lazy：关联对象是否延迟。

fetch：join、select、subselect
join：底层使用迫切左外连接
select：使用多个select语句（默认值）
subselect：使用子查询

lazy：false、true、extra

false：立即
true：延迟（默认值）
extra：极其懒惰

2.4.1.2 fetch=”join”


fetch=”join” ，lazy无效。底层使用迫切左外连接，使用一条select将所有内容全部查询。

这里写图片描述

@Test
    public void demo03() {
        //关联级别：一对多，
        // * Customer.hbm.xml  <set fetch="join">
        // *** select语句使用左外连接，一次性查询所有
        Session session = factory.openSession();
        session.beginTransaction();

        //1 查询客户
        Customer customer = (Customer) session.get(Customer.class, 1);
        System.out.println(customer.getCname());

        //2 查询客户订单数
        Set<Order> orderSet = customer.getOrderSet();
        System.out.println(orderSet.size());

        //3 查询客户订单详情
        for (Order order : orderSet) {
            System.out.println(order);
        }


        session.getTransaction().commit();
        session.close();
    }

2.4.1.3 fetch=”select”



当前对象和关联对象使用多条select语句查询。
lazy=”false” , 立即，先查询客户select，立即查询订单select
lazy=”true”,延迟，先查询客户select，需要订单时，再查询订单select
lazy=”extra”，极其懒惰（延迟），先查询客户select，如果只需要订单数，使用聚合函数（不查询详情）

2.4.1.4 fetch=”subselect”



将使用子查询。注意：必须使用Query否则看不到效果。



lazy= 同上

    public void demo04() {
        //关联级别：一对多，
        // 演示3：* Customer.hbm.xml  <set fetch="subselect">
        Session session = factory.openSession();
        session.beginTransaction();

        //1 查询客户
        List<Customer> allCustomer = session.createQuery("from Customer").list();
        Customer customer = allCustomer.get(0);
        System.out.println(customer.getCname());

        //2 查询客户订单数
        Set<Order> orderSet = customer.getOrderSet();
        System.out.println(orderSet.size());

        //3 查询客户订单详情
        for (Order order : orderSet) {
            System.out.println(order);
        }


        session.getTransaction().commit();
        session.close();
    }

2.4.2 多对一

 <many-to-one fetch="" lazy="">  (<one-to-one>)
```    

**fetch取值：join、select**

    join：底层使用迫切左外连接
    select：多条select语句
**lazy取值：false、proxy、no-proxy**





<div class="se-preview-section-delimiter"></div>

false：立即
proxy：采用关联对象类级别检索的策略。


        订单 关联 客户 （多对一）
        订单 立即获得 客户，需要在客户Customer.hbm.xml <class lazy="false"> 
        订单 延迟获得 客户，需要在客户Customer.hbm.xml <class lazy="true"> 


![这里写图片描述](https://img-blog.csdn.net/20180803132131233?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTU1Mjgy/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)

**2.4.2.2   fetch="join"**
   

 - fecth="join" select语句使用左外连接，此时lazy无效。
![这里写图片描述](https://img-blog.csdn.net/20180803132225276?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTU1Mjgy/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)





<div class="se-preview-section-delimiter"></div>

@Test
public void demo05() {
//关联级别：多对一，
// 演示1：* Order.hbm.xml lazy无效
// * 注意：检查Customer.hbm.xml 和 Order.hbm.xml 没有额外的配置
Session session = factory.openSession();
session.beginTransaction();

    //1 查询订单
    Order order = (Order) session.get(Order.class, 1);
    System.out.println(order.getPrice());

    //2 查询订单客户信息
    Customer customer = order.getCustomer();
    System.out.println(customer.getCname());


    session.getTransaction().commit();
    session.close();
}


**2.4.2.3   fetch="select"**

 -     将采用多条select语句，lazy="proxy"是否延迟，取决关联对象 类级别检索策略。
   `lazy="false"`

![这里写图片描述](https://img-blog.csdn.net/20180803132344482?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTU1Mjgy/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
![这里写图片描述](https://img-blog.csdn.net/20180803132411735?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTU1Mjgy/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)






<div class="se-preview-section-delimiter"></div>

2.5 批量查询
--------

当客户 关联查询 订单，给每一个客户生产一个select语句查询订单。批量查询使用in语句减少查询订单语句个数。





<div class="se-preview-section-delimiter"></div>

默认：select * from t_order where customer_id = ?
批量：select * from t_order where customer_id in (?,?,?,?)
<set batch-size="5"> 5表示括号中?个数。


![这里写图片描述](https://img-blog.csdn.net/20180803132712895?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTU1Mjgy/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)





<div class="se-preview-section-delimiter"></div>

@Test
public void demo06() {
//批量查询
Session session = factory.openSession();
session.beginTransaction();

    //1 查询所有客户
    List<Customer> allCustomer = session.createQuery("from Customer").list();

    //2遍历
    for (Customer customer : allCustomer) {
        System.out.println(customer.getCname());
        System.out.println(customer.getOrderSet().size());
    }


    session.getTransaction().commit();
    session.close();
}






<div class="se-preview-section-delimiter"></div>

2.6 检索总结
--------

![这里写图片描述](https://img-blog.csdn.net/20180803152724754?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTU1Mjgy/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)






<div class="se-preview-section-delimiter"></div>

3 查询方式总结
========

**1.通过OID检索（查询）**


 - get（）立即、如果没有数据返回null



 - load（）延迟，如果没有数据抛异常。

**2.导航对象图检索方式：关联查询**






<div class="se-preview-section-delimiter"></div>

customer.getOrderSet()





<div class="se-preview-section-delimiter"></div>

user.getPost().getDepartment().getDepName();


**3.原始sql语句**

 - SQLQuery sqlQuery = session.createSQLQuery("sql 语句")   --->表，表字段（列）
        sqlQuery.list() 查询所有        sqlQuery.uniqueResult() 查询一个

**4.HQL，hibernate query language hibernate 查询语言【1】**

 - Query query = session.createQuery("hql语句")  --> 对象，对象属性

**5.QBC，query by criteria 纯面对对象查询语言【2】**





<div class="se-preview-section-delimiter"></div>

4 HQL【掌握】
---------
**4.1介绍**
![这里写图片描述](https://img-blog.csdn.net/20180803153846355?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTU1Mjgy/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
**4.2   查询所有客户**





<div class="se-preview-section-delimiter"></div>

@Test
public void demo01(){
//1 查询所有
Session session = factory.openSession();
session.beginTransaction();

    //1  使用简单类名 ， 存在自动导包
    // * Customer.hbm.xml <hibernate-mapping auto-import="true">

// Query query = session.createQuery(“from Customer”);
//2 使用全限定类名
Query query = session.createQuery(“from com.a_init.Customer”);

    List<Customer> allCustomer = query.list();
    for (Customer customer : allCustomer) {
        System.out.println(customer);
    }

    session.getTransaction().commit();
    session.close();
}

**4.3   选择查询**





<div class="se-preview-section-delimiter"></div>

@Test
public void demo02(){
//2 简单条件查询
Session session = factory.openSession();
session.beginTransaction();

    //1 指定数据，cid OID名称
    Query query = session.createQuery("from Customer where cid = 1");
    //2 如果使用id，也可以（了解）
    Query query = session.createQuery("from Customer where id = 1");
    //3 对象别名 ,格式： 类 [as] 别名
    Query query = session.createQuery("from Customer as c where c.cid = 1");
    //4 查询所有项，mysql--> select * from...
    Query query = session.createQuery("select c from Customer as c where c.cid = 1");

    Customer customer = (Customer) query.uniqueResult();
    System.out.println(customer);

    session.getTransaction().commit();
    session.close();
}


**4.4   投影查询（部分）**





<div class="se-preview-section-delimiter"></div>

@Test
public void demo04(){
//4 投影
Session session = factory.openSession();
session.beginTransaction();

    //1 默认
    //如果单列 ，select c.cname from，需要List<Object>
    //如果多列，select c.cid,c.cname from ，需要List<Object[]>  ,list存放每行，Object[]多列

// Query query = session.createQuery(“select c.cid,c.cname from Customer c”);
//2 将查询部分数据，设置Customer对象中
// * 格式：new Customer(c.cid,c.cname)
// * 注意：Customer必须提供相应的构造方法。
// * 如果投影使用oid，结果脱管态对象。
Query query = session.createQuery(“select new Customer(c.cid,c.cname) from Customer c”);

    List<Customer> allCustomer = query.list();
    for (Customer customer : allCustomer) {
        System.out.println(customer.getCid() + " : " + customer.getOrderSet().size());
    }

    session.getTransaction().commit();
    session.close();
}

**4.5   排序**





<div class="se-preview-section-delimiter"></div>

@Test
public void demo03(){
//3排序，mysql–> select… order by 字段 [asc]|desc ,….
Session session = factory.openSession();
session.beginTransaction();

    Query query = session.createQuery("from Customer order by cid desc");

    List<Customer> allCustomer = query.list();
    for (Customer customer : allCustomer) {
        System.out.println(customer.getCid());
    }

    session.getTransaction().commit();
    session.close();
}


**4.6   分页**





<div class="se-preview-section-delimiter"></div>

@Test
public void demo05(){
//分页
Session session = factory.openSession();
session.beginTransaction();

    Query query = session.createQuery("from Customer");
    // * 开始索引 , startIndex 算法： startIndex = (pageNum - 1) * pageSize;
    // *** pageNum 当前页（之前的 pageCode）
    query.setFirstResult(0);
    // * 每页显示个数 ， pageSize
    query.setMaxResults(2);

    List<Customer> allCustomer = query.list();
    for (Customer customer : allCustomer) {
        System.out.println(customer.getCid());
    }

    session.getTransaction().commit();
    session.close();
}


**4.7   绑定参数**





<div class="se-preview-section-delimiter"></div>

@Test
public void demo06(){
/* 6 绑定参数
* 方式1：占位符，使用? 在hql语句替换具体参数
* 设置参数 query.setXxx(int , object)
* 参数1：?位置，从0开始。
* 参数2：实际参数
* 例如：String –> query.setString(int,String)
* 方式2：别名 , 格式 “属性= :别名 ”
* 设置参数 query.setXxx(String,object)
* 参数1：别名
* 参数2：实际参数
* 例如：Integer –> query.setInteger(String,Integer)
* 提供公共设置方法
* setParameter(int|string , Object)
*/
Session session = factory.openSession();
session.beginTransaction();

    Integer cid = 1;

    //方式1

// Query query = session.createQuery(“from Customer where cid = ?”);
// query.setInteger(0, cid);
//方式2
Query query = session.createQuery(“from Customer where cid = :xxx”);
// query.setInteger(“xxx”, cid);
query.setParameter(“xxx”, cid);

    Customer customer = (Customer) query.uniqueResult();
    System.out.println(customer);

    session.getTransaction().commit();
    session.close();
}


**4.8   聚合函数和分组**





<div class="se-preview-section-delimiter"></div>

@Test
public void demo07(){
/* 7 聚合函数
*/
Session session = factory.openSession();
session.beginTransaction();

    //1 
    Query query = session.createQuery("select count(*) from Customer");
    //2 别名
    Query query = session.createQuery("select count(c) from Customer c");
    //3 oid
    Query query = session.createQuery("select count(cid) from Customer");

    Long numLong = (Long) query.uniqueResult();
    int num = numLong.intValue();

    System.out.println(num);


    session.getTransaction().commit();
    session.close();
}


**4.9   连接查询**

![这里写图片描述](https://img-blog.csdn.net/20180803154812448?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxOTU1Mjgy/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)

1.交叉连接 ，等效 sql 笛卡尔积
2.隐式内连接，等效 sql 隐式内连接
3.内连接，等效sql内连接
4.迫切内连接，hibernate底层使用 内连接。
5.左外连接，等效sql左外连接
6.迫切左外连接，hibernate底层使用 左外连接
7.右外连接，等效sql右外连接


内连接和迫切内连接？
左外连接和迫切左外连接？






<div class="se-preview-section-delimiter"></div>

@Test
public void demo08(){
/* 8 链接查询：左外连接和迫切左外连接？
* * 左外连接 , left outer join
* 底层使用sql的左外连接，hibernate进行数据自动封装，将一条记录，封装给两个对象（Customer，Order）
* 将两个对象添加到一个对象数组中Object[Customer,Order]
* * 迫切左外链接 left outer join fetch
* 底层使用sql的左外连接，hibernate将一条记录封装给Customer，讲order数据封装Order，并将order关联到Customer
* customer.getOrderSet().add(order)
* 默认查询的数据重复
*/
Session session = factory.openSession();
session.beginTransaction();

    //左外连接

// List list = session.createQuery(“from Customer c left outer join c.orderSet “).list();
//迫切左外链接 (默认数据重复)
// List list = session.createQuery(“from Customer c left outer join fetch c.orderSet “).list();
//迫切左外链接 (去重复)
List list = session.createQuery(“select distinct c from Customer c left outer join fetch c.orderSet “).list();

    session.getTransaction().commit();
    session.close();
}

“`

4.10 命名查询

@Test
    public void demo08(){
        /* 8 链接查询 ： 左外连接和迫切左外连接？
         * * 左外连接 , left outer join
         *      底层使用sql的左外连接，hibernate进行数据自动封装，将一条记录，封装给两个对象（Customer，Order）
         *      将两个对象添加到一个对象数组中Object[Customer,Order]
         * * 迫切左外链接 left outer join fetch
         *      底层使用sql的左外连接，hibernate将一条记录封装给Customer，讲order数据封装Order，并将order关联到Customer
         *          customer.getOrderSet().add(order)
         *      默认查询的数据重复
         */
        Session session = factory.openSession();
        session.beginTransaction();

        //左外连接
//      List list = session.createQuery("from Customer c left outer join c.orderSet ").list();
        //迫切左外链接 (默认数据重复)
//      List list = session.createQuery("from Customer c left outer join fetch c.orderSet ").list();
        //迫切左外链接 (去重复)
        List list = session.createQuery("select distinct c from Customer c left outer join fetch c.orderSet ").list();


        session.getTransaction().commit();
        session.close();
    }

4.10 命名查询

 思想：将HQL从java源码中，提取到配置文件中。
 分类：全局、布局
 配置

 全局：*.hbm.xml   <class></class><query name="名称">HQL语句

 局部： <class name="" table=""><id><property> <query name="">HQL</class>

获得

    全局：
        session.getNamedQuery("queryName")
    局部：
        session.getNamedQuery("className.queryName")  需要使用类的全限定名称

这里写图片描述

@Test
    public void demo09(){
        /* 9 命名查询
         */
        Session session = factory.openSession();
        session.beginTransaction();

        //全局
        //List list = session.getNamedQuery("findAll").list();
        //局部
        List list = session.getNamedQuery("com.itheima.a_init.Customer.findAll").list();

        System.out.println(list.size());

        session.getTransaction().commit();
        session.close();
    }

5 QBC【了解】

略

6 常见配置

6.1 整合c3p0(连接池) （了解）


- 整合c3p0
这里写图片描述
步骤一：导入c3p0 jar包

步骤二：hibernate.cfg.xml 配置

 hibernate.connection.provider_class org.hibernate.connection.C3P0ConnectionProvider

6.2 事务

6.2.1 回顾

事务：一组业务操作，要么全部成功，要么全部不成功。
特性：ACID

原子性：整体
一致性：数据
隔离性：并发
持久性：结果

隔离问题：

脏读：一个事务读到另一个事务未提交的内容
不可重复读：一个事务读到另一个事务已提交的内容（insert）
虚读（幻读）：一个事务读到另一个事务已提交的内容（update）



隔离级别–解决问题

read uncommittd，读未提交。存在3个问题。
read committed，读已提交。解决：脏读。存在2个问题。
repeatable read ，可重复读。解决：脏读、不可重复读。存在1个问题。
serializable，串行化。单事务。没有问题。

这里写图片描述

6.2.2 hibernate设置隔离级别

 在hibernate.cfg.xml 配置 hibernate.connection.isolation 4

6.2.3 lost update 丢失更新
这里写图片描述

悲观锁：丢失更新肯定会发生。
采用数据库锁机制。

读锁：共享锁

select .... from  ... lock in share mode;

写锁：排他锁。（独占）

select ... from  ....  for update

这里写图片描述

 乐观锁：丢失更新肯定不会发生在表中提供一个字段（版本字段），用于标识记录。
如果版本不一致，不允许操作。

这里写图片描述

Hibernate框架之入门day03

1. Hibernate的关联关系映射:(多对多)

1.1 多对多的配置:

2 抓取策略（优化）

2.1 检索方式

2.2 检查策略

2.3 类级别检索

2.4 关联级别检索

5 QBC【了解】

6 常见配置

6.1 整合c3p0(连接池) （了解）

6.2 事务

猜你喜欢