Hibernate框架知识要点总结

1.常见映射：

复合主键映射

//首先要把多个主键字段封装成一个类，并实现Serializable接口
public class Composite implements Serializable{
private String id;//key1
private String name;//key2
}
//要映射的类
public class stu{
private Composite keys;
private String dept;
}
//写配置(要点)
<composite-id name="keys">
<key-property name="id" column=""></key-property>
<key-property name="name" column=""></key-property>
</composite-id>

集合映射（list,set,map）

//set
<set name="" table="">
<key column=""></key>
<element column="" type=""></element>
</set>

//list
<list name="" table="">
<key column=""></key>
<index column=""></index>
<element column="" type=""></element>
</list>

//map
<map name="" table="">
<key column=""></key>
<map-key column="" type=""></map-key>
<element column="" type=""></element>
</map>

一对多，多对一

//1的一方
public class  Dept{
private int id;
private String deptName;
private Set<Employee>employees;
}
//多的一方
public class Employee{
private int empId;
private String empName;
private Dept dept;
}

//写配置（要点）
//一的一方的配置
<set name="" >
<key column=""></key>
<one-to-many class=""/>
</set>
//多的一方
<many-to-one name="" column="" class=""></many-to-one>

多对多

//Project
public class Project{
private int Pid;
private String PName;
private Set<Developer>developers;
}
//Developer
public class Developer{
private int Did;
private String DName;
private Set<Project>projects;
}

//写配置（要点项）
多对多(中间表实现)
<set name="集合属性的名字" table="中间表的名字">
<key column="中间表引用的字段名(外键，对应当前配置表的主键)"></key>
<many-to-many column="中间表外键对应的字段" class="集合属性的类型s"></many-to-many>
</set>

一对一

添加外键的方式

//Person
public class Person{
private int Pid;
private String name;
private IdCard idcard;
}

//IdCard
public class IdCard{
private int id;//身份证号
}

//写配置（要点）
//无外键的一方
<one-to-one name="" class=""></one-to-one>
//有外键的一方
<many-to-one name="" column="" class="" unique="true 多对一并且外键为唯一值实现一对一" ></many-to-one>

添加主键的方式

//Person
public class Person{
private int Pid;
private String name;
private IdCard idcard;
}

//IdCard
public class IdCard{
private int personId;IdCard主键。引用Person的主键
private int id;//身份证号
}
//写配置（要点）
<id name="">
<generator class="foreign">
<param name="property">和下面的name要一样</param>
</generator>
</id>
<one-to-one name="" class="" constrained="true 添加外键约束"></one-to-one>

组合映射
           

//汽车
public class Car {
private int id;
private String name;
private double price;
// 汽车的，轮子
private Wheel wheel; // 映射： 叫组件映射！
}
//轮子
public class Wheel {
private double size;
private int count;
}

//写配置
//组合映射（类中包含类，映射到同一张表）
<component name="" class="">
<property name="" type=""></property>
</component>

继承映射（简单继承映射，复杂继承映射）

简单继承映射：就是每个子类都写一个配置 

父类子类字段都通过<property></property>配置，
只在子类中写配置，父类不用写

          2.复杂继承映射又分为3类，映射为一个表，2个表，多个表

               复杂映射的配置文件都写在父类中。
               1、父类，子类都映射到同一张表
                

//首先要定义一个鉴别器。鉴别器是用来区别鉴别表的每一条记录是来哪个子类的。注意：这个定义一定要写在主键<key></key>后面
<discriminator column="" type=""></discriminator>
//然后每个子类都要写
<subclass name="子类名" class="" discriminator-value="鉴别器的值，要根据鉴别器的类型写">
<property name="" type=""></property>
</subclass>

2.父类单独映射为一张表。所有子类也各映射一张表，这张表的主键是引用父类表的主键
        

<joined-subclass name="" table="">
<key column=""/>
<property name="" type=""></property>
<joined-subclass>

3.每个子类都映射一张表，父类不映射

<id name="">
<generator class="不能为自增长主键生成器"></generator>
</id>
<union-subclass name="" table="">
<property name="" type=""></property>
</union-subclass>

2.lazy，inverse，cascade

lazy:懒加载
inverse:控制权限反转
cascade：级联

3.对象状态

临时状态
持久化状态
游离状态

4.查询方式

主键查询、对象查询
hql查询
criter查询
 

4.一级缓存

5.二级缓存

1.集合缓存

2.开启hql查询缓存

首先要配置，表示开启hql查询缓存

<!-- 二级查询缓存开启 -->
<property name="hibernate.cache.use_query_cache">true</property>

然后在createQuery(" ")后再加一个setCacheable()方法

session.createQuery("from Dept").setCacheable(true);//表示查询数据放入二级缓存/从二级缓存取

6.C3P0连接池

7.session创建的2种方式