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

Hibernate框架知识要点总结

1.常见映射：

2.lazy，inverse，cascade

3.对象状态

4.查询方式

4.一级缓存

5.二级缓存

1.集合缓存

2.开启hql查询缓存

6.C3P0连接池

7.session创建的2种方式