Hibernate 冬眠
持久层框架
jdbc是java访问数据库的唯一手段
EJB2 官方sun公司的产品 是重量级的框架
hibernate 一年个人开发
EJB3 编写规范
ibatis 和 hibernate 有竞争
Hibernate功能
帮我们写sql
关系的维护
性能优化，提供了缓存，延迟加载
ORM：对象关系映射
类 表
属性 字段
关系 外键
需要两个配置文件
hibernate.cfg.xml 连接数据库
Xxx.hbm.xml 图纸 类和对象的映射
hibernate_reference.pdf 官方使用手册 英文版
相关目录：
etc-log4j.properties[直接复制使用]
lib 开发时依赖的第三方jar包
hibernate3.jar hibernate核心包
中文文档
hibernate jar包 1.2章
hibernate.cfg.xml配置 3.3章
dialect 方言 土话 3.3章
hibernate 类型 5.5章
id 5.4.1章
hibernate.cfg.xml 中 属性hibernate开头可以省略
===================================================
相关配置代码：
hibernate.cfg.xml
<session-factory>
<property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
<property name="connection.url">
jdbc:oracle:thin:@10.0.4.98:1521:ww
</property>
<property name="connection.username">xwq</property>
<property name="connection.password">xwq</property>
<property name="dialect">org.hibernate.dialect.OracleDialect</property>
<property name="show_sql">true</property>
<property name="format_sql">true</property>
<mapping resource="day01/Person.hbm.xml"/>
</session-factory>
Person.hbm.xml
<hibernate-mapping package="day01">
<class name="Person" table="xwq_person">
<id name="id" column="id" type="integer">
<generator class="sequence">
<param name="sequence">xwq_seq</param>
</generator>
<!-- <generator class="native">
<param name="sequence">xwq_seq</param>
</generator>-->
</id>
<property name="name" column="name" type="string"></property>
<property name="birthday" column="birthday" type="date">
</property>
<property name="sex" column="sex" type="boolean"></property>
</class>
</hibernate-mapping>
util:
public class HibernateUtil
{
private static SessionFactory sessionFactory;
static{
sessionFactory = new Configuration()
.configure()
.buildSessionFactory();
}
public static Session getSession()
{
return sessionFactory.openSession();
}
}
java：
Person p = new Person();
p.setName("efg");
p.setSex(false);
p.setBirthday(java.sql.Date.valueOf("1999-01-01"));
Session session = null;
try
{
session = HibernateUtil.getSession();
session.beginTransaction();
session.save(p);
session.getTransaction().commit();
}
catch (Exception e)
{
session.getTransaction().rollback();
} finally
{
if(session != null)
{
session.close();
}
}
=======================================
Hibernate 核心api
Configuration 用于解析hibernate.cfg.xml和Xxx.hbm.xml,并创建SessionFactory对象
SessionFactory 用于创建Session对象，创建过程很消耗资源，线程安全 做成单例
Session [程序和数据库的会话] 持久化管理器 线程不安全【】
Transaction 事务管理器
动态DML
dynamic-insert="true" //映射文件中的class中的属性
dynamic-update="true" //持久态时 动态更新 不是调用update方法
莫个字段更新时不需要修改 设置 update="false";
insert="false";
【但可以通过hql来更新 executeUpdate() 来更新】
查询可以不加事务
数据库字段名和属性名完全相同 可以不写
type类型也可以不写
配置文件中的属性 针对set get方法而言
Hibernate 对象的状态
临时态：
内存里有，而且数据库没有一条记录跟他对应，对象没有被Session管理
持久态：
内存里有，而且数据库有对应的记录，这个对象被Session管理
【特征：对象状态改变，自动同步到数据库】
游离态：
内存里有，而且数据库有对应的记录，这个对象没有被Session管理
Hibernate曾删改
//增加
public static void insert(Person p){
session.save(p);
//session.saveOrUpdate(p); //数据库有相同的id就更新，反之就插入
//临时态执行save 游离态 持久态执行update
}
//删除 根据id
public static void delete(Integer id){
Person p = new Person();
p.setID(2);
session.delete(p);
}
//删除 根据 Person
public static void delete(Person p){
session.delete(p);
}
//修改
public static void update(Person p){
session.update(p);
//session.saveOrUpdate(p);
}
//查询 根据id
public static Person selectById(Integer id){
session.get(Person.class,id);
//session.load(Person.class,id) //有取值后再查询 p.getName(); 后执行查询
//load 有延迟加载，如果对象不存在，抛出异常 当用的时候才去数据库查
//get 没有延迟加载，如果对象不存在，返回null
}
//查询所有
public static List<Person> select(){
List<Person> persons = null;
Person person = null;
String hql = "from Person";
Query query = session.createQuery(hql);
persons = query.list();
person = query.uniqueResult();
}
// 查询 根据name
public static List<Person> selectByName(String name){
List<Person> persons = null;
String hql = "from Person p where p.name = ?";
// String hql = "from Person p where p.name = :name"; //name随便写
Query query = session.createQuery(hbl);
query.setString(0,name);
// query.setString("name",name);
persons = query.list();
}
分页技术：
Query
setFirstResult(int)//开始位置 hibernate 从0开始
setMaxResults(int)//个数
setXxx()
list()
uniqueResult() //唯一结果
executeUpdate()
persons = session.createQuery(hql).setFirstResult(3).setMaxResults(4).list();
//通过id 和 sex 更新 sex
public static void updateSexById(Integer id, boolean sex) {
//先查询 后更新(方法一)
Person = session.get(Person.class,id);
person.setSex(true);
//直接更新（方法二）
String hql = "update Person p set p.sex=:sex where id=:id";
session.createQuery(hql).setBoolean("sex", sex).setInteger("id", id).executeUpdate();
｝
//通过name 查 person
public static void selectPersonByName(String name) {
//返回一条结果 方法一
String hql = " from Person where name = :name";
p=(Person) session.createQuery(hql)
.setString("name", name)
.uniqueResult();
//返回多条
String hql = " from Person where name = :name";
list=session.createQuery(hql)
.setString("name", name)
.list();
//返回 id 和 name 结果 是person 对象的
String hql=new StringBuffer()
.append("select new Person(p.id,p.name) ")
.append("from Person p ")
.append("where p.name=:name")
.toString();
p=(Person) session.createQuery(hql)
.setString("name", name)
.uniqueResult();
//返回 id 和 name 的 结果 ---是个objet 对象
String hql=new StringBuffer()
.append("select p.id,p.name ")
.append("from Person p ")
.append("where p.name=:name")
.toString();
arr=(Object[]) session.createQuery(hql)
.setString("name", name)
.uniqueResult();
//模糊查询
String hql = new StringBuffer()
.append("from Person p ")
.append("where p.hob like :hob)")
.toString();
persons = session.createQuery(hql)
.setString("hob", "%"+hobby+"%")
.list();
//返回是个Map 对象的 结果
String hql=new StringBuffer()
.append("select new Map(p.id as id,p.name as name)")
.append("from Person p ")
.append("where p.name=:name")
.toString();
map=(Map) session.createQuery(hql)
.setString("name", name)
.uniqueResult();
// List<Person> persons = session.createQuery(hql).list();
}
自动创建表：配置文件中 属性 hbm2ddl.auto
取值：none【不使用】 create【创建】 update【没有创建，有表更新】
cascade属性设置级联操作
none 不使用
save-update 保存-更新
delete 删除
all save-update-delete
delete-orphan 删除时，级联删除孤儿
all-delete-orphan 全部级联
关系映射类型：
多对一
一对一
一对多
多对多
继承
组件
多对一（emp－dept）
Emp.hbm.xml:
<many-to-one name="dept" column="dept_id" class="Dept" fetch="join">
</many-to-one>
test:
String hql=new StringBuffer()
// .append("select e ")
.append("from Emp e ")
.append("left join fetch e.dept d ")
.toString();
emps=session.createQuery(hql).list();
关系属性默认有延迟加载
fetch="join" 对于根据主键查询时取消延迟加载【对get load有效】
说明：
默认情况下
多对一情况下
从多方根据id查询一方
关联属性使用了延迟加载
------
fetch="join"
get时，级联抓取关联属性
如果没有配置，关联属性延迟加载
join fetch 解决n+1条sql的问题
一对一（car－engine）
方法一：(
engine 中 car_id 作为外键FK 和 唯一 UK
)
car.hbm.xml:
<one-to-one name="engine" class="Engine" fetch="join" cascade="save-update"
property-ref="car"></one-to-one>
engine.hbm.xml:
<many-to-one name="car" column="car_id" class="Car" fetch="join" unique="true"></many-to-one>
说明：
property-ref="car" //
unique="true" // 保证唯一
test:
session.save(car);
方法二：（engine 中 id 作为主键PK 和 外键 FK）
car.hbm.xml:
<one-to-one name="engine" class="Engine"
fetch="join" cascade="save-update"></one-to-one>
engine.hbm.xml:
<class name="Engine" table="engine2">
<id name="id" column="id">
<generator class="foreign"> // 注意：foreign
<param name="property">car</param> // 注意：
</generator>
</id>
<property name="name" column="name"></property>
<one-to-one name="car" class="Car"
fetch="join"
constrained="true"></one-to-one>
</class>
说明：
constrained="true" //默认没有加约束，实际开发可加可不加，实际开发是有sql脚本的
一对多（order－item）
------------
Order(类)--有个属性是 Set<Item>
Order.hbm.xml:
<set name="items" inverse="true" cascade="all-delete-orphan">
<key column="order_id"></key> //通过 order_id 知道 关联的
<one-to-many class="Item"/> //集合中的类型
</set>
Item.hbm.xml:
<many-to-one name="order" column="order_id" class="Order"></many-to-one>
说明：
inverse="true" //放弃维护权 少了 update 操作
是否放弃关系维护权
默认情况下一对多中关系维护权在一方
说明：一对多情况下从一方抓取多方会有重复对象【bug】
解决方法： .append("select distinct o ") [hibernate3.2版本以后解决了]
3.2版本以前解决方法：
方法一：自己遍历集合去比较
方法二：用set集合
List<Order> orders=session.createQuery(hql).list();
Set<Order> set=new HashSet<Order>(orders);
orders=new ArrayList<Order>(set);
用户：xwq订单号：9
商品一：5 商品名：aaa 商品数量：1 商品单价20.00
商品一：6 商品名：bbb 商品数量：3 商品单价10.00
总价为;50.00
方法一：
order = (Order) session.get(Order.class, id);
方法二：
String hql = new StringBuffer()
.append("select distinct o") //查出多条结果需要
.append("from Order o ")
.append("join fetch o.user ")
.append("join fetch o.items i ")
.append("join fetch i.product ")
.append("where o.id=:id")
.toString();
映射：
类中有属性 －－表中没有（属性－－sql语句） //hibernate 可以进行子查询
<property name="count" formula="(select count(1) from t_item i where i.order_id = id)"></property> // id 默认是当前的表的id
.append("join o.items i ")
.append("where i.product=:product ")//集合中每一个元素的属性
多对多（Student--Course）一般采用 两个多对一的 hibernate 也支持 但一般不用。
----------
Student.hbm.xml:
<set name="courses" table="t_student_course">
<key column="s_id"></key>
<many-to-many class="Course" column="c_id"></many-to-many>
</set>
Course.hbm.xml:
<set name="students" inverse="true" table="t_student_course">
<key column="c_id"></key>
<many-to-many class="Student" column="s_id"></many-to-many>
</set>
=========================
继承映射：（User - Manager - Member）
三种方法：
一、一张表：所有属性都放在一张表中，用一个字段做区分
多态查询效率最高的，但会浪费数据库的空间
user
id
username
password
name
phone
status me/ma
User.hbm.xml:
class name="User" table="user">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<discriminator column="status" type="string"></discriminator> // 区分的字段 discriminator 类中没有，数据库中要添加该字段
<property name="username" column="username"></property>
<property name="password" column="password"></property>
<subclass name="Member" discriminator-value="me">
// 子类 subclass
<property name="name" column="name"></property>
<property name="phone" column="phone"></property>
</subclass>
<subclass name="Manager" discriminator-value="ma">
</subclass>
</class>
二、一个子类一张表：只有子类建表，包装自己的和父类的所有数据
节省空间，多态查询效率最低，如果不考虑多态查询时，效率最高
member
id
username
password
name
phone
manager
id
username
password
Member.hbm.xml:
<import class="User"/> //多态查询，不写，也可以用 不能多态查询
<class name="Member" table="member3">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<property name="username" column="username"></property>
<property name="password" column="password"></property>
<property name="name" column="name"></property>
<property name="phone" column="phone"></property>
</class>
Manager.hbm.xml:
<import class="User"/> //多态查询用的，不写，也可以用 但是不能多态查询
<class name="Manager" table="manager3">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<property name="username" column="username"></property>
<property name="password" column="password"></property>
</class>
三、一个类一张表：一个类一张表，用外键做关系
节省空间，效率最低，不建议使用
user
id
usename
password
member
user_id
name
phone
manager
user_id
User.hbm.xml:
<class name="User" table="user2">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<property name="username" column="username"></property>
<property name="password" column="password"></property>
<joined-subclass name="Member" table="member2">
// id有关联的子类 joined-subclass
<key column="user_id"></key>
<property name="name" column="name"></property>
<property name="phone" column="phone"></property>
</joined-subclass>
<joined-subclass name="Manager" table="manager2">
<key column="user_id"></key>
</joined-subclass>
</class>
------------------------
组件映射
Person
id
Name name
Name
firstName
lastName
person
id first_name last_name
Person.hbm.xml:
<hibernate-mapping package="day05">
<class name="Person" table="person">
<id name="id" column="id">
<generator class="native"></generator>
</id>
<component name="name" class="Name">
// 组件 component
<property name="firstName" column="first_name"></property>
<property name="lastName" column="last_name"></property>
</component>
</class>
缓存：
一级缓存：将持久态对象缓存在Session中【查同一个对象，只查一次数据库，一个sql】
二级缓存：将对象缓存在SessionFactory
映射文件中<class>加上<cache/> 就添加到二级缓存中，一般不用。
三种 query 方法
Query 官方文档中文15章
Criteria官方文档中文16章
SQLQuery官方文档中文17章
Query:
----------
<query name="selectAll"> //hql语句 可以写在配置文件中
<![CDATA[
from Person
where id<:id
]]>
</query>
<query name="selectByName">
<![CDATA[
from Person p
where p.name.firstName=:firstName
and p.name.lastName=:lastName
]]>
</query>
//test类的写法：
persons=session.getNamedQuery("selectByName")
.setString("firstName", "aaa")
.setString("lastName", "bbb")
.list();
Criteria:
功能做条件查询
----------
----------
StringBuffer hql=new StringBuffer()
.append("from Person p ")
.append("where 1=1 ");
List params=new ArrayList();
if(p.getName()!=null&&!"".equals(p.getName())){
hql.append("and p.name=? ");
params.add(p.getName());
}
if(p.getBirthday()!=null){
hql.append("and p.birthday=? ");
params.add(p.getBirthday());
}
if(p.getSex()!=null){
hql.append("and p.sex=? ");
params.add(p.getSex());
}
if(p.getHobbies()!=null){
hql.append("and p.hob=? ");
params.add(p.getHob());
}
Query query=session.createQuery(hql.toString());
for (int i = 0; i < params.size(); i++) {
setParam(i,params.get(i),query);
}
List<Person> persons=query.list();
private static void setParam(int i, Object param, Query query) {
if(param instanceof String){
query.setString(i, (String)param);
} else if(param instanceof Date){
query.setDate(i, (Date)param);
} else {
query.setParameter(i, param);
}
--------------
List<Person> persons=session.createCriteria(Person.class)
.add(Restrictions.eq("name", "ooo"))
.list();
List<Person> persons=session.createCriteria(Person.class)
.add(Example.create(p))
.list();
Criteria criteria=session.createCriteria(Person.class);
if(p.getName()!=null&&!"".equals(p.getName())){
criteria.add(Restrictions.like("name", "%"+p.getName()+"%"));
}
if(p.getSex()!=null){
criteria.add(Restrictions.eq("sex", p.getSex()));
}
criteria.list();
SQLQuery：
---------------
<sql-query name="s">
<return alias="p" class="day01.Person"></return>
<![CDATA[
select *
from t_person p
]]>
</sql-query>
Test中代码：
List list=session.getNamedQuery("s").list();
String sql=new StringBuffer()
.append("select * ")
.append("from t_person ")
// .append("where name=? ")
.append("where name=:name")
.toString();
List list=session.createSQLQuery(sql)
.addEntity(Person.class)
// .setString(0, "aaa")
.setString("name", "aaa")
.setFirstResult(2)
.setMaxResults(5)
.list();
自动生成Hibernate
右击-MyEclipse-Add Hibernate
扫一扫
1万+
评论
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
查看更多评论
添加红包
