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);//表示查询数据放入二级缓存/从二级缓存取