学习hibernate的笔迹第三篇，主要内容：多对多关系，检索策略，HQL查询，QBC，事物管理，c3p0配置

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

1.1.1.1 多对多的配置:

步骤一创建实体和映射:

 Student:

 public class Student {

 private Integer sid;

 private String sname;

 // 学生选择多门课程.

 private Set<Course> courses = new HashSet<Course>();

 ...

 }

Student

 public class Course {

 private Integer cid;

 private String cname;

 // 课程可以被多个学生选择:

 private Set<Student> students = new HashSet<Student>();

 ...

 }

Course

 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>

Student.hbm.xml

 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>

Course.hbm.xml

2 抓取策略（优化）

2.1 检索方式

l 立即检索：立即查询，在执行查询语句时，立即查询所有的数据。

l 延迟检索：延迟查询，在执行查询语句之后，在需要时在查询。（懒加载）

2.2 检查策略

l 类级别检索：当前的类的属性获取是否需要延迟。

l 关联级别的检索：当前类关联另一个类是否需要延迟。

2.3 类级别检索

l get：立即检索。get方法一执行，立即查询所有字段的数据。

l 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 介绍

l 容器<set> 提供两个属性：fetch、lazy

fetch：确定使用sql格式

lazy：关联对象是否延迟。

l fetch：join、select、subselect

join：底层使用迫切左外连接

select：使用多个select语句（默认值）

subselect：使用子查询

l lazy：false、true、extra

false：立即

true：延迟（默认值）

extra：极其懒惰

一对多的时候：

fetch　　　　　　 lazy 　　　　　　结论
-----------------------------------------------------------------------------------------------------------
select 　　　　　 true 　　　　默认值, 会在使用集合时加载,普通select语句
select　　　　 false 　　　　立刻使用select语句加载集合数据
select 　　　　　 extra 　　　　会在使用集合时加载,普通select语句,如果只是获得集合的长度,会发送Count语句查询长度.
join　　　　　　 true 　　　　查询集合时使用表链接查询,会立刻加载集合数据
join 　　　　　　 false　　　　查询集合时使用表链接查询,会立刻加载集合数据
join　　　　　　 extra　　　　查询集合时使用表链接查询,会立刻加载集合数据
subselect　　　　 true 　　　　会在使用集合时加载,子查询语句
subselect 　　　　false 　　　　会在查询用户时,立即使用子查询加载客户的订单数据
subselect　　　　 extra 　　　　会在使用集合时加载,子查询语句,如果只是获得集合的长度,会发送Count语句查询长度.

2.4.1.2 fetch="join"

l 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 不研究

fetch 　　　　　　　　lazy　　　　　　结果
---------------------------------------------------
select　　　　　　　 false 　　　　加载订单时,立即加载客户数据.普通select语句加载客户.
select 　　　　　　　 proxy　　　　类加载策略为:lazy=false 同上
　　　　　　　　　　　　　　　　　　　　 lazy=true 加载订单时,先不加载客户数据.使用客户数据时才加载
join　　　　　　　　 false　　　　使用表链接查询订单以及对应客户信息.lazy属性无效
join 　　　　　　　　 proxy 　　　使用表链接查询订单以及对应客户信息.lazy属性无效

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"l

　　将采用多条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);

layz=false
在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 命名查询

l 思想：将HQL从java源码中，提取到配置文件中。

l 分类：全局、布局

l 配置

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

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

l 获得

全局：

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 离线查询(了解)

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

l 离线查询条件与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(连接池) （了解）

l 整合c3p0

步骤一：导入c3p0 jar包

步骤二：hibernate.cfg.xml 配置

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

l 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 回顾

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

l 特性：ACID

原子性：整体

一致性：数据

隔离性：并发

持久性：结果

l 隔离问题：

脏读：一个事务读到另一个事务未提交的内容

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

虚读（幻读）：一个事务读到另一个事务已提交的内容（update）

l 隔离级别--解决问题

read uncommittd，读未提交。存在3个问题。

read committed，读已提交。解决：脏读。存在2个问题。

repeatable read ，可重复读。解决：脏读、不可重复读。存在1个问题。

serializable，串行化。单事务。没有问题。

