Hibernate 04

来源：互联网发布：linux udp 端口检测编辑：程序博客网时间：2024/06/06 01:52

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.itcast.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.itcast. demo3.Course" column="cno"/>        </set>    </class></hibernate-mapping>Course.hbm.xml<hibernate-mapping>    <class name="cn.itcast. 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表示立即检索。
即lazy:false load方法执行就会发送sql语句与get效果一样

这里写图片描述

@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 介绍
 容器<set> 提供两个属性：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= 同上

@Test    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 多对一
2.4.2.1 介绍


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

 fetch取值：join、select
join：底层使用迫切左外连接
select：多条select语句
 lazy取值：false、proxy、no-proxy
false：立即
proxy：采用关联对象类级别检索的策略。
订单关联客户（多对一）
订单立即获得客户，需要在客户Customer.hbm.xml <class lazy="false">
订单延迟获得客户，需要在客户Customer.hbm.xml <class lazy="true">

no-proxy 不研究

2.4.2.2 fetch=”join”
 fecth=”join” select语句使用左外连接，此时lazy无效。

@Test    public void demo05() {        //关联级别：多对一，        // 演示1：* Order.hbm.xml  <set fetch="join">  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”

 lazy=”proxy”

2.5 批量查询
 当客户关联查询订单，给每一个客户生产一个select语句查询订单。批量查询使用in语句减少查询订单语句个数。
默认：select * from t_order where customer_id = ?
批量：select * from t_order where customer_id in (?,?,?,?)
 <set batch-size="5"> 5表示括号中?个数。

@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();    }

2.6 检索总结

检索策略优点缺点优先考虑使用的场合
立即检索对应用程序完全透明，不管对象处于持久化状态还是游离状态，应用程序都可以从一个对象导航到关联的对象 (1)select语句多
(2)可能会加载应用程序不需要访问的对象，浪费许多内存空间。 (1)类级别
(2)应用程序需要立即访问的对象
(3)使用了二级缓存
延迟检索由应用程序决定需要加载哪些对象，可以避免执行多余的select语句，以及避免加载应用程序不需要访问的对象。因此能提高检索性能，并节省内存空间。应用程序如果希望访问游离状态的代理类实例，必须保证她在持久化状态时已经被初始化。 (1)一对多或者多对多关联
(2)应用程序不需要立即访问或者根本不会访问的对象

表连接检索 (1)对应用程序完全透明，不管对象处于持久化状态还是游离状态，都可从一个对象导航到另一个对象。
(2)使用了外连接，select语句少 (1)可能会加载应用程序不需要访问的对象，浪费内存。
(2)复杂的数据库表连接也会影响检索性能。 (1)多对一或一对一关联
(2)需要立即访问的对象
(3)数据库有良好的表连接性能。

Customer Get(int id)
Return Session.load(Customer.class,id);
1. layz=false
2. 在Service层获得在页面要上要用到的属性=> 在Service层中确保数据已经
3 查询方式总结
1.通过OID检索（查询）
get（）立即、如果没有数据返回null
load（）延迟，如果没有数据抛异常。
2.导航对象图检索方式：关联查询
customer.getOrderSet()
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】

4 HQL【掌握】
4.1 介绍

4.2 查询所有客户

@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.itheima.a_init.Customer");        List<Customer> allCustomer = query.list();        for (Customer customer : allCustomer) {            System.out.println(customer);        }        session.getTransaction().commit();        session.close();    }

4.3 选择查询

@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 投影查询（部分）

@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 排序

@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 分页

@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 绑定参数

@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 聚合函数和分组

@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 连接查询

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

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

@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【了解】

5.1.1.1 QBC查询:
QBC:Query By Criteria条件查询.面向对象的查询的方式.
5.1.1.2 QBC简单的查询:

// 简单查询:        List<Customer> list = session.createCriteria(Customer.class).list();        for (Customer customer : list) {            System.out.println(customer);        }5.1.1.3 QBC分页的查询:        Criteria criteria = session.createCriteria(Order.class);        criteria.setFirstResult(10);        criteria.setMaxResults(10);        List<Order> list = criteria.list();5.1.1.4 QBC排序查询:        Criteria criteria = session.createCriteria(Customer.class);//      criteria.addOrder(org.hibernate.criterion.Order.asc("age"));        criteria.addOrder(org.hibernate.criterion.Order.desc("age"));        List<Customer> list = criteria.list();

5.1.1.5 QBC条件查询:

// 按名称查询:        /*Criteria criteria = session.createCriteria(Customer.class);        criteria.add(Restrictions.eq("cname", "tom"));        List<Customer> list = criteria.list();*/        // 模糊查询;        /*Criteria criteria = session.createCriteria(Customer.class);        criteria.add(Restrictions.like("cname", "t%"));        List<Customer> list = criteria.list();*/        // 条件并列查询        Criteria criteria = session.createCriteria(Customer.class);        criteria.add(Restrictions.like("cname", "t%"));        criteria.add(Restrictions.ge("age", 35));        List<Customer> list = criteria.list();

5.1.1.6 离线查询(了解)
 DetachedCriteria 离线查询对象，不需要使用Session就可以拼凑查询条件。一般使用在web层或service层拼凑。将此对象传递给dao层，此时将与session进行绑定执行查询。
 离线查询条件与QBC一样的。

@Test    public void demo10(){        /* 10 离线查询         */        //web & service        DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);        detachedCriteria.add(Restrictions.eq("cid", 1));        //---------------dao        Session session = factory.openSession();        session.beginTransaction();        // 离线Criteria 与session绑定        Criteria criteria = detachedCriteria.getExecutableCriteria(session);        List<Customer> allCustomer = criteria.list();        System.out.println(allCustomer.size());        session.getTransaction().commit();        session.close();    }

6 常见配置
6.1 整合c3p0(连接池) （了解）
 整合c3p0

步骤一：导入c3p0 jar包步骤二：hibernate.cfg.xml 配置    hibernate.connection.provider_class org.hibernate.connection.C3P0ConnectionProvider

 c3p0具体配置参数

############################## C3P0 Connection Pool###############################hibernate.c3p0.max_size 2#hibernate.c3p0.min_size 2#hibernate.c3p0.timeout 5000#hibernate.c3p0.max_statements 100#hibernate.c3p0.idle_test_period 3000#hibernate.c3p0.acquire_increment 2#hibernate.c3p0.validate false

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

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

6.2.4 hibernate处理丢失更新
 悲观锁：写锁

@Test    public void demo01(){        //1 查询所有        Session session = factory.openSession();        session.beginTransaction();        Customer customer = (Customer) session.get(Customer.class, 1 ,LockMode.UPGRADE);        System.out.println(customer);        session.getTransaction().commit();        session.close();    }

 乐观锁：
在PO对象（javabean）提供字段，表示版本字段。一般Integer
在*.hbm.xml 文件配置 <version name="...">

步骤一：

步骤二：

步骤三：测试

@Test    public void demo02(){        //1 查询所有        Session session = factory.openSession();        session.beginTransaction();//      Order order = new Order();//      order.setPrice(998d);//      session.save(order);        Order order = (Order) session.get(Order.class, 32);        order.setPrice(889d);        session.getTransaction().commit();        session.close();    }

阅读全文

0 0