Hibernate框架快速入门笔记

一、Hibernate文件目录结构

二、Hibernate的配置详解

核心配置文件 hibernate.cfg.xml

<session-factory>
<!-- 配置关于数据库连接的四个项 driverClass url username password -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3366/hibernateTest</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">123</property>

<!-- 可以将向数据库发送的sql显示出来 -->
<property name="hibernate.show_sql">true</property>
<!-- 格式化sql -->
<property name="hibernate.format_sql">true</property>
<!-- hibernate的方言 -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- 自动创建表 -->
<property name="hibernate.hbm2ddl.auto">update</property>
<!-- 用于设置事务提交方式 -->
<property name="hibernate.connection.autocommit">false</property>

<!-- 配置hibernate的映射文件所在位置 -->
<mapping resource="com/lbb/hibernate/domain/Customer.hbm.xml" />
</session-factory>

<property name="hibernate.hbm2ddl.auto">update</property>

映射配置文件 xxx.hbm.xml

<hibernate-mapping package="cn.itheima.domain">
<!-- name属性它是实体类的全名 table 表的名称 catalog 数据库名称 -->
<class name="Customer" table="t_customer"
catalog="hibernateTest">
<!-- id它是用于描述主键 -->
<id name="id" column="id" type="int">  <!-- java数据类型 -->
<!-- 主键生成策略 -->
<generator class="nati
2288b
ve"></generator>
</id>

<!-- 使用property来描述属性与字段的对应关系 -->
<property name="name" column="name" length="20" type="string"></property>  <!-- hibernate数据类型 -->
<property name="address">
<column name="address" length="50" sql-type="varchar(50)"></column> <!-- sql数据类型 -->
</property>
<property name="sex" column="sex" length="20"></property>
</class>
</hibernate-mapping>

<class>

<hibernate-mapping package="cn.itheima.domain">

<class>

<id>

<id>

<generator>

<property>

三、Hibernate的执行原理和常用API

<mappingresource="com/xx/User.hbm.xml"/>

// 保存一个Customer
@Test
public void saveCustomerTest() {
// 使用hibernate的api来完成将customer信息保存到mysql中操作
Configuration config = new Configuration().configure(); // 加载hibernate.cfg.xml

SessionFactory sessionFactory = config.buildSessionFactory();

Session session = sessionFactory.openSession(); // 相当于得到一个Connection。

// 开启事务
Transaction transaction = session.beginTransaction();

// 操作
Customer c = new Customer();
c.setName("张三");
c.setAddress("北京");
c.setSex("男");
session.save(c);

// 事务提交
transaction.commit();
session.close();
sessionFactory.close();
}

Configuration

Configuration config=new Configuration();//主要加载的src下的hibernate.properties
// 手动加载映射
// config.addResource("cn/itheima/domain/Customer.hbm.xml"); 直接加载映射配置文件
// config.addClass(Customer.class); //这种方式它会直接在实体类所在包下查找规范映射配置文件

SessionFactory

public class HibernateUtils {

private static Configuration config;
private static SessionFactory sessionFactory;

static{

config=new Configuration().configure();
sessionFactory=config.buildSessionFactory();
}

//  是从连接池中获取一个连接
public static Session openSession(){
return sessionFactory.openSession();
}

//  获取一个与线程绑定的Session
public static Session getCurrentSession(){
return sessionFactory.getCurrentSession();
}
}

<!-- 设置连接提供者 -->
<property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
<!--  c3p0连接池的配置 -->
<property name="hibernate.c3p0.max_size">20</property> <!-- 最大连接池 -->
<property name="hibernate.c3p0.min_size">5</property> <!-- 最小连接数 -->
<property name="hibernate.c3p0.timeout">120</property> <!-- 超时 -->
<property name="hibernate.c3p0.idle_test_period">3000</property> <!-- 空闲连接 -->

Session

Transaction

<!-- 用于设置事务提交方式 -->
<property name="hibernate.connection.autocommit">false</property>

Query(重点)

@Test
public void test1() {
Session session = HibernateUtils.openSession();
Query query = session.createQuery("from Customer");// from后面是类名
List<Customer> list = query.list();
System.out.println(list);
session.close();
}

