Hibernate学习笔记
1>、Hibernate是数据访问层框架，是一个ORM(Object Relation Mapping)框架，作者为:Gavin King
2>、搭建Hibernate的开发环境
a>、添加jar包:
aa>、hibernatte开发包中/lib/required/所有jar
bb>、数据库的驱动程序
b>、定制hibernate的工作参数:在classpath根目录下创建一个hibernate.cfg.xml的配置文件
模版从hibernate开发包中/documentation/manual/en-US/html_single/index.html教程第一章
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- 数据连接设定 -->
<property name="connection.driver_class">oracle.jdbc.OracleDriver</property>
<property name="connection.url">jdbc:oracle:thin:@localhost:1521:SXT</property>
<property name="connection.username">scott</property>
<property name="connection.password">tiger</property>
<!-- 数据库连接池大小 -->
<property name="connection.pool_size">1</property>
<!-- SQL方言 -->
<property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>
<!-- 禁用二级缓存 -->
<property name="cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</property>
<!--向控制台输出所有执行的SQL语句 -->
<property name="show_sql">true</property>
<!-- 自动建表 -->
<property name="hbm2ddl.auto">update</property>
<!-- 注册映射文件 -->
<mapping resource="com/sxt/hibernate/po/Employee.hbm.xml"/>
</session-factory>
</hibernate-configuration>
c>、设计持久化类(Employee)，持化化类设计的规范为
a>、public 非final
b>、有一个OID属性，该属性唯一标识一个对象，基本类型建议使用包装类型
c>、有无参的构造方法
d>、属性有get/set方法
e>、集合属性声明为接口类型,如Set,List
d>、完成持久化类的对象关系映射，在持久化类所在位置，建一个名字为:持久化类名.hbm.xml的映射文件
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.sxt.hibernate.po.Employee" table="t_emps">
<!-- 主键映射 -->
<id name="id" column="emp_id">
<!-- 主键的生成策略 -->
<generator class="native"/>
</id>
<!-- 其它属性映射 -->
<property name="empno" length="20" />
<property name="name" column="ename" length="30" not-null="true"/>
<property name="sex" length="2"/>
<property name="job" length="20"/>
<property name="hiredate" />
<property name="salary" column="sal" />
</class>
</hibernate-mapping>
e>、使用Hibernate API完成数据库访问操作
//读取hibernate.cfg.xml中的配置信息
Configuration cfg = new Configuration();
cfg.configure();
//创建SessionFactory
SessionFactory sf = cfg.buildSessionFactory();
//创建Session
Session session = sf.openSession();
//开始事务
Transaction tx = session.beginTransaction();
//执行数据库操作
session.save(emp1);
//提交事务
tx.commit();
//释放资源
session.close();
2>、使用Hibernate完成CRUD操作
session.save();
session.get();
session.update();
session.delete();
session.createQuery(hql);
3>、主键的生成策略
a>、由数据库生成: identity,sequence,native
b>、由程序生成:assigned : 在调用save()方法，必须为对象的OID属性指定值
c>、由Hibernate生成: increment,uuid(主键为字符串类型),guid
4>、基于注解的映射方式
@Entity
@Table(name="t_emp3")
public class Employee3 {
@Id
@GeneratedValue
@Column(name="emp_id")
private Integer id; // OID：对象标识符，对应了数据库表的主键列
@Column(name="eno",length=20,nullable=false)
private String empno;
@Column(name="ename",length=20)
private String name;
@Column(length=2)
private String sex;
@Column(length=10)
private String job;
@Temporal(TemporalType.DATE)
private Date hiredate;
@Column(name="sal")
private double salary;
}
5>、持久化对象的三种状态
临时态(Transient) 持久态(Persistent) 脱管态(Detached)
OID属性是否有值 没有 有 有
是否位于session的缓存 否 是 否
数据库中是否有对应的记录 没有 有 有
a>、save(),update(),saveOrUpdate(),get(),query.list()得到的对象都是持久态
b> 、持久态的对象如果其属性发生变化，在事务提交时hibernate会自动执行更新，将其状态同步至数据库，如果没有变化，即使调用update()方法也不会执行更新
c>、当执行get(),load()查询时，会首先从session的缓存中取，只有在session的缓存中没有时，才查询数据库
d>、如果将对象的引用设为null,emp=null;临时态，脱管态可以被垃圾回收，持久态不能
e>、与状态有关的方法
session.saveOrUpdate()
session.eveict();
session.clear();
session.flush();
6>、关联关系的映射
a>、两个对象究竟是什么关系(一对多/多对一,一对一,多对多,继承)
b>、该关系所对应的表结构
c>、对象模型怎么建
A -> B
B -> A
A <-> B
一般在关联关系的维护方(如果在保存A时，需要B的信息，则A为关联关系的维护)建单向关联
如果要在关联关系的非维护方建关，就建双向关联，在非关联关系的维护方建关联关系，只影响查询操作
d>、关联关系映射怎么做
e>、在对对象执行crud操作时需注意什么
aa>、执行保存操作时，关联关系的维护方需设定关联关系,关联对象必须为持久态或脱管态
emp.setDept(new Dept(1)); //关联对象只需主键有值
bb>、如果在对象上建了关联关系，并进行了映射，hibernate保证查询到的对象可以访问关联的对象 : e.getDept().getName();
cc>、如果一个对象被另一个对象引用,则该对象不能删除(除非设定cascade)
7>、多对一/一对多关联
a>、表结构:在Many方建外键
b>、双向关联中<set inverse="true"></set> insert="true" : 指定set不维持关联关系
c>、延迟加载(lazy) :只有当访问关联对象时，才执行SQL语句从数据库中查询对象
只有session打开的情况下才能实现延迟加载，如果session关闭前，延迟属性没有初始化，关闭之后访问该属性会出异常
<many-to-one lazy="false/proxy"/>
<set lazy="true/false/extra"/> : 集合属性一定要使用延迟加载
lazy="extra" : 在执行dept.getEmps().size()时，执行的sql为:select count(dept_id) from t_emps where dept_id=1
d>、抓取策略 : 如何查询关联对象
<many-to-one fetch="select/join"/> : join 外连接抓取，在查询员工的同时使用外连接将员工的部门一块查出来，会覆盖lazy的设定
<set fetch="select/join/subselect"/> : subselect : 当执行List<Dept> depts = session.createQuery("from Dept").list();
depts.get(0).emps(); 会将所有部门的员工一块查出来
e>、级联操作:当对主控对象执行save,update,delete操作时，是否在关联对象上执行同样的操作
g>、<set order-by="salary desc"/> : order-by : 指定加载集合元素时，按哪个属性排序
8>、session.get()与load()方法的差别:(都是根据主键查询对象)
get(): 立即加载，执行get()方法会立即发出SQL语句，执行数据库查询，查询到的就是目标类(Employee)的对象，如果数据不存在返回null
load():延迟加载, 执行load()方法不会发出SQL语句，只有在访问load()方法返回的对象的属性时，才执行查询，查询返回的是目标类的代理类对象，数据不存在抛异常
9>、一对一映射
a>、共用主键
b>、唯一外键
10>、多对多映射
a>、关联关系上没有附加属性
public class Product {
private Integer id;
private String name;
private double salary;
}
public class Order {
private Integer id;
private String username; // 客户姓名
private String addr; // 送货地址
private String tel; // 联系电话
private Set<Product> products = new HashSet<Product>();
}
<class name="Order" table="t_orders">
<id name="id" column="order_id">
<generator class="native"/>
</id>
<property name="username" length="10" />
<property name="addr" length="20" />
<property name="tel" length="20" />
<!-- 多对多关联 -->
<set name="products" table="t_items" >
<key column="o_id"/> <!-- t_items表与t_orders表的连接列 -->
<many-to-many class="Product" column="p_id"/> <!-- p_id是t_items表与t_products表的连接列 -->
</set>
</class>
b>、关联关系上附加有其它属性(如订单上购买的商品的数量) : 可以将多对多关系拆成两个一对多
public class Product {
private Integer id;
private String name;
private double salary;
}
public class LineItem {
private Integer id;
private Order order; // 所属订单
private Product product; // 对应的商品
private int quantity = 1; // 数量
}
<class name="LineItem" table="t_items">
<id name="id" column="item_id">
<generator class="native"/>
</id>
<property name="quantity" />
<many-to-one name="order" column="o_id"/>
<many-to-one name="product" column="p_id"/>
</class>
<class name="Order" table="t_orders">
<id name="id" column="order_id">
<generator class="native"/>
</id>
<property name="username" length="10" />
<property name="addr" length="20" />
<property name="tel" length="20" />
<!-- 一对多关联 -->
<set name="items" cascade="all">
<key column="o_id"/>
<one-to-many class="LineItem"/>
</set>
</class>
11>、list映射
a>、当需要保证元素的添加次序与获取次序一致时使用list，否则应用set,使用list时，元素在list中的次序会在数据库中存储下来
b>、list必须是关联关系的维护方
c>、
<list name="products" table="t_items" >
<key column="o_id"/> <!-- t_items表与t_orders表的连接列 -->
<list-index column="prod_seq"/> <!-- 指定记录产品在订单中次序的列名 -->
<many-to-many class="Product" column="p_id"/> <!-- p_id是t_items表与t_products表的连接列 -->
</list>
12>、继承映射
Person : id,name,sex,age
Student extends Person : sno,score;
Teacher extends Person : title,salary;
a>、每个类分层结构一张表(table per class hierarchy) [单表]
id name sex age sno score title salary type[鉴别列]
1 张三 男 20 null null null null p
2 李四 女 15 sxt01 90 null null s
3 王五 男 30 null null 教授 5000 t
aa>、优点：所有数据都在一张表中，crud速度比较快
bb>、所有子类属性不能有not null约束，当子类属性比较多时，可能会产生很多null值
b>、每个子类一张表(table per subclass)
t_persons
id name sex age
1 张三 男 20
2 李四 女 15
3 王五 男 30
t_students
id sno score
2 sxt01 90
t_teachers
id title salary
3 教授 5000
bb>、缺点:子类的crud操作都访问至入两张表
c>、每个具体类一张表(table per concrete class)
t_persons
id name sex age
1 张三 男 20
t_students
id name sex age sno score
2 李四 女 15 sxt01 90
t_teachers
id name sex age title salary
3 王五 男 30 教授 5000
aa>、所有表中主键值不能相同
13>、Hibernate的查询操作
a>、QBC : Query By Criteria
b>、Native SQL :
c>、HQL查询
14>、批量处理
a>、批量插入
for ( int i=0; i<100000; i++ ) {
Customer customer = new Customer(.....);
session.save(customer);
if ( i % 20 == 0 ) { //20, same as the JDBC batch size //20,与JDBC批量设置相同
//flush a batch of inserts and release memory:
//将本批插入的对象立即写入数据库并释放内存
session.flush();
session.clear();
}
}
b>、批量更新与删除
session = HibernateUtils.getSession();
session.beginTransaction();
//String hql = "update Employee e set e.salary=e.salary + 200 where e.salary<2000";
String hql = "delete from Employee e where e.salary < 2000";
Query query = session.createQuery(hql);
int rows = query.executeUpdate();
System.out.println("删除了" + rows + "条记录");
session.getTransaction().commit();
c>、恢复scott的数据
aa>在sqlplus 下执行: @ D:\oracle\product\10.2.0\db_1\RDBMS\ADMIN\scott.sql
15、缓存 (将对象放入内存，提升查询的性能)
a>、一级缓存
session的缓存，对缓存对象的管理由hibernate实现，缓存的是所有持久态的对象，Hibernate不控制缓存中对象的数量，可能会出现内存溢出，所缓存对象的生命周期较短
b>、二级缓存
SessionFactory的缓存,由第三方实现，hibernate只提供了存取缓存对象的API，在使用前需要打开与配置，所缓存对象的生命周期较长，经常被查询且很少会改变的对象适合放入二级缓存
aa>、选择缓存供应商，在hibernate.cfg.xml中添加相关配置
<property name="cache.use_query_cache">true</property>
<property name="cache.use_second_level_cache">true</property>
<property name="cache.use_structured_entries">true</property>
<property name="cache.region.factory_class">org.hibernate.cache.EhCacheRegionFactory</property>
<property name="net.sf.ehcache.configurationResourceName">/ehcache.xml</property>
bb>、添加缓存供应商的jar包
cc>、准备缓存提供者的配置文件
dd>、指定需要放入二级缓存中的类
aaa>、在类的映射文件中指定: <class name="Employee"><cache usage="read-only"/></class>
bbb>、在hibernate.cfg.xml中指定
<class-cache usage="read-only" class="com.sxt.hibernate.po.Employee"/>
c>、查询缓存
缓存的是HQL属性查询的结果集，对实体查询只缓存主键值
select e.name,e.job,e.salary from Employee e where e.salary > 2000 and e.job='MANAGER'
query.setCacheable(true)
16、JPA : Java Persistence API
a>、JPA与Hibernate的关系
JPA是一套持久化规范，不是一个持久化框架
Hibernate是JPA的实现者之一
b>、搭建JPA开发环境(Hibernate实现)
aa>、添加Jar : 1)、原hibernate的所有jar包,2)、hibernate的lib\jpa\hibernate-entitymanager-4.3.2.Final.jar
bb>、配置文件(classpath:META-INF/persistence.xml)
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
version="2.0">
<persistence-unit name="sxt">
<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
<properties>
<!-- property的name与value属性的值由JPA的实现来定 -->
<property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver"/>
<property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/jpa"/>
<property name="hibernate.connection.username" value="root"/>
<property name="hibernate.connection.password" value="java"/>
<property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/>
<property name="hibernate.show_sql" value="true"/>
<property name="hibernate.format_sql" value="true"/>
<property name="hibernate.hbm2ddl.auto" value="update"/>
</properties>
</persistence-unit>
</persistence>
c>、使用JPA完成CRUD操作
persist();
find();
merge()
remove();
d>、关联关系映射
17、
<property name="gender" not-null="true" length="5">
<type name="org.hibernate.type.EnumType">
<param name="enumClass">com.itqiang.model.Gender</param>
<!--
12为java.sql.Types.VARCHAR常量值，即保存枚举的字面值到数据库。如果不指定type参数，保存枚举的索引值(从0开始)到数据库
-->
<param name="type">12</param>
</type>
</property>
2>、搭建Hibernate的开发环境
a>、添加jar包:
aa>、hibernatte开发包中/lib/required/所有jar
bb>、数据库的驱动程序
b>、定制hibernate的工作参数:在classpath根目录下创建一个hibernate.cfg.xml的配置文件
模版从hibernate开发包中/documentation/manual/en-US/html_single/index.html教程第一章
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- 数据连接设定 -->
<property name="connection.driver_class">oracle.jdbc.OracleDriver</property>
<property name="connection.url">jdbc:oracle:thin:@localhost:1521:SXT</property>
<property name="connection.username">scott</property>
<property name="connection.password">tiger</property>
<!-- 数据库连接池大小 -->
<property name="connection.pool_size">1</property>
<!-- SQL方言 -->
<property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>
<!-- 禁用二级缓存 -->
<property name="cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</property>
<!--向控制台输出所有执行的SQL语句 -->
<property name="show_sql">true</property>
<!-- 自动建表 -->
<property name="hbm2ddl.auto">update</property>
<!-- 注册映射文件 -->
<mapping resource="com/sxt/hibernate/po/Employee.hbm.xml"/>
</session-factory>
</hibernate-configuration>
c>、设计持久化类(Employee)，持化化类设计的规范为
a>、public 非final
b>、有一个OID属性，该属性唯一标识一个对象，基本类型建议使用包装类型
c>、有无参的构造方法
d>、属性有get/set方法
e>、集合属性声明为接口类型,如Set,List
d>、完成持久化类的对象关系映射，在持久化类所在位置，建一个名字为:持久化类名.hbm.xml的映射文件
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.sxt.hibernate.po.Employee" table="t_emps">
<!-- 主键映射 -->
<id name="id" column="emp_id">
<!-- 主键的生成策略 -->
<generator class="native"/>
</id>
<!-- 其它属性映射 -->
<property name="empno" length="20" />
<property name="name" column="ename" length="30" not-null="true"/>
<property name="sex" length="2"/>
<property name="job" length="20"/>
<property name="hiredate" />
<property name="salary" column="sal" />
</class>
</hibernate-mapping>
e>、使用Hibernate API完成数据库访问操作
//读取hibernate.cfg.xml中的配置信息
Configuration cfg = new Configuration();
cfg.configure();
//创建SessionFactory
SessionFactory sf = cfg.buildSessionFactory();
//创建Session
Session session = sf.openSession();
//开始事务
Transaction tx = session.beginTransaction();
//执行数据库操作
session.save(emp1);
//提交事务
tx.commit();
//释放资源
session.close();
2>、使用Hibernate完成CRUD操作
session.save();
session.get();
session.update();
session.delete();
session.createQuery(hql);
3>、主键的生成策略
a>、由数据库生成: identity,sequence,native
b>、由程序生成:assigned : 在调用save()方法，必须为对象的OID属性指定值
c>、由Hibernate生成: increment,uuid(主键为字符串类型),guid
4>、基于注解的映射方式
@Entity
@Table(name="t_emp3")
public class Employee3 {
@Id
@GeneratedValue
@Column(name="emp_id")
private Integer id; // OID：对象标识符，对应了数据库表的主键列
@Column(name="eno",length=20,nullable=false)
private String empno;
@Column(name="ename",length=20)
private String name;
@Column(length=2)
private String sex;
@Column(length=10)
private String job;
@Temporal(TemporalType.DATE)
private Date hiredate;
@Column(name="sal")
private double salary;
}
5>、持久化对象的三种状态
临时态(Transient) 持久态(Persistent) 脱管态(Detached)
OID属性是否有值 没有 有 有
是否位于session的缓存 否 是 否
数据库中是否有对应的记录 没有 有 有
a>、save(),update(),saveOrUpdate(),get(),query.list()得到的对象都是持久态
b> 、持久态的对象如果其属性发生变化，在事务提交时hibernate会自动执行更新，将其状态同步至数据库，如果没有变化，即使调用update()方法也不会执行更新
c>、当执行get(),load()查询时，会首先从session的缓存中取，只有在session的缓存中没有时，才查询数据库
d>、如果将对象的引用设为null,emp=null;临时态，脱管态可以被垃圾回收，持久态不能
e>、与状态有关的方法
session.saveOrUpdate()
session.eveict();
session.clear();
session.flush();
6>、关联关系的映射
a>、两个对象究竟是什么关系(一对多/多对一,一对一,多对多,继承)
b>、该关系所对应的表结构
c>、对象模型怎么建
A -> B
B -> A
A <-> B
一般在关联关系的维护方(如果在保存A时，需要B的信息，则A为关联关系的维护)建单向关联
如果要在关联关系的非维护方建关，就建双向关联，在非关联关系的维护方建关联关系，只影响查询操作
d>、关联关系映射怎么做
e>、在对对象执行crud操作时需注意什么
aa>、执行保存操作时，关联关系的维护方需设定关联关系,关联对象必须为持久态或脱管态
emp.setDept(new Dept(1)); //关联对象只需主键有值
bb>、如果在对象上建了关联关系，并进行了映射，hibernate保证查询到的对象可以访问关联的对象 : e.getDept().getName();
cc>、如果一个对象被另一个对象引用,则该对象不能删除(除非设定cascade)
7>、多对一/一对多关联
a>、表结构:在Many方建外键
b>、双向关联中<set inverse="true"></set> insert="true" : 指定set不维持关联关系
c>、延迟加载(lazy) :只有当访问关联对象时，才执行SQL语句从数据库中查询对象
只有session打开的情况下才能实现延迟加载，如果session关闭前，延迟属性没有初始化，关闭之后访问该属性会出异常
<many-to-one lazy="false/proxy"/>
<set lazy="true/false/extra"/> : 集合属性一定要使用延迟加载
lazy="extra" : 在执行dept.getEmps().size()时，执行的sql为:select count(dept_id) from t_emps where dept_id=1
d>、抓取策略 : 如何查询关联对象
<many-to-one fetch="select/join"/> : join 外连接抓取，在查询员工的同时使用外连接将员工的部门一块查出来，会覆盖lazy的设定
<set fetch="select/join/subselect"/> : subselect : 当执行List<Dept> depts = session.createQuery("from Dept").list();
depts.get(0).emps(); 会将所有部门的员工一块查出来
e>、级联操作:当对主控对象执行save,update,delete操作时，是否在关联对象上执行同样的操作
g>、<set order-by="salary desc"/> : order-by : 指定加载集合元素时，按哪个属性排序
8>、session.get()与load()方法的差别:(都是根据主键查询对象)
get(): 立即加载，执行get()方法会立即发出SQL语句，执行数据库查询，查询到的就是目标类(Employee)的对象，如果数据不存在返回null
load():延迟加载, 执行load()方法不会发出SQL语句，只有在访问load()方法返回的对象的属性时，才执行查询，查询返回的是目标类的代理类对象，数据不存在抛异常
9>、一对一映射
a>、共用主键
b>、唯一外键
10>、多对多映射
a>、关联关系上没有附加属性
public class Product {
private Integer id;
private String name;
private double salary;
}
public class Order {
private Integer id;
private String username; // 客户姓名
private String addr; // 送货地址
private String tel; // 联系电话
private Set<Product> products = new HashSet<Product>();
}
<class name="Order" table="t_orders">
<id name="id" column="order_id">
<generator class="native"/>
</id>
<property name="username" length="10" />
<property name="addr" length="20" />
<property name="tel" length="20" />
<!-- 多对多关联 -->
<set name="products" table="t_items" >
<key column="o_id"/> <!-- t_items表与t_orders表的连接列 -->
<many-to-many class="Product" column="p_id"/> <!-- p_id是t_items表与t_products表的连接列 -->
</set>
</class>
b>、关联关系上附加有其它属性(如订单上购买的商品的数量) : 可以将多对多关系拆成两个一对多
public class Product {
private Integer id;
private String name;
private double salary;
}
public class LineItem {
private Integer id;
private Order order; // 所属订单
private Product product; // 对应的商品
private int quantity = 1; // 数量
}
<class name="LineItem" table="t_items">
<id name="id" column="item_id">
<generator class="native"/>
</id>
<property name="quantity" />
<many-to-one name="order" column="o_id"/>
<many-to-one name="product" column="p_id"/>
</class>
<class name="Order" table="t_orders">
<id name="id" column="order_id">
<generator class="native"/>
</id>
<property name="username" length="10" />
<property name="addr" length="20" />
<property name="tel" length="20" />
<!-- 一对多关联 -->
<set name="items" cascade="all">
<key column="o_id"/>
<one-to-many class="LineItem"/>
</set>
</class>
11>、list映射
a>、当需要保证元素的添加次序与获取次序一致时使用list，否则应用set,使用list时，元素在list中的次序会在数据库中存储下来
b>、list必须是关联关系的维护方
c>、
<list name="products" table="t_items" >
<key column="o_id"/> <!-- t_items表与t_orders表的连接列 -->
<list-index column="prod_seq"/> <!-- 指定记录产品在订单中次序的列名 -->
<many-to-many class="Product" column="p_id"/> <!-- p_id是t_items表与t_products表的连接列 -->
</list>
12>、继承映射
Person : id,name,sex,age
Student extends Person : sno,score;
Teacher extends Person : title,salary;
a>、每个类分层结构一张表(table per class hierarchy) [单表]
id name sex age sno score title salary type[鉴别列]
1 张三 男 20 null null null null p
2 李四 女 15 sxt01 90 null null s
3 王五 男 30 null null 教授 5000 t
aa>、优点：所有数据都在一张表中，crud速度比较快
bb>、所有子类属性不能有not null约束，当子类属性比较多时，可能会产生很多null值
b>、每个子类一张表(table per subclass)
t_persons
id name sex age
1 张三 男 20
2 李四 女 15
3 王五 男 30
t_students
id sno score
2 sxt01 90
t_teachers
id title salary
3 教授 5000
bb>、缺点:子类的crud操作都访问至入两张表
c>、每个具体类一张表(table per concrete class)
t_persons
id name sex age
1 张三 男 20
t_students
id name sex age sno score
2 李四 女 15 sxt01 90
t_teachers
id name sex age title salary
3 王五 男 30 教授 5000
aa>、所有表中主键值不能相同
13>、Hibernate的查询操作
a>、QBC : Query By Criteria
b>、Native SQL :
c>、HQL查询
14>、批量处理
a>、批量插入
for ( int i=0; i<100000; i++ ) {
Customer customer = new Customer(.....);
session.save(customer);
if ( i % 20 == 0 ) { //20, same as the JDBC batch size //20,与JDBC批量设置相同
//flush a batch of inserts and release memory:
//将本批插入的对象立即写入数据库并释放内存
session.flush();
session.clear();
}
}
b>、批量更新与删除
session = HibernateUtils.getSession();
session.beginTransaction();
//String hql = "update Employee e set e.salary=e.salary + 200 where e.salary<2000";
String hql = "delete from Employee e where e.salary < 2000";
Query query = session.createQuery(hql);
int rows = query.executeUpdate();
System.out.println("删除了" + rows + "条记录");
session.getTransaction().commit();
c>、恢复scott的数据
aa>在sqlplus 下执行: @ D:\oracle\product\10.2.0\db_1\RDBMS\ADMIN\scott.sql
15、缓存 (将对象放入内存，提升查询的性能)
a>、一级缓存
session的缓存，对缓存对象的管理由hibernate实现，缓存的是所有持久态的对象，Hibernate不控制缓存中对象的数量，可能会出现内存溢出，所缓存对象的生命周期较短
b>、二级缓存
SessionFactory的缓存,由第三方实现，hibernate只提供了存取缓存对象的API，在使用前需要打开与配置，所缓存对象的生命周期较长，经常被查询且很少会改变的对象适合放入二级缓存
aa>、选择缓存供应商，在hibernate.cfg.xml中添加相关配置
<property name="cache.use_query_cache">true</property>
<property name="cache.use_second_level_cache">true</property>
<property name="cache.use_structured_entries">true</property>
<property name="cache.region.factory_class">org.hibernate.cache.EhCacheRegionFactory</property>
<property name="net.sf.ehcache.configurationResourceName">/ehcache.xml</property>
bb>、添加缓存供应商的jar包
cc>、准备缓存提供者的配置文件
dd>、指定需要放入二级缓存中的类
aaa>、在类的映射文件中指定: <class name="Employee"><cache usage="read-only"/></class>
bbb>、在hibernate.cfg.xml中指定
<class-cache usage="read-only" class="com.sxt.hibernate.po.Employee"/>
c>、查询缓存
缓存的是HQL属性查询的结果集，对实体查询只缓存主键值
select e.name,e.job,e.salary from Employee e where e.salary > 2000 and e.job='MANAGER'
query.setCacheable(true)
16、JPA : Java Persistence API
a>、JPA与Hibernate的关系
JPA是一套持久化规范，不是一个持久化框架
Hibernate是JPA的实现者之一
b>、搭建JPA开发环境(Hibernate实现)
aa>、添加Jar : 1)、原hibernate的所有jar包,2)、hibernate的lib\jpa\hibernate-entitymanager-4.3.2.Final.jar
bb>、配置文件(classpath:META-INF/persistence.xml)
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
version="2.0">
<persistence-unit name="sxt">
<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
<properties>
<!-- property的name与value属性的值由JPA的实现来定 -->
<property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver"/>
<property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/jpa"/>
<property name="hibernate.connection.username" value="root"/>
<property name="hibernate.connection.password" value="java"/>
<property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/>
<property name="hibernate.show_sql" value="true"/>
<property name="hibernate.format_sql" value="true"/>
<property name="hibernate.hbm2ddl.auto" value="update"/>
</properties>
</persistence-unit>
</persistence>
c>、使用JPA完成CRUD操作
persist();
find();
merge()
remove();
d>、关联关系映射
17、
<property name="gender" not-null="true" length="5">
<type name="org.hibernate.type.EnumType">
<param name="enumClass">com.itqiang.model.Gender</param>
<!--
12为java.sql.Types.VARCHAR常量值，即保存枚举的字面值到数据库。如果不指定type参数，保存枚举的索引值(从0开始)到数据库
-->
<param name="type">12</param>
</type>
</property>
分享到：
发表评论
相关推荐
hibernate学习笔记 hibernate学习笔记 hibernate学习笔记 hibernate学习笔记 hibernate学习笔记 hibernate学习笔记 hibernate学习笔记 hibernate学习笔记
Hibernate学习笔记_特别详细 Hibernate学习笔记_特别详细
学习hibernate框架时，整理的笔记，对hibernate框架有全面的介绍
Java相关课程系列笔记之十四Hibernate学习笔记
Hibernate学习笔记Hibernate学习笔记Hibernate学习笔记Hibernate学习笔记
hibernate 学习笔记精要hibernate 学习笔记精要hibernate 学习笔记精要hibernate 学习笔记精要
达内HIBERNATE学习笔记,达内HIBERNATE学习笔记,达内HIBERNATE学习笔记,达内HIBERNATE学习笔记,
这套笔记是我学习Hibernate，进行相关技术点训练时记录下来的，其中包括技术点说明与相关事例，拿出来与大家分享。
hibernate学习笔记 hibernate
Hibernate学习笔记!
hibernate学习笔记文档
马士兵hibernate学习笔记，方便学习hibernate