Hibernate3.0
预备知识
:
Core Java
JDBC
SQL
Hibernate
理论基础
1.
什么是
hibernate?
2.
hibernate
的知识内容
3.
什么是对象持久化
?
对象持久化有什么用
?(
解决的问题
)
4.
如何对象持久化
?
5.
如何用数据库的方法做对象持久化
?
6.
ORM(
对象关系映射
)
是什么
?
有什么作用
?
7.
ORM
从对象到表所要考虑的问题
8.
什么是
ORM
框架
?
有什么用
?
9.
使用
hibernate
的方法做对象持久化的工作
,
程序员应该怎么做
?
10.
hibernate
有什么用
?
11.
程序员和
hibernate
的整体工作流程
什么是
hibernate:
持久化的框架
,
属于设计方面的内容
,
类库
,
用来做对象持久化的
,
什么是对象持久化呢
?
Hibernate
的知识内容
:
语法部分
(
类库
)
程序设计思想
,
也就是持久层的设计
什么是对象持久化
?
对象持久化有什么用
?(
解决的问题
):
发现问题
:
程序设计的架构
:
表现层
—
业务层
—
持久层
—
数据库层
,
其中表现层和业务层是
JVM
来执行
,
应用程序会产生许多的对象
,
如果断电了
,
对象就消失了
,
也就是说在内存中的对象是不稳定的
,
状态不能持久
发现问题
:
将一个对象从
A
电脑复制到
B
电脑
,
如何做到呢
?
那么有三种方法解决上面的问题
:
1.
序列化
:
通过网络传递
,
或者硬盘共享
2.
存储到数据库中
,
谁想用
,
从数据库中拿
3.
EJB Entity Bean(
实体
Bean)
序列化的方法比较死板
:
如果当一个对象的结构比较复杂的时候
,
我们这时只需要一部分内容
,
没有办法
,
只能整个写入到文件
,
整个读取
序列化的缺点
:
不能检索
,
不能分离一个对象
,
不方便共享
所以说第一种方法只能用于做临时的持久化
,
简单的传输
,
但不适合复杂的持久化工作
第二种方法
(
数据库持久化
):
检索方便
,
分布式共享
,
永久数据
总结
:
什么是对象持久化
:
对象持久化就是把内存中的对象永久的保存起来
,
保护对象的状态
,
方便使用
对象持久化有什么用
: 1.
解决掉电的问题
2.
共享方便
3.
保证对象安全
检索方便
如何对象持久化
:
1.
对象序列化
2.
数据库
(JDBC,EJB,Hibernate)
如何用数据库的方法做对象持久化
:
1.
JDBC
发现问题
:
需要做大量的工作
,
难度大
2.
EJB
使用的是其中的一个功能来做持久化
,
解决了使用
JDBC
方法的的大量工作的问题
发现问题
: EJB
是重量级的组件
,
要使用它
,
有两个问题
1.
成本
2.
性能
发现问题
:
以上两种方式还有个共同的问题
,
对象不是简单存储在数据库中的
,
比如多态的特点就不能处理
A b=new B(); B
为
A
的子类
3.
Hibernate
解决了以上的所有问题
,
作用
:1.
不用做大量的工作
2.
移植性能好
3.
提高了代码的质量
,
简单
4.
检索
共享
重用
成本
调试
ORM(
对象关系映射
)
是什么
?
有什么作用
?
发现问题
:
java
中的对象的属性类型和数据库中的字段类型是不一样的
,
那么如何来存储
java
中的对象呢
?
这就需要做对象关系的映射
,
也就是
ORM
什么是
ORM:
将内存中的对象和数据库做转化
,
这样就实现了
java
与数据库之间的访问等功能
ORM
从对象到表所要考虑的问题
:
Orm
的复杂问题
:
1.
数据库如何保证对象的唯一性
:
在内存中
,
两个对象属性值都一样
,
但是内存地址不一样
,
可以做区分
,
但是在数据库中如何分辨呢
?
2.
继承关系如何转化
3.
集合如何映射呢
?
什么是
ORM
框架
?
有什么用
?
就是一个类库
,
通过这个类库完成持久化层的设计
使用
hibernate
的方法做对象持久化的工作
,
程序员应该怎么做
?
1.
将
ORM
方案定下来
,
就是类到数据库的转化
2.
利用
hibernate
生成代码
hibernate
有什么用
?
1.
完成
jdbc
的代码
2.
管理持久化对象的状态
3.
提供一个查询的
API
程序员和
hibernate
的整体工作流程
程序员
:
1.
设计
ORM
方案
2.
写配置文件
3.
调用
Hibernate
的
API,
向
Hibernate
发出命令
hibernate:
4.
读配置文件
5.
生成
jdbc
代码
6.
执行
Hibernate
简单实例
Hibernate
语法
:
作用
:
数据库的增删改查
HQL
面向对象的查询语句
大致步骤
:
1.
设置环境
类库
2.
定义映射
A
定义映射的实体
po
B
建立数据库表
C
写
XML
配置文件
(
表
,
数据库
)
3.
调用
Hibernate API
A
管理
po
的状态
(
增删改
,
恢复
po
状态
)
B
检索
(
查询
)
Hibernate
第一个简单的实例
:
引例
(frisHbn
包
)
1.
设置环境
hibernate
配置环境需要的资源
Hibernate
的
jar
包
: lib.zip dtd.zip: dtd.zip
可以不设置
2.
定义映射
建立项目
:
bussiness
包
: entity
包
Biz
包
业务
client
包
:
测试
util
包
:
工具
先写持久化类
:
以花为实体
,
建立花类
,
并且建立数据库表
/**
*
建表语句
:
* CREATE TABLE T_FRUIT(
FID NUMBER(10) PRIMARY KEY,
NAME VARCHAR(20) NOT NULL,
COMMENTS VARCHAR(50),
PRICE NUMBER(5) NOT NULL
);
*/
package Yuchen.fristHbn.business.entity;
//
持久化类
(
花类
),
注意因为采用的是
hilo
的方式获得
id,
所以需要有
setid
的方法
public class Fruit {
private Integer fid;//hibernate
中的
id
不能识别
int
private String name;
private String comments;
private int price;
public Fruit() {
super();
}
public Fruit(String name, String comments, int price) {
super();
this.name = name;
this.comments = comments;
this.price = price;
}
public String getComments() {
return comments;
}
public void setComments(String comments) {
this.comments = comments;
}
public Integer getFid() {
return fid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public void setFid(Integer fid) {
this.fid = fid;
}
}
使用
hilo
的方式获得
id:
建表语句
:
CREATE TABLE T_HILO(HILO_ID NUMBER(10));
INSERT INTO T_HILO VALUES(1);
写
hibernate
的连接数据库的配置文件
:
<?xml version="1.0"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="show_sql">true</property>
<property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
<property name="connection.url">jdbc:oracle:thin:@127.0.0.1:1521:name</property>
<property name="connection.username">scott</property>
<property name="connection.password">tiger</property>
<property name="connection.isolation">2</property>
<property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>
<mapping resource="Yuchen/fristHbn/business/entity/Fruit.hbm.xml"/>
</session-factory>
</hibernate-configuration>
写映射配置文件
:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="Yuchen.fristHbn.business.entity">
<class name="Fruit" table="T_FRUIT">
<id name="fid" column="fid">
<generator class="hilo">
<param name="table">t_hilo</param>
<param name="column">hilo_id</param>
</generator>
</id>
<property name="name" column="name" />
<property name="comments" column="comments"></property>
<property name="price" column="price"></property>
</class>
</hibernate-mapping>
A.
类名
—
表名
B.
id—id
获得
id
的方式
详细信息
(
如
: hilo
的表名和字段
)
C.
属性
—
字段
使用
hibernate API(FruitManager.java):
package Yuchen.fristHbn.business.Biz;
//
业务逻辑类
:
负责增删改查
通过使用
hibernate API
进行
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import Yuchen.fristHbn.business.entity.Fruit;
public class FruitManager {
public void insert(Fruit fruit){
Configuration config=new Configuration();
config.configure();//
读配置文件
SessionFactory sf=config.buildSessionFactory();//
得到工厂
Session session=sf.openSession();//
得到
session
Transaction tt=session.beginTransaction();//
检查事务开启
session.save(fruit);//
存储
insert
tt.commit();//
提交
session.close();//
关闭资源
}
}
写测试类
:
插入一个对象到数据库中
/**
*
知识点
:
* hibernate
基础
:
练习语法部分
API
和简单的映射关系
*
程序目标
:
*
使用
hibernate
方法将对象进行持久化
*
实现数据库的增删改查
* API:
* 1.Configuration:
这个类负责读取
XML
文档
(
映射配置文件
)
* configure():
读
xml
* buildSessionFactory():
创建一个生产
session
对象的工厂
,
其实是再次检查
*
因为
hibernate
和
jdbc
不一样
,jdbc
是如果不手动设置开启事务
,
那它
*
就是马上执行
sql
的
,hibernate
的不会马上执行
,
是事务提交后执行
*
默认情况下就是打开事务的状态
,
这里只是再检查以下
* 2.SessionFactory:
负责生产
session
对象
* openSession():
创建一个
session
* 3.Session
类
:
这个是主要的类
,
负责增删改查
,
开启事务等
* beginTransaction():
产生一个事务对象
(Transaction)
* save():
增加相当于操作
sql
中的
insert
语句
* 4.Transaction
类
:
负责管理事务的
* commit():
提交一个事务
*
*/
package Yuchen.fristHbn.client;
import Yuchen.fristHbn.business.Biz.FruitManager;
import Yuchen.fristHbn.business.entity.Fruit;
public class Test {
public static void test1(){
Fruit fruit=new Fruit("lisi","hello",100);
// fruit.setName("zhangsan");
// fruit.setComments("hello");
// fruit.setPrice(100);
FruitManager fm=new FruitManager();
fm.insert(fruit);
}
public static void main(String[] args) {
// TODO
自动生成方法存根
Test t=new Test();
t.test1();
}
}
hibernate API(
一
):
Configuration:
读取配置文件信息
用来初始化的
SessionFactory:
重量级对象
,
特点
:
消耗资源大
,
线程是安全
,
所以可以被共享
上面两个对象只实例化一个就行了
,
都是用于初始化的
Session:
线程是不安全的
,
所以要避免多个线程共享它
,
是轻量级的对象
,
使用后关闭
Session
对象的状态
:
顺态
:
还没有被持久化
,
也就是说数据库中没有该对象的记录
,
并且
Session
中的缓冲区里没有这个对象的引用
持久态
:
在数据库中有该对象的记录
,
并且在
session
中的缓冲区里有这个对象的引用
,
和顺态正好相反
游离态
:
在数据库中有记录
,
但是不在
session
的缓冲区里
对象状态的转换
:
做一个工具类
,
将
hibernate
中重复的代码包装起来
:
package Yuchen.fristHbn.util;
//
生产
session
对象的工具类
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HbnUtil {
private static SessionFactory sf;
static{
sf=new Configuration().configure().buildSessionFactory();
}
public static Session getSession(){
return sf.openSession();
}
}
完善
FruitManager
类
:
package Yuchen.fristHbn.business.Biz;
//
业务逻辑类
:
负责增删改查
通过使用
hibernate API
进行
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import Yuchen.fristHbn.business.entity.Fruit;
import Yuchen.fristHbn.util.HbnUtil;
public class FruitManager {
public Integer insert(Fruit fruit){
Session session=HbnUtil.getSession();//
通过工具更方便了
Integer id=null;
// Configuration config=new Configuration();
// config.configure();//
读配置文件
// SessionFactory sf=config.buildSessionFactory();//
得到工厂
// Session session=sf.openSession();//
得到
session
Transaction tt=session.beginTransaction();//
检查事务开启
id=(Integer)session.save(fruit);//
存储
insert
tt.commit();//
提交
session.close();//
关闭资源
return id;
}
public Fruit selectId(Integer id){
Session session=HbnUtil.getSession();
Transaction t=session.beginTransaction();
Fruit fruit=(Fruit)session.get(Fruit.class, id);
t.commit();
session.close();
return fruit;
}
public void remove(Fruit fruit){
Session session=HbnUtil.getSession();
Transaction t=session.beginTransaction();
session.delete(fruit);
t.commit();
session.close();
}
}
测试对象状态的转换
:
/**
*
知识点
:
* hibernate
基础
:
练习语法部分
API
和简单的映射关系
*
程序目标
:
*
使用
hibernate
方法将对象进行持久化
*
实现数据库的增删改查
* API:
* 1.Configuration:
这个类负责读取
XML
文档
(
映射配置文件
)
* configure():
读
xml
* buildSessionFactory():
创建一个生产
session
对象的工厂
,
其实是再次检查
*
因为
hibernate
和
jdbc
不一样
,jdbc
是如果不手动设置开启事务
,
那它
*
就是马上执行
sql
的
,hibernate
的不会马上执行
,
是事务提交后执行
*
默认情况下就是打开事务的状态
,
这里只是再检查以下
* 2.SessionFactory:
负责生产
session
对象
* openSession():
创建一个
session
* 3.Session
类
:
这个是主要的类
,
负责增删改查
,
开启事务等
* beginTransaction():
产生一个事务对象
(Transaction)
* save():
增加相当于操作
sql
中的
insert
语句
* 4.Transaction
类
:
负责管理事务的
* commit():
提交一个事务
* test1():
测试插入的功能
* test2():
测试数据同步更新的功能
* test3():
测试
saveOrUpdate()
* test4():
测试
clear()
和
flush()
*/
package Yuchen.fristHbn.client;
import org.hibernate.Session;
import org.hibernate.Transaction;
import Yuchen.fristHbn.business.Biz.FruitManager;
import Yuchen.fristHbn.business.entity.Fruit;
import Yuchen.fristHbn.util.HbnUtil;
public class Test {
public void test1(){
Fruit fruit=new Fruit("lisi","hello",100);
// fruit.setName("zhangsan");
// fruit.setComments("hello");
// fruit.setPrice(100);
FruitManager fm=new FruitManager();
fm.insert(fruit);
}
public void test2(){
//
测试同步更新的功能
Fruit fruit=new Fruit("meigui","hongse",70);//
顺态
FruitManager fm=new FruitManager();
Fruit fruit2=new Fruit();
Integer id=fm.insert(fruit);
fruit2=fm.selectId(id);
System.out.println(fruit2.getFid());
System.out.println(fruit2.getName());
fruit.setName("ziluolan");//
这里修改了对象
fruit2=fm.selectId(id);
System.out.println(fruit2.getFid());//
但是结果没有更新
System.out.println(fruit2.getName());
//
因为
fruit
在
Integer id=fm.insert(fruit);
后变成游离态了
//
也就是说只有持久态才能实现同步更新
System.out.println(fruit.getFid());
System.out.println(fruit.getName());
}
public void test3(){
Session session=HbnUtil.getSession();
Transaction t=session.beginTransaction();
Fruit fruit=new Fruit("ziluolan","lanse",100);//
顺态
Fruit fruit2=new Fruit();
FruitManager fm=new FruitManager();
session.save(fruit);//fruit
在运行完此句后变为游离态
fruit2=(Fruit) session.get(Fruit.class, fruit.getFid());
//
从数据库读并打印出来
System.out.println(fruit2.getFid()+":"+fruit2.getName());
session.saveOrUpdate(fruit);//
如果该对象为游历态就更新数据库
update
//
否则就是顺态
,
增加
insert
fruit2=(Fruit) session.get(Fruit.class, fruit.getFid());
//saveOrUpdate
后再从数据库读并打印出来
System.out.println(fruit2.getFid()+":"+fruit2.getName());
//
两个打印结果一样
,saveOrUpdate
方法判断如果
id
为
null,
就
//
顺态
,
否则就是游离态
t.commit();
session.close();
}
public void test4(){
Session session=HbnUtil.getSession();
Transaction t=session.beginTransaction();
Fruit fruit=new Fruit("guihua","fense",300);//
顺态
Fruit fruit2=new Fruit();
session.saveOrUpdate(fruit);//
执行
insert
因为对象为顺态
// session.flush();
session.clear();//fruit
变成游离态了
,
并且不会执行
insert
语句
//
因为
hibernate
不是马上执行
sql,
而是等
t.commit()
提交事务
//
后才执行
,clear
后
,
对象为游离态
session.saveOrUpdate(fruit);//
这里验证上面的话
,
执行
update
//
做个
select
查看一下
,
可以证明
,
因为
clear
后
,
没有马上执行
//sql
语句
,
所以表里没有数据
,
这里
update
也没有用
,
所以表中
//
一个对象也没插入
,
但是如果加入
flush()
刷新就是马上执行
sql
了
t.commit();
session.close();
}
public static void main(String[] args) {
// TODO
自动生成方法存根
Test t=new Test();
// t.test1();
// t.test2();
// t.test3();
t.test4();
}
}
hibernate API(
二
):
flush():
从上面的例子可以看出
,flush
是刷新
session
的缓冲区
,
并执行里面的命令
flush()
的事务管理模式
: flushMode()
里面有三个常量
,
可以用数字来表示
Load():
另一种读取数据的方法
,
和
get
的区别是
: 1.
异常处理
: load
有异常处理
,get
没有
,
它返回
null,2.get
从数据库读数据
,load
可能去读缓冲区
事务的隔离级别
:
在
hibernate
的数据库配置文件中设置
数字
1
为可以脏读
,
数字
2
为不能
,
这个是最常用的
锁机制
:
避免并发冲突
,
在数据库中写数据是自动加锁的
,
读一般不加
,
有悲观锁和乐观锁
乐观锁是可以是
hibernate
程序自己加
实现乐观锁
:
引例
(hbn2
包
)
步骤
:
1.
在表中加个
version
字段
2.
在持久类里加个
version
属性
3.
配置文件
<version name=”versopm”>
每存一次值加
1
引例
:hbn2
包
复杂的映射
:
1.
基数关系映射
2.
继承关系映射
3.
组件关系映射
4.
集合映射
基数关系的映射
—one to one:
基数关系的映射需要考虑的问题
:
1.
数量问题
2.
方向问题
在
one to one
的关系中
,
我们有两种方法可以体现类与类之间的关系
1.
共享主键
2.
外键唯一
引例
: Joto
包
-
此包引用了
fristHbn
包
建立与
Fruit
类有一对一关系的类
:
我们认为一个花有一个产地
,
一个产地生产一种花
,
所以要建立产地类
package Yuchen.Joto.business.entity;
//
花的地址类
//
问题
:
为什么不能在构造函数中写
Fruit?
因为生成对象后要持久化
//
这个对象
,
但是数据库的表中不能插入另一个类的值
,
写上
null
又不
//
大合适
,
所以就去掉它
public class Address {
private Integer aid;
private String nation;
private String postcode;
private Fruit fruit;
public Address() {
}
public Address(String nation, String postcode) {
super();
this.nation = nation;
this.postcode = postcode;
}
public Integer getAid() {
return aid;
}
public void setAid(Integer aid) {
this.aid = aid;
}
public Fruit getFruit() {
return fruit;
}
public void setFruit(Fruit fruit) {
this.fruit = fruit;
// fruit.setAddress(this);
}
public String getNation() {
return nation;
}
public void setNation(String nation) {
this.nation = nation;
}
public String getPostcode() {
return postcode;
}
public void setPostcode(String postcode) {
this.postcode = postcode;
}
}
修改
Fruit
类
:
package Yuchen.Joto.business.entity;
//
持久化类
(
花类
),
注意因为采用的是
hilo
的方式获得
id,
所以需要有
setid
的方法
public class Fruit {
private Integer fid;//hibernate
中的
id
不能识别
int
private String name;
private String comments;
private int price;
private Address address;//
一朵花对应一个地址
public Fruit() {
super();
}
public Fruit(String name, String comments, int price) {
super();
this.name = name;
this.comments = comments;
this.price = price;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
address.setFruit(this);//
因为当你给一个花设置产地的时候
//
该产地也有了花
}
public String getComments() {
return comments;
}
public void setComments(String comments) {
this.comments = comments;
}
public Integer getFid() {
return fid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public void setFid(Integer fid) {
this.fid = fid;
}
}
为地址实体类建表
:
//oto
共享主键方式
create table t_address(
aid number(10) primary key,
nation varchar2(30) not null,
postcode varchar2(10) not null,
constraint address_fruit foreign key(aid) references T_FRUIT(fid)
);
注意建表的方式不同
,
所对应的映射文件也有些区别
共享主键方式的映射文件
:<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="Yuchen.Joto.business.entity">
<class name="Fruit" table="T_FRUIT">
<id name="fid" column="fid">
<generator class="hilo">
<param name="table">t_hilo</param>
<param name="column">hilo_id</param>
</generator>
</id>
<property name="name" column="name" />
<property name="comments" column="comments"></property>
<property name="price" column="price"></property>
<one-to-one name="address" cascade="all" />
</class>
<class name="Address" table="t_address">
<id name="aid" column="aid">
<generator class="foreign">
<param name="property">fruit</param>
</generator>
</id>
<property name="nation" column="nation"></property>
<property name="postcode" column="postcode"></property>
<one-to-one name="fruit" constrained="true"></one-to-one>
</class>
</hibernate-mapping>
思路
:
写类
—
表
,
类中的属性
—
字段
,
类关系
(
从数据库的角度出发
)
外键唯一的方式
:建表:
create table t_address(
aid number(10) primary key,
nation varchar2(30) not null,
postcode varchar2(10) not null,
fid number(10) not null unique,
constraint address_fruit foreign key(fid) references T_FRUIT(fid)
);
配置文件中修改
<one-to-one name="fruit"
constrained="true"></one-to-one>
为
<many-to-one name="fruit" column="fid" unique="true" cascade="all" />
client
程序
:/**
*
知识点
:
*
基数关系映射
:one to one
*
程序目标
:
* 1.
写持久类
,
建立持久类之间的关系
* 2.
定义映射关系
,
为
po
建表
:
两种建表方式
*
第一种
:
共享主键
*
第二种
:
外键唯一
* 3.
写映射文件
*
共享主键情况下映射文件的写法
:
* A.
主键方
:<one-to-one name="
引用类型变量名
" cascade="all">
* B.
外键方
:<one-to-one name="
引用类型变量名
" constrained="true">
*
外键唯一情况下映射文件的写法
:
* A.
主键方
:<one-to-one name="
引用类型变量名
" cascade="all">
* B.
外键方
:<many-to-one name="
引用类型变量名
" column="fid" unique="true" cascade="all" />
*/
package Yuchen.Joto.client;
import org.hibernate.Session;
import org.hibernate.Transaction;
import Yuchen.Joto.business.entity.Address;
import Yuchen.Joto.business.entity.Fruit;
import Yuchen.Joto.util.HbnUtil;
public class Test {
public void test1(){
Session session=HbnUtil.getSession();
Transaction t=session.beginTransaction();
Fruit fruit=new Fruit("
掉蓝
","
绿色
",260);
Address arddess=new Address("
中国
","
崛起
");
fruit.setAddress(arddess);
session.save(fruit);
t.commit();
session.close();
}
public static void main(String[] args) {
// TODO
自动生成方法存根
Test t=new Test();
t.test1();
}
}
基数关系的映射
(one to many):
引例
:Jotm
包
我们认为一种花有多个产地
:
建立花类
:
package Yuchen.Jotm.business.entity;
//
花类
import java.util.HashSet;
import java.util.Set;
public class Fruit {
private Integer fid;
private String name;
private String comments;
private int price;
private Set addresses = new HashSet();//
一种花有多个产地
public Fruit() {
super();
}
public Fruit(String name, String comments, int price) {
super();
this.name = name;
this.comments = comments;
this.price = price;
}
public void setAddress(Address address) {
addresses.add(address);
address.setFruit(this);
}
public Set getAddresses() {
return addresses;
}
public void setAddresses(Set addresses) {
this.addresses = addresses;
}
public String getComments() {
return comments;
}
public void setComments(String comments) {
this.comments = comments;
}
public Integer getFid() {
return fid;
}
public void setFid(Integer fid) {
this.fid = fid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
}
建立产地类
:
package Yuchen.Jotm.business.entity;
//
地址类
public class Address {
private Integer aid;
private String nation;
private String postcode;
private Fruit fruit;//
一个地址对应一种花
public Address() {
super();
}
public Address(String nation, String postcode) {
super();
this.nation = nation;
this.postcode = postcode;
}
public Integer getAid() {
return aid;
}
public void setAid(Integer aid) {
this.aid = aid;
}
public Fruit getFruit() {
return fruit;
}
public void setFruit(Fruit fruit) {
this.fruit = fruit;
}
public String getNation() {
return nation;
}
public void setNation(String nation) {
this.nation = nation;
}
public String getPostcode() {
return postcode;
}
public void setPostcode(String postcode) {
this.postcode = postcode;
}
}
建立数据库表
:
Fruit
类
:
create table T_FRUIT_many2one(
FID number(10) PRIMARY KEY,
NAME VARCHAR2(20) NOT NULL,
COMMENTS VARCHAR2(50),
PRICE number(5) NOT NULL
);
Address
类
:
这个是多的一方
,
所以他的外键的值要引用
Fruit
类的主键值
CREATE TABLE T_ADDRESS_many2one(
AID number(10) PRIMARY KEY,
NATION VARCHAR2(30) NOT NULL,
POSTCODE VARCHAR2(10) NOT NULL,
AFID number(10) NOT NULL,
CONSTRAINT ADDRESS_FRUIT_many2one FOREIGN KEY(AFID)
REFERENCES T_FRUIT_many2one(FID)
);
写映射配置文件
:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="Yuchen.Jotm.business.entity">
<class name="Fruit" table="T_FRUIT_many2one">
<id name="fid" column="fid">
<generator class="hilo">
<param name="table">t_hilo</param>
<param name="column">hilo_id</param>
</generator>
</id>
<property name="name" column="name" />
<property name="comments" column="comments"></property>
<property name="price" column="price"></property>
<set name="addresses" inverse="true" cascade="all">
<key column="afid"></key>
<one-to-many class="Address"></one-to-many>
</set>
</class>
<class name="Address" table="t_address_many2one">
<id name="aid" column="aid">
<generator class="hilo">
<param name="table">t_hilo</param>
<param name="column">hilo_id</param>
</generator>
</id>
<property name="nation" column="nation"></property>
<property name="postcode" column="postcode"></property>
<many-to-one name="fruit" column="afid" cascade="all"></many-to-one>
</class>
</hibernate-mapping>
client
类
:
/**
*
知识点
:
*
基数关系映射
:one to many
*
程序目标
:
*
映射文件的写法
:
* 1.
主键方
:
* <set name="
引用类型的变量
" inverse="true" cascade="all">
* <key column="
外键名
">
* <one-to-many class="
外键的类名
"></one-to-many>
* 2.
外键方
:
* <many-to-one name="
引用类型的变量
" column="
外键名
" cascade="all">
*/
package Yuchen.Jotm.client;
import Yuchen.Jotm.business.Biz.FruitManager;
import Yuchen.Jotm.business.entity.Address;
import Yuchen.Jotm.business.entity.Fruit;
public class Test {
public static void main(String[] args){
FruitManager fm=new FruitManager();
Address address1=new Address("
北京
","0000");
Address address2=new Address("
上海
","000340");
Fruit fruit=new Fruit("
玫瑰
","
红色
",2000);
fruit.setAddress(address1);
fruit.setAddress(address2);
fm.insert(fruit);
}
}
基数关系的映射
(many to many):
我们把花和产地看为多对多的关系
:
引例
:Jmtn
包
修改产地类
:
package Yuchen.Jmtn.business.entity;
import java.util.HashSet;
import java.util.Set;
//
产地类
public class Address {
private Integer aid;
private String nation;
private String postcode;
private Set fruits=new HashSet();//
一个地址对应一种花
public Address() {
super();
}
public Address(String nation, String postcode) {
super();
this.nation = nation;
this.postcode = postcode;
}
public Set getFruits() {
return fruits;
}
public void setFruits(Set fruits) {
this.fruits = fruits;
}
public Integer getAid() {
return aid;
}
public void setAid(Integer aid) {
this.aid = aid;
}
public void setFruit(Fruit fruit) {
fruits.add(fruit);
// fruit.setAddress(this);
}
public String getNation() {
return nation;
}
public void setNation(String nation) {
this.nation = nation;
}
public String getPostcode() {
return postcode;
}
public void setPostcode(String postcode) {
this.postcode = postcode;
}
}
建表
:
Fruit
类
:
create table T_FRUIT_many2many(
FID number(10) PRIMARY KEY,
NAME VARCHAR2(20) NOT NULL,
COMMENTS VARCHAR2(50),
PRICE number(5) NOT NULL
);
Address
类
:
这个是多的一方
,
所以他的外键的值要引用
Fruit
类的主键值
CREATE TABLE T_ADDRESS_many2many(
AID number(10) PRIMARY KEY,
NATION VARCHAR2(30) NOT NULL,
POSTCODE VARCHAR2(10) NOT NULL
);
中间表
:
CREATE TABLE FRUIT_ADDRESS(
FID number(10) NOT NULL REFERENCES T_FRUIT_MANY2MANY(FID),
AID number(10) NOT NULL REFERENCES T_ADDRESS_MANY2MANY(AID),
PRIMARY KEY(FID,AID)
);
映射配置文件
:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="Yuchen.Jmtn.business.entity">
<class name="Fruit" table="T_FRUIT_many2many">
<id name="fid" column="fid">
<generator class="hilo">
<param name="table">t_hilo</param>
<param name="column">hilo_id</param>
</generator>
</id>
<property name="name" column="name" />
<property name="comments" column="comments"></property>
<property name="price" column="price"></property>
<set name="addresses" table="fruit_address" inverse="true" cascade="save-update">
<key column="fid"></key>
<many-to-many class="Address" column="aid"></many-to-many>
</set>
</class>
<class name="Address" table="t_address_many2many">
<id name="aid" column="aid">
<generator class="hilo">
<param name="table">t_hilo</param>
<param name="column">hilo_id</param>
</generator>
</id>
<property name="nation" column="nation"></property>
<property name="postcode" column="postcode"></property>
<set name="fruits" table="fruit_address" cascade="save-update">
<key column="aid"></key>
<many-to-many class="Fruit" column="fid"></many-to-many>
</set>
</class>
</hibernate-mapping>
cline
类
:
/**
*
知识点
:
*
基数关系映射
:many to many
*/
package Yuchen.Jmtn.client;
import Yuchen.Jmtn.business.Biz.FruitManager;
import Yuchen.Jmtn.business.entity.Address;
import Yuchen.Jmtn.business.entity.Fruit;
public class Test {
public static void main(String[] args){
FruitManager fm=new FruitManager();
Address address1=new Address("
北京
","0000");
Address address2=new Address("
上海
","000340");
Fruit fruit=new Fruit("
玫瑰
","
红色
",2000);
Fruit fruit2=new Fruit("
紫罗兰
","
紫色
",1000);
fruit.setAddress(address1);
fruit.setAddress(address2);
fruit2.setAddress(address1);
fm.insert(fruit);
fm.insert(fruit2);
}
}
继承关系的映射
:
三个表
发现问题
:
如何体现继承关系呢
?
两种方式
:1.
共享主键
2.
外键唯一
继承中子类有一个
supper,
也就是有一个父类
,
但是父类中没有子类
,
所以是单向的一对一的关系
,
因此在继承中不考虑数量的问题
优点
:
和面向对象的概念相似
,
支持多态
缺点
:
子类的数据会存放很多
,
效率也不高
,
表也多
,
但是数据没有冗余
引例
:Extends
包
1.
建立工具包类
(
省略
)
2.
建立实体类
付款方式
:
现金
银行
package Yuchen.Extends.business.entity;
//
父类
:
付款方式
public abstract class Payment {
private Integer pid;
private String reason;//
付款原因
private Double amount;//
付款金额
public Payment() {
super();
}
public Payment(String reason, Double amount) {
super();
this.reason = reason;
this.amount = amount;
}
public Double getAmount() {
return amount;
}
public void setAmount(Double amount) {
this.amount = amount;
}
public Integer getPid() {
return pid;
}
public void setPid(Integer pid) {
this.pid = pid;
}
public String getReason() {
return reason;
}
public void setReason(String reason) {
this.reason = reason;
}
}
package Yuchen.Extends.business.entity;
//
银行付款
public class CardPayment extends Payment{
private Integer pid;
private String bank;//
银行卡
public CardPayment() {
super();
}
public CardPayment(String reason, Double omount, String bank) {
super(reason,omount);
this.bank = bank;
}
public Integer getPid() {
return pid;
}
public void setPid(Integer pid) {
this.pid = pid;
}
public String getBank() {
return bank;
}
public void setBank(String bank) {
this.bank = bank;
}
}
package Yuchen.Extends.business.entity;
//
现金
public class CashPayment extends Payment{
private Integer pid;
private String cash;//
货币类型
public CashPayment(){
}
public CashPayment(String reason,double amount, String cash) {
super(reason,amount);
this.cash = cash;
}
public String getCash() {
return cash;
}
public void setCash(String cash) {
this.cash = cash;
}
public Integer getPid() {
return pid;
}
public void setPid(Integer pid) {
this.pid = pid;
}
}
建表
:
1.Payment
create table t_payment (
pid number(10) primary key,
reason varchar2(30) not null,
amount number(30) not null
);
2.CardPayment
//
共享主键
create table t_cardpayment(
pid number(10) primary key references t_payment(pid),
bank varchar2(30) not null
);
3.CashPayment
//
共享主键
create table t_cashpayment(
pid number(10) primary key references t_payment(pid),
cash varchar2(30) not null
);
写配置文件
:<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="Yuchen.Extends.business.entity">
<class name="Payment" table="t_payment">
<id name="pid" column="pid">
<generator class="hilo">
<param name="table">t_hilo</param>
<param name="column">hilo_id</param>
</generator>
</id>
<property name="reason"></property>
<property name="amount"></property>
<joined-subclass name="CardPayment" table="t_cardpayment">
<key column="pid"></key>
<property name="bank"></property>
</joined-subclass>
<joined-subclass name="CashPayment" table="t_cashpayment">
<key column="pid"></key>
<property name="cash"></property>
</joined-subclass>
</class>
</hibernate-mapping>
client:
/**
*
知识点
:
*
继承关系映射
* test1():
三个表
*/
package Yuchen.Extends.client;
import org.hibernate.Session;
import org.hibernate.Transaction;
import Yuchen.Extends.business.entity.CardPayment;
import Yuchen.Extends.util.HbnUtil;
public class Test {
public static void test1(){
Session session=HbnUtil.getSession();
Transaction t=session.beginTransaction();
CardPayment card=new CardPayment("
买杂志
",100.0,"
人民币
");
session.save(card);
t.commit();
session.close();
}
public static void main(String[] args) {
// TODO
自动生成方法存根
Test.test1();
}
}
继承关系的映射
:
两个表
一个子类一个表
,
父类不建表
,
但是每个子类需要加入父类的属性
缺点
:
不支持多态的查询
,
特点不明显
,
用的很少
建表
:
两个表
:
1.CardPayment
create table t_cardpayment_concrete(
pid integer(10) primary key,
reason varchar(30) not null,
amount double not null,
bank varchar(10) not null
);
2.CashPayment
create table t_cashpayment_concrete(
pid integer(10) primary key,
reason varchar(30) not null,
amount double not null,
cash varchar(10) not null
);
修改配置文件
:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="Yuchen.Extends.business.entity">
<class name="Payment">
<id name="pid" column="pid">
<generator class="hilo">
<param name="table">t_hilo</param>
<param name="column">hilo_id</param>
</generator>
</id>
<property name="reason"></property>
<property name="amount"></property>
<union-subclass name="CardPayment" table="t_cardpayment_concrete">
<property name="bank"></property>
</union-subclass>
<union-subclass name="CashPayment" table="t_cashpayment_concrete">
<property name="cash"></property>
</union-subclass>
</class>
</hibernate-mapping>
继承关系的映射
:
一个表
优点
:1.
生成报表快
2.
易于实现
3.
支持多态
缺点
:
修改和维护比较麻烦
如果类中的属性太多用这个方法就不大合适了
建表
:
一个表
:
create table t_payment_hierarchy(
pid number(10) primary key,
reason varchar2(30) not null,
amount number not null,
cash varchar2(10) not null,
bank varchar2(10) not null,
type varchar2(10) not null
);
修改配置文件
:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="Yuchen.Extends.business.entity">
<class name="Payment" table="t_payment_hierarchy">
<id name="pid" column="pid">
<generator class="hilo">
<param name="table">t_hilo</param>
<param name="column">hilo_id</param>
</generator>
</id>
<discriminator column="type"></discriminator>
<property name="reason"></property>
<property name="amount"></property>
<subclass name="CardPayment" discriminator-value="card">
<property name="bank"></property>
</subclass>
<subclass name="CashPayment" discriminator-value="cash">
<property name="cash"></property>
</subclass>
</class>
</hibernate-mapping>
组件映射
and Query:
什么是组件映射
?
我们知道在类的关联关系中有一种关系叫组合关系
,
什么是组合关系呢
?
就是不能独立存在的类
,
我们以前在映射这种关系的时候在一对一的情况下使用的是
one to one
的映射方法
,
这种方法比较复杂
,
那么我们可以使用组件映射的方法使得映射更简单
语法
:
1.
被包含的对象没有
oid,
组件类不能看做
po
2.
组件类不映射一个表
作用
:
只有一个表
,
没有
1to1
的关系
,
使得映射更简单
引例
:
银行帐户
,
有两个类
,
一个是帐户基本信息类
,
另一个是帐户人详细地址类
建立实体类
:
地址类属于值对象
,
帐户类属于实体对象
,
两者之间是组合关系
package Yuchen.component.business.entity;
//
帐号信息类
public class Account{
private Integer aid;
private String name;
private Address address;//
地址
public Account() {
super();
}
public Account(String name, Address address) {
super();
this.name = name;
this.address = address;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public Integer getAid() {
return aid;
}
public void setAid(Integer aid) {
this.aid = aid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package Yuchen.component.business.entity;
//
详细地址类
:
注意不需要
id,
因为要和
Account
建一个表里
public class Address{
private String street;//
街道
private String city;//
城市
private String zipcode;//
邮编
public Address() {
super();
}
public Address(String street, String city, String zipcode) {
super();
this.street = street;
this.city = city;
this.zipcode = zipcode;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public String getStreet() {
return street;
}
public void setStreet(String street) {
this.street = street;
}
public String getZipcode() {
return zipcode;
}
public void setZipcode(String zipcode) {
this.zipcode = zipcode;
}
}
建表
:
create table t_component(
aid number(10) primary key,
name varchar2(30) not null,
street varchar(30) not null,
city varchar(30) not null,
zipcode varchar(30) not null
);
映射文件
:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="Yuchen.component.business.entity">
<class name="Account" table="t_component">
<id name="aid" column="aid">
<generator class="hilo">
<param name="table">t_hilo</param>
<param name="column">hilo_id</param>
</generator>
</id>
<property name="name" />
<component name="address">
<property name="street" />
<property name="city" />
<property name="zipcode" />
</component>
</class>
</hibernate-mapping>
client:
/**
*
知识点
:
*
组件映射
*/
package Yuchen.component.client;
import org.hibernate.Session;
import org.hibernate.Transaction;
import Yuchen.component.business.entity.Account;
import Yuchen.component.business.entity.Address;
import Yuchen.component.util.HbnUtil;
public class Test{
public static void test(){
Session session=HbnUtil.getSession();
Transaction t=session.beginTransaction();
Address address=new Address("
湖南路
","
上海
","010000");
Account account=new Account("lisi",address);
session.save(account);
t.commit();
session.close();
}
public static void main(String[] args){
Test.test();
}
}
Query:
/**
*
知识点
:
*
组件映射
,Query
查询
* test1():
组件映射
* test2():1.
条件查询
2.from Object 3.uniqueResult()
* test3():
复杂的条件查询
(
支持
like
等
)
* test4():
加参数的查询
* test5():
使用
select:1.
查询一个类中引用类型的属性值
* 2.
查询一个类中引用类型的对象
* test6():
查看两个对象的属性
(
对象数组太麻烦
)
* test7():
使用中间对象查看两个对象的属性
* 1.
建一个中间对象类
* 2.
写
select HQL
语句调用
API
* test8():
命名查询
* 1.
修改配置文件
* 2.
执行
API
* API:
* uniqueResult():
返回唯一的对象
* getNameQuery():
得到变量名所指定的
sql
语句
*/
package Yuchen.component.client;
import java.util.Iterator;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import Yuchen.component.business.entity.Account;
import Yuchen.component.business.entity.AccountAddress;
import Yuchen.component.business.entity.Address;
import Yuchen.component.util.HbnUtil;
public class Test{
public static void test(){
Session session=HbnUtil.getSession();
Transaction t=session.beginTransaction();
Address address=new Address("
湖南路
","
上海
","010000");
Account account=new Account("lisi",address);
session.save(account);
t.commit();
session.close();
}
public static void test2()
{
Session session=HbnUtil.getSession();
Transaction t=session.beginTransaction();
// Query q=session.createQuery("from Account where name='lisi'");
Query q=session.createQuery("from java.lang.Object");
List list=q.list();
Account account=(Account) list.get(1);
// Account account=(Account) q.uniqueResult();
System.out.println(account.getName());
t.commit();
session.close();
}
public static void test3(){
Session session=HbnUtil.getSession();
Transaction t=session.beginTransaction();
Query q=session.createQuery("from Account a where a.name like '%si'");
Account account=(Account) q.uniqueResult();
System.out.println(account.getName());
t.commit();
session.close();
}
public static void test4(){
Session session=HbnUtil.getSession();
Transaction t=session.beginTransaction();
Query q=session.createQuery("from Account a where a.name like :x");
q.setString("x", "%si");
Account account=(Account) q.uniqueResult();
System.out.println(account.getName());
t.commit();
session.close();
}
public static void test5(){
Session session=HbnUtil.getSession();
Transaction t=session.beginTransaction();
// Query q=session.createQuery("select a.address.city from Account a where a.name='lisi'");
Query q=session.createQuery("select a.address from Account a where a.name='lisi'");
Address address=(Address) q.uniqueResult();
System.out.println(address.getCity());
// String city=(String) q.uniqueResult();
// System.out.println(city);
t.commit();
session.close();
}
public static void test6(){
Session session=HbnUtil.getSession();
Transaction t=session.beginTransaction();
Query q=session.createQuery("select a.name,a.address from Account a");
List list=q.list();
Object[] obj=(Object[]) list.get(0);//
第一条
(name,address
组成的对象数组
)
// Object[] obj2=(Object[]) list.get(1);//
第二条
System.out.println(obj[0]);
System.out.println(((Address)obj[1]).getCity());
t.commit();
session.close();
}
public static void test7(){
Session session=HbnUtil.getSession();
Transaction t=session.beginTransaction();
Query q=session.createQuery("select new Yuchen.component.business.entity.AccountAddress(a.name,a.address.zipcode) from Account a");
List list=q.list();
Iterator it=list.iterator();
while(it.hasNext()){
AccountAddress aa=(AccountAddress) it.next();
System.out.println(aa.getName());
System.out.println(aa.getZipcode());
}
t.commit();
session.close();
}
public static void test8(){
Session session=HbnUtil.getSession();
Transaction t=session.beginTransaction();
Query query=session.getNamedQuery("mingming");
query.setString("name","%si");
Account aa=(Account) query.uniqueResult();
System.out.println(aa.getName());
t.commit();
session.close();
}
public static void main(String[] args){
Test.test8();
}
}
修改配置文件
:
在
class
后加入
:
<query name="mingming"><![CDATA[from Account a where a.name like :name]]></query>