// 分页查询 一页显示10条 要得到第二页数据
@Test
public void test3() {
Session session = HibernateUtils.openSession();
session.beginTransaction();

Query query = session.createQuery("from Customer");
query.setFirstResult(10);
query.setMaxResults(10);
List list = query.list();
System.out.println(list);

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

List<Object[]>

// 查询指定列信息
@Test
public void test4() {
Session session = HibernateUtils.openSession();
session.beginTransaction();

Query query = session.createQuery("select name,address from Customer");
List<Object[]> list = query.list();
System.out.println(list);

Query query2 = session.createQuery("select new Customer(name,address) from Customer");
List list2 = query2.list();
System.out.println(list2);

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

// 条件查询
@Test
public void test5() {
Session session = HibernateUtils.openSession();
session.beginTransaction();

//          Query query = session.createQuery("select new Customer(name,address) from Customer where name = ?");
Query query = session.createQuery("from Customer where name = ?");
query.setParameter(0, "姓名0");
Customer customer = (Customer) query.uniqueResult();
System.out.println(customer);

Query query2 = session.createQuery("from Customer where name = :myname");
query2.setParameter("myname", "姓名0");
Customer customer2 = (Customer) query.uniqueResult();
System.out.println(customer2);

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

List<Object[]>

// 执行本地sql----查询全部
@Test
public void test6() {
Session session = HibernateUtils.openSession();
session.beginTransaction();

// 执行select * from t_customer;
SQLQuery sqlQuery = session.createSQLQuery("select * from t_customer");
// List<Object[]> list = sqlQuery.list();
// System.out.println(list);

// 想要将结果封装到Customer对象中
sqlQuery.addEntity(Customer.class);
List<Customer> list = sqlQuery.list();
System.out.println(list);

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

// 执行本地sql----条件查询
@Test
public void test7() {
Session session = HibernateUtils.openSession();
session.beginTransaction();

// 执行select * from t_customer where name=?;
SQLQuery sqlQuery = session.createSQLQuery("select * from t_customer where name=?");
// 对参数进行赋值
sqlQuery.setParameter(0, "姓名1");

// 想要将结果封装到Customer对象中
sqlQuery.addEntity(Customer.class);
// List<Customer> list = sqlQuery.list();
// System.out.println(list);

Customer c = (Customer) sqlQuery.uniqueResult();
System.out.println(c);
session.getTransaction().commit();
session.close();
}

Criteria

@Test
public void test8() {
Session session = HibernateUtils.openSession();
session.beginTransaction();

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

// 查询所有
//          List list = criteria.list();
//          System.out.println(list);

// 分页查询
//          criteria.setFirstResult(10);
//          criteria.setMaxResults(10);
//          List list2 = criteria.list();
//          System.out.println(list2);

// 多条件查询
// 1.查询name='姓名1'
//          criteria.add(Restrictions.eq("name","姓名1"));
//          Customer customer = (Customer) criteria.uniqueResult();
//          System.out.println(customer);

// 2.查询address='上海'
//          criteria.add(Restrictions.eq("address", "上海"));
//          Customer customer = (Customer) criteria.uniqueResult();
//          System.out.println(customer);

//          criteria.add(Restrictions.eq("name","姓名1"));
//          criteria.add(Restrictions.eq("address", "上海"));
//          Customer customer = (Customer) criteria.uniqueResult();
//          System.out.println(customer);
//          List list = criteria.list();
//          System.out.println(list);

//查询name='姓名1' 或者   address='上海'
criteria.add(Restrictions.or(Restrictions.eq("name", "姓名1"),Restrictions.eq("address","上海")));
List<Customer> list = criteria.list();
System.out.println(list);

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

四、Hibernate持久化类与主键生成策略

Hibernate持久化类

Hibernate主键生成策略

建议：企业开发中使用代理主键！

建议不采用。

mysql的自增主键，oracle不支持主键自动生成。如果数据库支持自增建议采用。

比如oracle的序列。如果数据库支持序列建议采用。

由于生成主键策略的控制权由hibernate控制，所以不建议采用。

此策略可以保证生成主键的唯一性，并且提供了最好的数据库插入性能和数据库平台的无关性。建议采用。

Hibernate持久化对象状态

五、Hibernate一级缓存

private transient ActionQueue actionQueue;
private transient StatefulPersistenceContext persistenceContext;

所以：在操作中，建议我们通过持久化对象来直接修改其操作。

注意：如果执行delete操作，先删除一级缓存，在删除数据库中的数据。删除后对象id变为空，对象变为瞬时态

六、Hibernate关联映射–数据对象三种关系

一对多

public class Customer {
private Integer id; // 主键
private String name; // 姓名
// 描述客户可以有多个订单
private Set<Order> orders = new HashSet<Order>();

public class Order {
private Integer id;
private Double money;
private String receiverInfo; // 收货地址
// 订单与客户关联
private Customer c; // 描述订单属于某一个客户

Hbm映射文件编写

<!-- 一个客户关联多个订单 -->
<set name="orders" inverse="false" cascade="all">
<key column="cid" />
<one-to-many class="cn.itheima.oneToMany.Order" />
</set>
<!-- 使用set来描述在一的一方中关联的多 Set<Order>，
它的name属性就是set集合的名称
key:它主要描述关联的多的一方产生的外键名称，注意要与多的一方定义的外键名称相同
one-to-many 描述集合中的类型 -->

<!-- 多对一 -->
<many-to-one fetch="join" lazy="false" name="c" class="cn.itheima.oneToMany.Customer" column="cid" cascade="save-update">
</many-to-one>
<!--
name属性它描述的是Order类中的一的一方的属性名称   Customer c;
class 代表一的一方的类型
column 描述的是一对多，在多的一方产生的外键的名称 c_customer_id
-->

cascade=save-update

inverse

七、Hibernate注解开发

@Entity // 定义了一个实体
@Table(name = "t_book", catalog = "hibernateTest")
public class Book {

@Id // 主键
// @GeneratedValue //native
@GeneratedValue(strategy = GenerationType.IDENTITY) // identity
private Integer id; // 主键

@Column(name = "c_name", length = 30, nullable = true)
private String name;

@Temporal(TemporalType.TIMESTAMP) // 是用来定义日期类型
private Date publicationDate; // 出版日期

@Type(type="double")
private Double price; // 价格 如果没有添加注解，也会自动的生成在表中

@Transient
private String msg; // 现在这个属性不想生成在表中

@Id
@GenericGenerator(name = "myuuid", strategy = "uuid")
@GeneratedValue(generator = "myuuid")
private String id;

<mapping class="cn.itheima.oneToMany.Customer" />

<mapping class="cn.itheima.oneToMany.Order" />

一对多(多对一)

// 描述客户可以有多个订单
/*
* targetEntity相当于<one-to-many class="">
* mappedBy相当于inverse=true
*/
@OneToMany(targetEntity=Order.class,mappedBy="c",orphanRemoval=true)
@Cascade(org.hibernate.annotations.CascadeType.DELETE)
private Set<Order> orders = new HashSet<Order>();

// 订单与客户关联
@ManyToOne(targetEntity = Customer.class)
@JoinColumn(name = "c_customer_id") // 指定外键列
@Cascade(org.hibernate.annotations.CascadeType.SAVE_UPDATE)
private Customer c; // 描述订单属于某一个客户

cascade=CascadeType.ALL

orphanRemoval=true

Hibernate关联映射-多对多

@ManyToMany(targetEntity = Student.class, mappedBy = "teachers") // 代表由对方来维护外键
@Cascade(CascadeType.ALL)
private Set<Student> students = new HashSet<Student>();

@ManyToMany(targetEntity = Teacher.class)
// 使用JoinTabl来描述中间表，并描述中间表中外键与Student,Teacher的映射关系
// joinColumns它是用来描述Student与中间表中的映射关系
// inverseJoinColums它是用来描述Teacher与中间表中的映射关系
@JoinTable(name = "s_t", joinColumns = {
@JoinColumn(name = "c_student_id", referencedColumnName = "id") }, inverseJoinColumns = {
@JoinColumn(name = "c_teacher_id", referencedColumnName = "id") })
@Cascade(CascadeType.ALL)
private Set<Teacher> teachers = new HashSet<Teacher>();

Hibernate关联映射-一对一

@OneToOne(targetEntity = IDCard.class, mappedBy = "user")
private IDCard idCard;

@OneToOne(/*targetEntity = User.class*/)
@JoinColumn(name = "c_user_id")
@Cascade(CascadeType.SAVE_UPDATE)
private User user;

八、Hibernate检索方式概述

导航对象图检索方式

OID检索方式

HQL

@Entity
@Table(name = "t_customer")
@NamedQuery(name = "myHql", query = "from Customer")
@SqlResultSetMapping(name = "customerSetMapping", entities = { @EntityResult(entityClass = Customer.class, fields = {
@FieldResult(name = "id", column = "id"), @FieldResult(name = "name", column = "name") }) })
@NamedNativeQuery(name = "findCustomer", query = "select * from t_customer", resultSetMapping = "customerSetMapping")
@Proxy(lazy = true)
public class Customer {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id; // 主键

private String name; // 姓名

@OneToMany(targetEntity = Order.class, mappedBy = "c")
private Set<Order> orders = new HashSet<Order>();

@Entity
@Table(name = "t_order")
@NamedQuery(name="findOrderByCustomer",query="from Order where c=:c")
public class Order {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id;

private Double money;

private String receiverInfo; // 收货地址
// 订单与客户关联
@ManyToOne(targetEntity = Customer.class)
@JoinColumn(name = "c_customer_id")
@Cascade(CascadeType.SAVE_UPDATE)
private  Customer c;

public class HQLTest {

// 命名查询
@Test
public void test9() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
// 1.我要查询张龙这个客户的订单
Customer c = session.get(Customer.class, 1);

Query query = session.getNamedQuery("findOrderByCustomer"); // from Order  where c=:c
// 2.现在hql它的参数是一个实体
List<Order> list = query.setEntity("c", c).list();

System.out.println(list);

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

// 命名查询
@Test
public void test8() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
Query query = session.getNamedQuery("myHql");
List<Customer> list = query.list();
System.out.println(list);
session.getTransaction().commit();
session.close();
}

// 投影查询
@Test
public void test7() {
Session session = HibernateUtils.openSession();
session.beginTransaction();

// 1.查询出所有的Customer的name
// String hql = "select name from Customer";

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

// System.out.println(list); // [张龙, 张三丰]

// 如果只查询一个列,得到的结果List<Object>

// 2.查询所有的Customer的id,name
// String hql = "select id,name from Customer";

// List<Object[]> list = session.createQuery(hql).list();

// for(Object[] objs:list){
// for(Object obj:objs){
// System.out.print(obj+" ");
// }
// System.out.println();
// }
// 如果是查询多列,得到的结果是List<Object[]>

// 3.使用投影将查询的结果封装到Customer对象
String hql = "select new Customer(id,name) from Customer"; // 必须在PO类中提供对应的构造方法
List<Customer> cs = session.createQuery(hql).list();
System.out.println(cs);

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

// 分组统计操作
@Test
public void test6() {
Session session = HibernateUtils.openSession();
session.beginTransaction();

// 统计操作----统计一共有多少订单 count
// String hql="select count(*) from Order";

// Object count = session.createQuery(hql).uniqueResult();
// System.out.println(count);

// 分组统计----每一个人的订单总价
String hql = "select sum(money) from Order group by c";
List list = session.createQuery(hql).list();
System.out.println(list);

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

// 分页检索
@Test
public void test5() {
Session session = HibernateUtils.openSession();
session.beginTransaction();

Query query = session.createQuery("from Order");
// 每页显示6条件 ，我们要得到第二页数据
query.setFirstResult((2 - 1) * 6); // 设定开始位置
query.setMaxResults(6); // 设置条数

List<Order> list = query.list();
System.out.println(list);

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

}

// 条件查询
@Test
public void test4() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
// 1.根据位置来绑定参数
// 1.1创建hql
// String hql = "from Order where money>? ";

// 1.2.执行hql
// List<Order> list = session.createQuery(hql).setParameter(0,
// 2000d).list();
// 可以使用例如setString() setDouble这样的方法去添加参数,参数的序号是从0开始.

// 2.根据名称来绑定
// 1.1创建hql
String hql = "from Order where money>:mymoney ";

// 1.2.执行hql
List<Order> list = session.createQuery(hql).setParameter("mymoney", 2000d).list();
// 可以使用例如setString() setDouble这样的方法去添加参数

System.out.println(list);
session.getTransaction().commit();
session.close();

}

// 排序检索--//查询订单，根据订单的价格进行排序
@Test
public void test3() {
Session session = HibernateUtils.openSession();
session.beginTransaction();

// 1.定义hql
String hql = "from Order order by money desc"; // desc 降序 默认是asc 升序
// 2.执行hql查询订单，根据价格进行排序
List<Order> list = session.createQuery(hql).list();

System.out.println(list);

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

// 基本检索
@Test
public void test2() {
Session session = HibernateUtils.openSession();
session.beginTransaction();

// 1.编写HQL
String hql = "from Customer"; // from是关键字，后面是类名,关键字是不区分大小写，但是类名是区分
// 2.通过session.createQuery(hql)
// Query query = session.createQuery(hql);
// 3.通过list方法得到数据
// List<Customer> list = query.list();

List<Customer> list = session.createQuery(hql).list();

System.out.println(list.get(0));

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

// 准备数据(2个Customer，每一个Customer有10个Order)
@Test
public void test1() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
// 操作
Customer c = new Customer();
c.setName("张三丰");

for (int i = 0; i < 10; i++) {
Order order = new Order();
order.setMoney(2000d + i * 10);
order.setReceiverInfo("上海");
order.setC(c);
session.save(order);
}

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

QBC

public class QBCTest {

// 离线的检索
@Test
public void test6() {
// 1.得到一个DetachedCriteria
DetachedCriteria dc = DetachedCriteria.forClass(Customer.class);
dc.add(Restrictions.like("name", "张_"));

// 2.生成Criteria执行操作
Session session = HibernateUtils.openSession();
session.beginTransaction();
Criteria criteria = dc.getExecutableCriteria(session);
List<Customer> list = criteria.list();

System.out.println(list);
session.getTransaction().commit();
session.close();

}

// 统计检索
@Test
public void test5() {
Session session = HibernateUtils.openSession();
session.beginTransaction();

// 1.统计订单总数
Criteria criteria = session.createCriteria(Order.class);
// Object obj =
// criteria.setProjection(Projections.rowCount()).uniqueResult();
// //统计总行数 count(id)
// System.out.println(obj);

// 2.订单的总价格----分组统计根据客户
// criteria.setProjection(Projections.sum("money")); //统计总金额

criteria.setProjection(
Projections.projectionList().add(Projections.sum("money")).add(Projections.groupProperty("c")));

List<Object[]> list = criteria.list(); // 在这个集合中保存的是Object[money的统计信息,客户信息]

for (Object[] objs : list) {
for (Object obj : objs) {
System.out.println(obj);
}
}

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

// 分页检索
@Test
public void test4() {
Session session = HibernateUtils.openSession();
session.beginTransaction();

Criteria criteria = session.createCriteria(Order.class);
criteria.setFirstResult((2 - 1) * 6);
criteria.setMaxResults(6);
List<Order> list = criteria.list();

System.out.println(list);

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

// 条件检索
@Test
public void test3() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
// 1.查询名称叫张某客户 张_
Criteria criteria = session.createCriteria(Customer.class);
Criterion like = Restrictions.like("name", "张_"); // 其它的条件 lt < gt > le
// <= ge>= eq==
criteria.add(like);// 添加条件
Customer c = (Customer) criteria.uniqueResult();
System.out.println(c);

// 2.查询订单价格在1050以上的，并且它的客户是张某
Criteria cri = session.createCriteria(Order.class);
SimpleExpression lt = Restrictions.gt("money", 1050d); // >1050
SimpleExpression eq = Restrictions.eq("c", c); // 与c客户相同
LogicalExpression and = Restrictions.and(lt, eq);
cri.add(and);
// List<Order> orders =
// cri.add(Restrictions.and(Restrictions.gt("money", 1050d),
// Restrictions.eq("c", c))).list();
List<Order> orders = cri.list();
System.out.println(orders);

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

}

// 排序检索
@Test
public void test2() {
// 查询订单信息 根据订单的价格进行排序
Session session = HibernateUtils.openSession();
session.beginTransaction();

Criteria criteria = session.createCriteria(Order.class);
// 指定排序
// criteria.addOrder(org.hibernate.criterion.Order.desc("money")); // 降序
criteria.addOrder(org.hibernate.criterion.Order.asc("money")); // 升序

List<Order> list = criteria.list();

System.out.println(list);

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

// 基本检索
@Test
public void test1() {
// 查询所有Customer
Session session = HibernateUtils.openSession();
session.beginTransaction();
// 1.得到一个Criteria对象
Criteria criteria = session.createCriteria(Customer.class);

// 2.调用list方法
List<Customer> list = criteria.list();

System.out.println(list);

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

本地SQL

//测试本地sql命名查询
@Test
public void test2(){
Session session = HibernateUtils.openSession();
session.beginTransaction();

Query query = session.getNamedQuery("findCustomer");
List list = query.list();
System.out.println(list);
session.getTransaction().commit();
session.close();
}

多表操作

c) 迫切内连接

迫切左外连接

注意：在hibernate中有迫切连接的概念，而sql中没有。

//hql多表查询
public class HQLJoinTest {

// 演示迫切左外连接
@Test
public void test5() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
// 注意:fetch不可以与单独条件的with一起使用
List<Customer> list = session
.createQuery("select distinct c from Customer c left outer join fetch c.orders where c.id=1").list(); // 左外连接

for (Customer c : list) {
System.out.println(c);
}

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

// 演示外连接
@Test
public void test4() {
Session session = HibernateUtils.openSession();
session.beginTransaction();

List<Object[]> list = session.createQuery("from Customer c left outer join c.orders").list(); // 左外连接
for (Object[] objs : list) {
for (Object obj : objs) {
System.out.print(obj + "\t");
}
System.out.println();
}
session.getTransaction().commit();
session.close();
}

// 迫切内连接
@Test
public void test3() {
Session session = HibernateUtils.openSession();
session.beginTransaction();

// 迫切内连接 inner join fetch 注意：使用迫切连接结果可能出现重复，所以要使用distinct来去重复
String hql = "select distinct c from Customer c inner join fetch c.orders";
// 底层也是执行的inner join 只不过结果封装到对象中。

Query query = session.createQuery(hql);
List<Customer> list = query.list(); // 结果是List<>,集合中装入的From后面的对象。

for (Customer o : list) {
System.out.println(o);
}

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

// 测试隐式内连接
@Test
public void test2() {
Session session = HibernateUtils.openSession();
session.beginTransaction();
// sql连接 select * from t_customer,t_order where 条件
String hql = "from Order o where o.c.id=1";
Query query = session.createQuery(hql);
List list = query.list();
System.out.println(list);
/*
String hql = "from Customer c,Order o where c.id=1 and c.id = o.customer.id";
Query query = session.createQuery(hql);
List<Object[]> list = query.list();
for (Object[] objs : list) {
for (Object obj : objs) {
System.out.print(obj + "\t");
}
System.out.println();
}
*/
session.getTransaction().commit();
session.close();
}

// 测试显示内连接
@Test
public void test1() {
Session session = HibernateUtils.openSession();
session.beginTransaction();

// sql连接 select * from t_customer inner join t_order on 条件

String hql = "from Customer c inner join c.orders with c.id=1";

Query query = session.createQuery(hql);
List<Object[]> list = query.list(); // 结果是List<Object[]>
// 而Object[]中装入的是Customer与Order对象。

for (Object[] objs : list) {
for (Object obj : objs) {
System.out.print(obj + "\t");
}
System.out.println();
}

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

九、Hibernate事务管理

<!-- 设置事务隔离级别 -->
<property name="hibernate.connection.isolation ">4</property>

<property name="hibernate.current_session_context_class">thread</property>

Session currentSession = sessionFactory.getCurrentSession();

十、Hibernate优化方案

HQL优化

检索策略

<class>

抓取策略

@Entity
@Table(name = "t_customer")
@Proxy(lazy = false)
@BatchSize(size=3)
public class Customer {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id; // 主键

private String name; // 姓名

@OneToMany(targetEntity = Order.class, mappedBy = "c")
@Fetch(FetchMode.SELECT)
@LazyCollection(LazyCollectionOption.TRUE)
@BatchSize(size=3)
private Set<Order> orders = new HashSet<Order>();

@Entity
@Table(name = "t_order")
public class Order {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id;

private Double money;

private String receiverInfo; // 收货地址
// 订单与客户关联
@ManyToOne(targetEntity = Customer.class)
@JoinColumn(name = "c_customer_id")
@Cascade(CascadeType.SAVE_UPDATE)
@Fetch(FetchMode.JOIN)
@LazyToOne(LazyToOneOption.FALSE)
private  Customer c;