一、概述
1、hibernate是一种对象关系映射框架，将类对象和数据库表建立映射关系，是一个全自动的ORM框架
2、hibernate内部封装JDBC
3、hibernate主要用于实体类和表关系的一个映射
4、无论是xml映射形式还是注解映射形式，都有一个数据库总配置文件hibernate.cfg.xml
用于设置连接数据库等信息
5、涉及的两个名词
ORM---对象关系映射，将对象映射到关系数据库中，操作实体类就相当于操作数据库表
JPA---持久层接口，继承了JpaRepository，通过hibernate完成数据库操作
JPA实体类相关注解见hibernate注解实现部分
二、表关系
1、一对一 one to one
2、一对多 one to many【以一的主键作为外键相连】
3、多对多 many to many【另建一个关系表】
三、hibernate实现表关系
（一）xml实现
每个实体类对应一个xxx.hbm.xml配置文件
1、一对多
（1）Type 【oneToMany】
//1、【实体类】
public class Type {
private int id;
private String name;
//在一的里面声明一个多类型的集合（一个type对应多个product）
private Set<Product> pis=new HashSet<>();
//set get封装集合、有参无参构造略
}
//2、【表映射文件】 Type.hbm.xml
<hibernate-mapping>
<!-- 1、配置表本身信息:数据库对应的表名； colum：表字段同；主键生成策略：native（自适应）-->
<class name="com.sqf.entity.Type" table="type">
<id name="id" type="int">
<column name="id" />
<generator class="native" />
</id>
<property name="name" type="java.lang.String">
<column name="name" />
</property>
<!-- 2、配置表关系：配置声明的product类型集合-->
<!-- （1）控制权的反转 ：
inverse="true"主动放弃维护关系，由多的一方product维护联系
作用：在两表有联系情况下使用，提高效率，没有额外update语句）
级联操作：
cascade="all"删一个表，与之联系的表对于删除 -->
<set name="pis" inverse="true" cascade="all">
<!--（2）两表联系的外键 tid-->
<key column="tid"></key>
<one-to-many class="com.sqf.entity.Product"/>
</set>
</class>
</hibernate-mapping>（2）Product【ManyToOne】
public class Product {
private int id;
private String code;
private String name;
private String brand;
private String pic;
private int num;
private double price;
private String intro;
private int status;
private String bigpic;
//tid外键不用封装,1对多，将1的对象声明在多的类中
private Type type;
//set get封装，构造函数等略
}
<hibernate-mapping>
<!-- 1、配置表本身信息-->
<class name="com.sqf.entity.Product" table="product_info">
<id name="id" type="int">
<column name="id" />
<generator class="native" />
</id>
<property name="code" type="java.lang.String">
<column name="code" />
...
<!-- 2、配置表关系：声明在此类中的type对象-->
<!-- column：外键表字段（一的主码放在了多的这边作为外键）
lazy:两条sql语句同时进行不延迟 fetch=jion：将多表连接在同一个sql语句中执行 -->
<many-to-one name="type" class="com.sqf.entity.Type" lazy="false" fetch="join">
<column name="tid" />
</many-to-one>
</class>
</hibernate-mapping>2、多对多
两个里面都要写另一个对象类型的set集合
//【类1】
public class AdminInfo {
private int id;
private String name;
private String pwd;
private String role;
//声明另一个多的Set集合
Set<Function> fis=new HashSet<>();
//set、get各个属性，包括Set集合
}
//【类1配置文件】AdminInfo.hbm.xml
<hibernate-mapping>
<!-- 1、配置表本身信息-->
class name="com.sqf.entity.AdminInfo" table="admin_info">
<id name="id" type="int">
<column name="id" />
<generator class="native" />
</id>
<property name="name" type="java.lang.String">
<column name="name" />
</property>
...
<!-- 2、配置多对多联系 -->
<!-- name：本类声明的另一个类的集合名
table：联系两个表的第三张表
key：该表联系字段（第三张表中）-->
<set name="fis" table="powers" inverse="false" lazy="true">
<key>
<column name="aid" />
</key>
<!-- colum：另一张表联系字段（第三张表中） -->
<many-to-many class="com.sqf.entity.Function" column="fid"/>
</set>
</class>
</hibernate-mapping>
//【类2】
public class Function {
private int id;
private String name;
private int parentid;
private String url;
private boolean isleaf;
private int nodeorder;
//声明另一个多的set集合
Set<AdminInfo> ais=new HashSet<>();
//set、get各个属性，包括Set集合
}
//【类2配置文件】Function.hbm.xml
<hibernate-mapping>
<class name="com.sqf.entity.Function" table="functions">
<id name="id" type="int">
<column name="id" />
<generator class="native" />
</id>
...
<!-- 2、配置多对多关联关系 -->
<set name="ais" table="powers" inverse="true" lazy="true">
<key>
<column name="fid" />
</key>
<many-to-many class="com.sqf.entity.AdminInfo" column="aid" />
</set>
</class>
</hibernate-mapping>【注】
- xml配置文件分为两部分：类本身信息的配置+类关系的配置
- 类本身属性的配置：id---用id标签，其他属性均用property 标签
- 类关系的配置：主要配置声明在本类的其他类类型的对象或集合
- 一对多，多对一连接的方式是外键：表中---一的主键声明在多的属性中作为外键
- 类中---一中声明多类型的集合；多种声明一类型对象
- 多对多连接方式是另建一个关系表：关系表中--相关表的主键作为关系表的属性
- 类中---每个类声明一个另一个类型的set集合
（二）注解实现
1、1对多
将1的对象声明在多的类中，在1中声明多类型的集合
如： type和product：1：n 一个type对应多个product
（1）Type 【oneToMany】
@Entity
@Table(name="type" ,catalog="digital")
public class Type {
private int id;
private String name;
private Set<Product> pis=new HashSet<>();//在One的里面声明一个Many类型的集合
//一对多:;one:类型，many：商品
//mappedBy="type" 放弃维护权，由多的维护，type为product类中声明的type类型的type
//cascade={CascadeType.ALL}，级联操作
@OneToMany(mappedBy="type" ,cascade={CascadeType.ALL})
//set注入
public Set<Product> getPis() {
return pis;
}
public void setPis(Set<Product> pis) {
this.pis = pis;
}
//本类其他属性set get封装;构造方法略
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name="id",unique=true,nullable=false)
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Column(name="name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}注解：
@OneToMany(mappedBy="type" ,cascade={CascadeType.ALL})
替代xml文件中部分：
<!-- 1、配置集合 -->
<!-- 控制权的反转 ：inverse="true"主动放弃维护关系，由多的一方product维护联系（在两表有联系情况下使用，提高效率，没有额外update语句）-->
<!-- 2、级联操作：删一个表，与之联系的表对于删除 -->
<set name="pis" inverse="true" cascade="all">
<!-- 3、两表联系的外键 tid-->
<key column="tid"></key>
<one-to-many class="com.sqf.entity.Product"/>
</set>*/
（2）Product【ManyToOne】
@Entity
@Table(name="product_info" ,catalog="digital")
public class Product {
private int id;
private String code;
private String name;
...
private Type type;//tid外键不用封装,1对多，将1的对象声明在多的类中
//多对一 many是商品，one是类型，数据库表中tid（通过tid联系两表）
@ManyToOne
@JoinColumn(name="tid")
//本类的属性set get封装、有参无参略
public Type getType() {
return type;
}
public void setType(Type type) {
this.type = type;
}
}注解：
@ManyToOne
@JoinColumn(name="tid")替代xml文件的部分：
<many-to-one name="type" class="com.sqf.entity.Type" lazy="false" fetch="join">
<column name="tid" />
</many-to-one>出现在多的这一边，与另一个类多对一对应 ：
column：外键表字段（一的主码放在了多的这边作为外键）
lazy:两条sql语句同时进行不延迟 fetch=jion：将多表连接在同一个sql语句中执行
2、多对多
多对多：两个里面都要写另一个set集合对象
【类1】
@Entity
@Table(name="admin_info" ,catalog="digital")
public class AdminInfo {
private int id;
private String name;
private String pwd;
private String role;
Set<Function> fis=new HashSet<>(); //声明另一个多的set集合
/*********多对多********/
//维护联系的一方：多一个join
//三个字段：power第三张联系表的表名；（colums:可以有多个外键连接functions表，）
//aid外键，本表在power表中对应的id外键,fid外键，另一个功能表在power表中对应的id外键
@ManyToMany()
@JoinTable(name="power",joinColumns={@JoinColumn(name="aid")},
inverseJoinColumns={@JoinColumn(name="fid")})
public Set<Function> getFis() {
return fis;
}
//set注入
public void setFis(Set<Function> fis) {
this.fis = fis;
}
//本类的属性set get、构造函数略
}
【类2】
@Entity
@Table(name="functions" ,catalog="digital")
public class Function {
private int id;
private String name;
private int parentid;
private String url;
private boolean isleaf;
private int nodeorder;
//声明另一个多的set集合
Set<AdminInfo> ais=new HashSet<>();
/*********多对多********/
//写另一个类中的集合名：表示本表放弃维护
@ManyToMany(mappedBy="fis")
public Set<AdminInfo> getAis() {
return ais;
}
public void setAis(Set<AdminInfo> ais) {
this.ais = ais;
}
//本类的属性set get、构造函数略
}【注】
- 注解形式的属性声明方式、声明什么样的对象同xml
- 注解映射数据库：类本身及其属性+类之间关系
- 类本身：@Entity ---标注位实体类
@Table(name="admin_info" ,catalog="digital")---对应数据库中表名、数据库名- 类属性：id属性---- @Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name="id",unique=true,nullable=false)- 非id属性-- @Column(name="属性名")
- 类之间关系：一对多--@OneToMany(mappedBy="一的表名" ,cascade= {CascadeType.ALL})
- 多对一---@ManyToOne
@JoinColumn(name="tid")- 多对多---@ManyToMany(mappedBy="声明在本类中的其他类型的Set集合名")
四、SQL语句的书写
1、@Before 获取session对象
@Before
public void init(){
//1.加载hibernate.cfg.xml数据库总文件
registry=new StandardServiceRegistryBuilder().configure().build();
//2.根据配置文件获得session factory对象
sessionfactory=new MetadataSources(registry).buildMetadata().buildSessionFactory();
//3.获得session对象
session=sessionfactory.openSession();
//4.开启事物。获得事务处理transaction对象
transaction=session.beginTransaction();
}2、 @Test 写相应的语句
@Test
public void test_hql1(){
//1.定义要查询的hql语句
String hql="from Product";
//2.创建查询的query对象，调用list方法将查询结果保存到集合中
Query query=session.createQuery(hql);
List<Product> list=query.list();
//3、拿到结果循环输出（业务中是从session域中拿结果）
for(Product p:list){
System.out.println(p.getName());
}
}增 Admin admin=new Admin("李四", "22");
session.save(admin);改 Admin admin=session.load(Admin.class, 1);
admin.setName("张三");
session.update(admin);删 Admin admin=session.load(Admin.class, 2);
session.delete(admin);
3、@ After 提交事务，释放资源
@After
public void destory(){
transaction.commit();
session.close();
sessionfactory.close();
}五、缓存机制
（一）一级缓存----session缓存
1、session缓存是事务级的，随着事务的开启而开启，事务的关闭而关闭
session缓存是Hibernate内置的，不能被程序员取消的
2、当多次查询同样的操作时，后面的操作是用的session缓存中的值
3、 操作机制
- 当执行修改数据库操作的时候，数据库首先将要修改的数据通过session缓存备份到快照中， 即session缓存中一份数据，快照中备份一份数据；
- 当执行修改操作时，执行的是session缓存中的对象数据（堆中），然后将修改后的堆中的数据和快照进行比较（原数据）
相同，不执行update操作，
不相同，执行update操作
4、session的同步和更新
session的同步：将session缓存中的数据同步到数据库
session刷新：更新缓存中的数据，在执行数据修改操作之后，执行上面三个任意一个才会更新缓存中数据
（二）二级缓存---SeesionFactory级缓存
1、二级缓存的生命周期与SessionFactory一致
2、SessionFactory的缓存可以分为内置缓存和外置缓存
内置缓存----存放映射元数据和预定义SQL语句
外置缓存---Hibernate的二级缓存---第三方的插件--需要开启
3、二级缓存的分类
- 类缓存：缓存对象为实体类对象
- 集合缓存：缓存对象为集合类对象
- 查询缓存：缓存对象为查询结果
4、二级缓存的并发访问策略---默认只读
六、hibernate和mybatis比较
【相同点】
1、两者都需要通过各自框架的配置文件连接数据库
2、都要将各层的对象声明到各自框架的配置文件中
3、dao接口都是只声明操作数据库函数
4、Hibernate与MyBatis都可以是通过SessionFactoryBuider 由XML配置文件生成SessionFactory，然后由SessionFactory 生成Session，最后由Session来开启执行事务和SQL语句。
5、Hibernate和MyBatis都支持JDBC和JTA事务处理。
【不同点】
1、hibernate实现接口类采用daoImpl实现类的方式，在实现类中写对应的sql语句，所有sql语句要详细写
mybatis实现接口类采用 dao.xml mapper映射文件的形式，在mapper文件映射dao接口并用标签声明对象，并在mapper文件中写sql
有些控制语句可以用标签形式，（动态sql），更智能化
详见mybatis 动态sql if for的使用
2、hibernate是全自动，而mybatis是半自动
hibernate完全可以通过对象关系模型实现对数据库的操作，拥有完整的JavaBean对象与数据库的映射结构来自动生成sql。
而mybatis仅有基本的字段映射，对象数据以及对象实际关系仍然需要通过手写sql来实现和管理。
3、hibernate数据库移植性远大于mybatis
hibernate通过它强大的映射结构和hql语言，大大降低了对象与数据库（Oracle、MySQL等）的耦合性，
而mybatis由于需要手写sql，因此与数据库的耦合性直接取决于程序员写sql的方法，如果sql不具通用性而用了很多某数据库特性的sql语句的话，移植性也会随之降低很多，成本很高。
4、hibernate拥有完整的日志系统，mybatis则欠缺一些
hibernate日志系统非常健全，涉及广泛，包括：sql记录、关系异常、优化警告、缓存提示、脏数据警告等；而mybatis则除了基本记录功能外，功能薄弱很多。
5、hibernate较mybatis相比需要关心很多细节
hibernate配置要比mybatis复杂的多，学习成本也比mybatis高。但也正因为mybatis使用简单，才导致它要比hibernate关心很多技术细节。mybatis由于不用考虑很多细节，开发模式上与传统jdbc区别很小，因此很容易上手并开发项目，但忽略细节会导致项目前期bug较多，因而开发出相对稳定的软件很慢，而开发出软件却很快。hibernate则正好与之相反。但是如果使用hibernate很熟练的话，实际上开发效率丝毫不差于甚至超越mybatis。
6、sql直接优化上，mybatis要比hibernate方便很多
由于mybatis的sql都是写在xml里，因此优化sql比hibernate方便很多。而hibernate的sql很多都是自动生成的，无法直接维护sql；虽有hql，但功能还是不及sql强大，见到报表等变态需求时，hql也歇菜，也就是说hql是有局限的；hibernate虽然也支持原生sql，但开发模式上却与orm不同，需要转换思维，因此使用上不是非常方便。总之写sql的灵活度上hibernate不及mybatis。
7、缓存机制上，hibernate要比mybatis更好一些
MyBatis的二级缓存配置都是在每个具体的表-对象映射中进行详细配置，这样针对不同的表可以自定义不同的缓存机制。并且Mybatis可以在命名空间中共享相同的缓存配置和实例，通过Cache-ref来实现。
而Hibernate对查询对象有着良好的管理机制，用户无需关心SQL。所以在使用二级缓存时如果出现脏数据，系统会报出错误并提示。
总结：
- hibernate---有daoImpl实现类 框架配置文件 hibernate.xml
mybatis-----有dao.xml 框架配置文件 mybatis.xml
- Hibernate：智能机器人，但研发它（学习、熟练度）的成本很高，工作都可以摆脱他了，但仅限于它能做的事。
MyBatis：机械工具，使用方便，拿来就用，但工作还是要自己来作，不过工具是活的，怎么使由我决定。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
