hibernate笔记

1.创建表
Customers(
id int primary key,
name varchar(20),
age int,
birthday datetime,
married int ,
photo longblob,  | blob(oracle) | image(sqlserver)
description text | clob(oracle) | text(sqlserver)

)
2.创建java项目
添加jar文件,还有驱动程序
3.创建Customer类,和customer表对应
/**
* 客户类
*/
public class Customer {
private Integer id ;
private String name ;
private Integer age ;
private Date birthday ;
private boolean married ;
private byte[] photo ;
private String description ;
get/set...
}
4.创建映射文件Customer.hbm.xml[跟类在一起,名称一致,规范]//hibernate.jar/org.hiberante.Hibernate-mapping.dtd
<?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>
<class name="cn.itcast.hibernate.pesistence.Customer" table="customers" lazy="false">
<id name="id" column="id" type="integer">
<generator class="increment" />
</id>
<property name="name" column="name" type="string" />
<property name="age" column="age" type="integer" />
<property name="birthday" column="birthday" type="date" />
<property name="married" column="married" type="boolean" />
<property name="photo" column="photo" type="binary" />
<property name="description" column="description" type="text" />
</class>
</hibernate-mapping>
5.创建配置文件.src/hibernate.properties
hibernate.connection.driver_class=com.mysql.jdbc.Driver
hibernate.connection.url=jdbc:mysql://localhost:3306/hibernate
hibernate.connection.username=root
hibernate.connection.password=root
//方言是对底层数据库所用自身机制的配置(注册,比如函数,数据类型,过程之类)
hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
hibernate.show_sql=true
6.写测试类App
public class App {
//相当于连接池(数据源)
private static SessionFactory sf = null ;
static{
try {
//加载属性文件,hibernate.properties
Configuration conf = new Configuration();
//加载映射文件
conf.addClass(Customer.class);
//构建回话工厂,初始化会话工厂
sf = conf.buildSessionFactory();
} catch (Exception e) {
e.printStackTrace();
}
}

public static void main(String[] args) {
Customer c = new Customer();
c.setName("tom");
insertCustomer(c);
}

public static void insertCustomer(Customer c){
Session s = sf.openSession();
//开始事务:acid
Transaction tx = s.beginTransaction();
s.save(c);
tx.commit();
s.close();
}
}
7.用jdbc查询指定id的记录
select * from customers where id = ?
ResultSet rs ;
Customer c = new Customer();
if(rs.next()){
c.setName(s.getString(..));
//..

}
8.查询多个记录
sql = "select id,name from customers where id = ?"
ResultSet rs ;
List list = new ArrayList();
Customer c = null;
while(rs.next()){
c = new Customer();
c.setName(s.getString(..));
//..
list.add(c);
}
return list ;
9.批量删除
jdbc:delete from customers where id > 3 ;

10.Hibernate:持久化技术,io jdbc
封装了数据的访问细节[sql,遍历结果集],体现了oop. ORM(Object Relation Mapping).
11.java与sql之间数据的相互转换
insert into t(name,age) values(?,?);
//insert into t(name,age) values('tom',13);
//从java-->sql之间的类型转换
ppst.setString(1,"tom");
ppst.setInt(2,12);

select name,age from customers
//从sql-->java类型之间的转换
ppst.getString(1);
ppst.getInt(2);

12.domain/model/entity[实体:切实存在的个体]
13.域对象之间关系
1.关联:类之间引用关系.以属性方式体现.
2.依赖:类之间访问关系,不以属性体现.
3.聚集:强调生命周期,部分和整体.逻辑上约束.
4.泛化:一般化,继承.


14.Configuration:配置hibernate,根启动
15.SessionFactory:相当于数据源(连接池),线程安全的,重量级:创建和销毁需要消耗大量资源.
缓存，集合(Map).{}[预先生成desql + 映射元数据]l.
16.session:持久化管理器,不是线程安全的,避免多个线程共享.存放当前工作单元所加载的对象.

17.<property access="property">
access:设置访问级别:默认是方法级访问.field:字段级访问.
formula:公式[sql表达式]

18.<class>
mutable:可变的,默认是true。false
dynamic-insert:false,插入时只包含取值不为空的字段.
dynamic-update:更新时,包含取值发生改变的字段.

19.自然主键:把业务含义的字段设置为主键。 setId("llllhhhh")
   代理主键:使用一种自动化的机制给主键赋值.