6.2.2 hibernate设置隔离级别

l 在hibernate.cfg.xml 配置

hibernate.connection.isolation 4

6.2.3 lost update 丢失更新

l 悲观锁：默认认为一定会发送别人要修改我使用的数据. 那我就可以为我读取的数据加锁.

　　　　　　读锁/共享锁 => 读锁可被其他线程所共享,如果是读取的话大家都可以用这把锁读到数据.
　　　　　　　　　　select * from table lock in share mode（读锁、共享锁）

　　　　　　写锁/排他锁 => 写锁不能共享,只要有人为数据加入了写锁,其他人就不能为数据加任何锁.
　　　　　　　　　　select * from table for update （写锁、排它锁）

l 乐观锁：丢失更新肯定不会发生

在表中提供一个字段（版本字段），用于标识记录。如果版本不一致，不允许操作。

6.2.4 hibernate处理丢失更新

l 悲观锁：写锁

@Test

public void demo01(){

//1 查询所有

Session session = factory.openSession();

session.beginTransaction();

Customer customer = (Customer) session.get(Customer.class, 1, LockOptions.UPGRADE);

System.out.println(customer);

session.getTransaction().commit();

session.close();

}

l 乐观锁：

在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();

}

Hibernate3 多对多关系的更多相关文章

hibernate 多对多关系总结
hibernate中,对对象关系的映射处理估计是最让人迷惑和头疼的,特别是cascade和inverse属性的使用,不知已经杀死了我多少个脑细胞了,好记性永远比不上烂笔头,为了能节省自己的脑细胞,降低 ...
Hibernate学习第三天（2）（多对多关系映射）
1.1.1 Hibernate多对多关系的配置 1.1.1.1 创建表 l 用户表 CREATE TABLE `sys_user` ( `user_id` bigint(32) NO ...
Entity Framework 6 Recipes 2nd Edition（10-9）译 -> 在多对多关系中为插入和删除使用存储过程
10-9. 在多对多关系中为插入和删除使用存储过程问题想要在一个无载荷的多对多关系中使用存储过程(存储过程只影响关系的连接表) 解决方案假设有一个多对多关系的作者( Author)表和书籍( B ...
在thinkphp中，写的博文标签多对多关系的标签频率统计算法
常常看到别人的博客里面,或者网站里面有这样随机颜色,但字体大小与标签出现频率有关的标签云,于是自己就想写一个.至于颜色的随机显示,那就很简单了,这里就不列代码. 因为正在学thinkphp,所以数据查 ...
如何决解项目中hibernate中多对多关系中对象转换json死循环
先写一下原因吧!我是写的SSH项目,在项目中我遇到的问题是把分页对象(也就是pageBean对象)转化为json数据,下面为代码: public class PageBean <T>{// ...
EF里一对一、一对多、多对多关系的配置和级联删除
本章节开始了解EF的各种关系.如果你对EF里实体间的各种关系还不是很熟悉,可以看看我的思路,能帮你更快的理解. I.实体间一对一的关系添加一个PersonPhoto类,表示用户照片类 /// < ...
2.2、Hibernate用注解方式实现一对多、多对多关系
一.一对多关系 1.在上一篇日志中用.xml配置文件项目基础上,再往lib目录先添加一个包-hibernate-jpa-2.0-api-1.0.0.Final.jar 2.新建一个com.st.bea ...
【极力分享】[C#/.NET]Entity Framework(EF) Code First 多对多关系的实体增，删，改，查操作全程详细示例【转载自https://segmentfault.com/a/1190000004152660】
[C#/.NET]Entity Framework(EF) Code First 多对多关系的实体增,删,改,查操作全程详细示例本文我们来学习一下在Entity Framework中使用Cont ...
多对多关系<EntityFramework6.0>
无负载建立多对多关联的模型原文中是Modeling a Many-to-Many Relationship with No Payload,虽然这么翻译也有点不准确,但是可以说明其目的,如下图所示, ...

随机推荐

MySQL系列：数据表基本操作（2）
1. 指定数据库 mysql> use portal; 2. 数据库表基本操作 2.1 查看数据表 mysql> show tables; +------------------+ | T ...
mybatis 批量查询参数语句
在mybatis 传入数组在sql语句中进行查询 1.传入一个map集合,已或者的形式拼接数组循环 <select id="selectUserByList" parame ...
SOJ 1685:chopsticks(dp)
题目链接说实话挺喜欢soj的界面,简简单单,没有多余的东西hhh(但是简单到连内存限制,时间限制都看不到了. 题意是有个“奇葩”的主人公,吃饭要用三根筷子.两根短的一根长的. 现在给你n根筷子,要在 ...
sql server2012学习笔记
第1章 SQL安装 1-1 [SQL Server基础]前言 (10:44) 1-2 SQL Server安装 (08:29) 1-3 第一次登陆 SQL Server (02:58) 1-4 [ ...
UOJ274 [清华集训2016] 温暖会指引我们前行【LCT】【最大生成树】
题目分析: 差评,最大生成树裸题.hack数据还卡常. 代码: #include<bits/stdc++.h> using namespace std; ; struct LCT{ ],d ...
BZOJ 2049 洞穴勘测
LCT判断联通性没什么特别的..还是一个普通的板子题,把LCT当并查集用了,只不过LCT灵活一些,还可以断边话说自从昨天被维修数列那题榨干之后我现在写splay都不用动脑子了,,机械式的码spla ...
☆ [NOIp2016] 天天爱跑步「树上差分」
题目类型:LCA+思维传送门:>Here< 题意:给出一棵树,有\(M\)个人在这棵树上跑步.每个人都从自己的起点\(s[i]\)跑到终点\(t[i]\),跑过一条边的时间为1秒.现在每 ...
Matplotlib学习---用matplotlib和sklearn画拟合线（line of best fit）
在机器学习中,经常要用scikit-learn里面的线性回归模型来对数据进行拟合,进而找到数据的规律,从而达到预测的目的.用图像展示数据及其拟合线可以非常直观地看出拟合线与数据的匹配程度,同时也可用于 ...
【XSY2751】Mythological IV 线性插值
题目描述已知\(f(x)\)为\(k\)次多项式. 给你\(f(0),f(1),\ldots,f(k)\),求 \[ \sum_{i=1}^nf(i)q^i \] \(k\leq 500000,n\ ...
Centos 7.3 安装Grafana 6.0
grafana简介 Grafana是一个完全开源的度量分析与可视化平台,可对来自各种各种数据源的数据进行查询.分析.可视化处理以及配置告警. Grafana支持的数据源: 官方:Graphite,In ...

Hibernate3 多对多关系

学习hibernate的笔迹第三篇，主要内容：多对多关系， 检索策略，HQL查询，QBC，事物管理，c3p0配置

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

1.1.1.1 多对多的配置:

2 抓取策略（优化）

2.1 检索方式

2.2 检查策略

2.3 类级别检索

2.4 关联级别检索

2.4.1 一对多或多对多

2.4.1.1 介绍

2.4.1.2 fetch="join"

2.4.1.3 fetch="select"

2.4.1.4 fetch="subselect"

2.4.2 多对一

2.4.2.1 介绍

2.4.2.2 fetch="join"

2.4.2.3 fetch="select"l

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

2.5 批量查询

2.6 检索总结

3 查询方式总结

4 HQL【掌握】

4.1 介绍

4.2 查询所有客户

4.3 选择查询

4.4 投影查询（部分）

4.5 排序

4.6 分页

4.7 绑定参数

4.8 聚合函数和分组

4.9 连接查询

4.10 命名查询

5 QBC【了解】

5.1.1.1 QBC查询:

5.1.1.2 QBC简单的查询:

5.1.1.3 QBC分页的查询:

5.1.1.4 QBC排序查询:

5.1.1.5 QBC条件查询:

5.1.1.6 离线查询(了解)

6 常见配置

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

6.2 事务

6.2.1 回顾

6.2.2 hibernate设置隔离级别

6.2.3 lost update 丢失更新

6.2.4 hibernate处理丢失更新

Hibernate3 多对多关系的更多相关文章

随机推荐

热门专题

学习hibernate的笔迹第三篇，主要内容：多对多关系，检索策略，HQL查询，QBC，事物管理，c3p0配置

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