20.equals ==
21.OID:Object ID
22.主键生成策略
increment:带走 + 1,不需要依赖于底层库
identity:使用db的自增字段.mysql sqlserver,需要依赖于底层库
sequence:需要依赖于底层库
<generator class="sequence">
<param name="sequence">seq_customers</param>
</generator>
hilo:hign/low, + 1 带走.在数据中维护一个单独的表,专门存放id的最大值.
native:本地的.(动态的)自动根据底层库的类型,选择合适策略映射上,
   mysql/sqlserver:identity oracle:sequence[hibernate_sequence]

assined:指定的.[适用于单个的自然主键] setId("12345");

联合主键:
<composite-id>
<key-property name="aid" column="aid" type="string" />
<key-property name="bid" column="bid" type="string" />
<key-property name="cid" column="cid" type="string" />
</composite-id>

<composite-id name="id" class="...CompId">
<key-property name="aid" column="aid" type="string" />
<key-property name="bid" column="bid" type="string" />
<key-property name="cid" column="cid" type="string" />
</composite-id>




23.映射多对一关联关系:类层面[单向、双向、多对一、一对多],表层面[外键的问题]
<many-to-one name="customer" column="cid[外键]" class="" cascade="save-update">


24.映射一对多关联
<set name cascade inverse lazy>
<key column="cid" />
<one-to-many class="" />
</set>
inverse:让缓存忽略集合的变化,重点失去对关联字段的控制权.和cascade有相互的干扰.
cascade:级联操作的程度.
父子关系:有父方完全控制子方的持久化生命周期,表现形式是当接触关联关系的时候,不是更新操作,而是删除操作.



25.java对象在jvm中的生命周期.
当没有任何一个引用能够直接或间接到达该对象，就被销毁了.
session的缓存就是集合,集合中存放都是对象的引用.
26.hibernate的持久化对象有3(4)状态.
临时态:new 没有和session关联 db没有记录
持久化状态:和session关联 db有记录
游离态:没有session关联 db可能有记录
删除态:

27.s.save s.update s.saveOrUpdate()共同特征是将非持久化状态的对象和缓存关联，使他们
变为持久化装状态.
s.saveOrUpdate()需要查看 <id un-saved="0">

28.清理缓存
s.flush();清理，让db和session同步,不提交
s.refresh();刷新.session和db同步.
s.clear();清空缓存.

auto commit never.
29.s.update():将游离对象和session关联,使他变为持久化.
由于游离对象没有快照,所以不论对象是否发生变化,都会更新.导致不必要更新,
如果要避免该现象可设置<class select-before-update="true">.
该属性还有另外一个好处,避免盲目激活触发器.

和触发器协同工作:
s.flush();
s.refresh();
30.持久化的属性有两种类型:值类型和实体.
值类型:没有oid，不能被单独持久化,生命周期只能依赖于所在实体内部.
实体:有oid,可以单独持久化.
组件是值类型.
<component name class="">
<!-- 映射到达父代的方式,parent必须作为component第一个子元素出现 -->
<parent name="customer" />
<property name column type length />
</component>

31.多对一(一对多)关联关系自连接
Area{
id name
Area parentArea ;
Set children = new HashSet();
}
<class name="..Area" table="areas" lazy="false">
    ...
    <many-ton-one name="parentArea" class="..Area" column="pid" />
    <set name="children" lazy>
        <key column="pid" />
        <one-to-many class="..Area">
   </set>
   </class>
  
32.一对一关联两种映射方案
1.外键关联:采用many-to-one模拟.
<many unique="true" />
<one-to-one property-ref="addr" />
2.共享主键关联:是要求一端的主键值和另外一端保持一致
<one-to-one name class />
<id>
<generator class="foreign">
<param name="property">user</param>
</generator>
</id>
33.多对多关联:需要引入中间表[tid,sid]联合主键
<set name table="links" inverse="true">
<key column="tid" />
<many-to-many class column="sid" />
</set>
由于多对多关系是通过中间关联表实现,而关联式联合主键,如果让两端都来
维护关联关系的控制器,会导致关联表数据的冲突,所以必须要将一端的inverse打开.
使其失去关联关系的控制权.
34.采用hibernate.cfg.xml配置
new Configuration().config().buildSessionFactory();

HibernateUtil工具类,包含共有方法.

35.DBCP C3p0
    <property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
    <property name="c3p0.acquire_increment">2</property>
    <property name="c3p0.max_size">5</property>
    <property name="c3p0.min_size">2</property>