Hibernate
来源:互联网 发布:人工鱼群算法 编辑:程序博客网 时间:2024/06/09 15:34
Hibernate
序
创建 hibernate 工程示例:
- 创建工程,引入 jar 包
- 创建配置文件 hibernate.cfg.xml, 配置数据库连接
- 编写实体类(
entity
), 标明注解, 然后配置在 hibernate.cfg.xml 中 - 创建
SessionFactory
, 获取Session
, 通过操作实体类操作数据库。
Session
对象的三种状态:
Transient
, 瞬时状态,指的是对象已经被初始化,但没有跟 hibernate 的 session 建立过联系,即数据库里没有数据对应。Persistent
, 持久化状态,指的是对象在数据中有对应数据,对象有 id 值。它可能是通过 save 或 load 等方式得到的,并且在 session 缓存中有定义。Detached
, 脱管状态,曾经被持久,在数据库中有数据对应。但是,在 session 缓存里没有记录。也许是 session 关闭了,也许是清空了。
状态之间可以进行转换,下面是大致的转换流程:
get/load/query()
- get/load 会优先在 session 缓存里寻找对象,如果找不到,再去查询数据库
- query 会直接查询数据库
- get 不懒,会立刻查询。如果没有找到,那么返回 null
- load 延迟加载,立刻返回一个代理对象。如果没有找到,那么抛出异常
LazyInitializationException
!!!
flush/refresh()
flush 将 session 缓存里的数据同步到数据库,触发相应的 sql 语句。
以下情况,会触发 flush 操作:
- 调用 commit 的时候,会触发 session.flush() 操作。
- 执行 session.createQuery() 查询的时候,也会触发 flush 操作。
- 手动执行 flush 操作。
refresh 是将数据库里的信息,同步到 session 缓存。
clear/evict()
从 session 缓存中清理数据
save/persist()
都是用来将瞬时对象变为持久化对象,即将数据插入数据库,对应 insert 语句。
save 是 hibernate 原生的语法,persist 是 jpa 的语法。
在执行的时候,不会立刻插入数据,只有执行了 flush 操作,才真正触发数据库操作。
save/persist 方法会立刻为实体类对象生成主键。
他们的区别是, 如果在保存之前,重新手动赋予了主键:
- save 会忽视你的赋值
- persist 会抛异常
update/merge()
- 他们主要用来完成实体类对象的修改,对应的是 update 语句。
- 若更新一个持久化对象,可以不显式调用 update, 因为 flush 操作会触发 update
- 可以将一个脱管对象转换为持久化对象
- merge 是 jpa 中的语法
doWork
可以将 jdbc 的 connection 对象暴露出来,用于插入一些 jdbc 操作语法。
Identifier
-- JPA 默认@GeneratedValue(strategy = GenerationType.AUTO/IDENTITY/SEQUENCE/TABLE)-- JPA 定制序列/Table@GeneratedValue(generator = "xxx")@SequenceGenerator(name = "xxx", sequenceName = "seq_xxx", associateSize = 1)@TableGenerator(name = "xxx", table = "tb_xxx")-- Hibernate 格式的 generator:@GeneratedValue(generator = "yyy")@GenericGenerator(name = "yyy", strategy = "native")@GenericGenerator(name = "yyy", strategy = "uuid2")@GenericGenerator(name = "yyy", strategy = "table")
Association
1-N
一对多的关系,在数据库的角度,需要使用外键维护这种关系。
一般情况下,在多的一边的表上,建立一个外键映射到另一个表。
比如,有两个表 author, book 一般而言,book 的定义类似是这样的:
create table book { bookid int primary key, name varchar2(20) not null, price float, publish_date date default sysdate, -- 下面字段用来维护跟作者的关系 -- 它是一个外键约束 authorid references author}
book/author 分别对应实体类 Book/Author,我们可以在其中任意一个实体类中,设置他们的关系。
如果只是在其中一个中设置关系,那么叫“单边关系”、“单向关联”,否则是“双向关联”。
其中最常用的是 多对一的单向关联 和 *多对一的双向关联*。
多对一的单向:
public class Author { @Id @GeneratedValue private long id; private String name;}public class Book { @Id @GeneratedValue private long id; private String name; private FLoat price; // 只是在多的一段设置关系。这是非常常用的一种方式。 // 用 @JoinColumn 定制外键字段的名字 @ManyToOne @JoinColumn private Author author;}
多对一的双向关系:
// 多的一端,即主端,需要负责维护关系public class Book { @Id @GeneratedValue private long id; private String name; private FLoat price; // 只是在多的一端设置关系。这是非常常用的一种方式。 // 用 @JoinColumn 定制外键字段的名字 @ManyToOne @JoinColumn private Author author;}// 一的一端,即从端,需要当甩手掌柜public class Author { @Id @GeneratedValue private long id; private String name; // 不要让双方都去维护关系,不然会有冲突或重复。 // 一般情况下,需要让多的一端维护关系即可。这里用 mappedBy 表名,自己当甩手掌柜。 @OneToMany(mappedBy = "author") private Set<Books> books = new HashSet<>();}
在数据插入的时候,要先保存一的一端,再保存多的一端,否则,会有冗余的 SQL 语句。
M-N
- 多对多的关系,需要使用中间表维护双方关系。对应的注解为
@ManyToMany
- 必须为双方制定从属关系,也就是将维护关系的责任交给其中一个实体类(
mappedBy
),从而避免重复或冲突。 - 可以使用
@JoinTable
对中间表进行定制
例子:
@Entitypublic class Emp { @ManyToMany // 负责关系的维护 @JoinTable(...) private Set<Project> projects = new HashSet<>();}@Entitypublic class Project { @ManyToMany(mappedBy = "projects") // 甩手掌柜 private Set<Emp> emps = new HashSet<>();}
1-1
两种方式:
- 在其中一个表上创建一个列,保存另一个表的主键。即外键关联。
- 两个表,有关联的数据,使用相同的主键。即主键关联。
外键关联:
@Entitypublic class Person { @Id @GeneratedValue // 主键自动生成 private long id; @OneToOne @JoinColumn // 负责维护外键 private IdCard idcard;}@Entitypublic class IdCard { @Id @GeneratedValue // 主键自动生成 private long id; @OneToOne(mappedBy="idcard") // 甩手掌柜 private Person person;}
主键关联:
@Entitypublic class Person { @Id // 主键*不要*自动生成!! private long id; @OneToOne // 负责维护外键,将外键映射到主键。即将另一张表的外键映射到本表的主键。 @MapsId @JoinColumn(name = "id") private IdCard idcard;}@Entitypublic class IdCard { @Id @GeneratedValue // 主键自动生成 private long id; @OneToOne(mappedBy="idcard") // 甩手掌柜 private Person person;}
Embed
这不属于关联关系,只是一种包含:
@Entityclass Person { @Embedded private Name name;}@Embeddableclass Name { String firstName; String lastName;}
Inheritance
SINGLE_TABLE
将所有的东西塞进 一张表 中,即所有的子类跟父类使用一张表, 在这张表中使用“区别列”(DiscriminatorColumn)来区分各个类。
这是默认的继承策略。
@Entity@Inheritance(strategy = InheritanceType.SINGLE_TABLE)@DiscriminatorColumn(name = "xxx") // 可以定制分割列的名字public class Animal {}@Entity@DiscriminatorValue("狗") // 可以定制public class Dog extend Animal {}
它并不符合范式,但也有自己的优点:
- 使用了区别的列
- 只使用了一张表,所以查询速度快
- 缺点:子类的独有列,不能添加唯一/非空约束
- 缺点:太多冗余字段
JOINED
是一种完全“符合范式”的设计:
- 将所有共有的属性提取到父表中
- 仅将子类特有的属性保存到子表中
- 父表跟子表通过外键的方式建立关系
- 如果查询子表的详细数据,通过关联查询关联相关表即可
@Entity@Inheritance(strategy = InheritanceType.JOINED)public class Animal { }@PrimaryKeyJoinColumn(name = "xxxxid") // 可以定制关联主键public class Dog extend Animal { }
总结:
- 优点:没有任何冗余
- 缺点:查询的效率低,因为需要关联各张表
TABLE_PER_CLASS(union)
每个类对应一张表,大家互相隔离,各自为政!
@Entity@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)public class Animal { }@Entitypublic class Dog extend Animal { }
总结:
- 优点:独立,自由,查询快
- 如果只查询子类,那么不需要任何关联;但如果查询父类的话,需要使用 Union 关联各表
- 缺点:存在冗余字段
- 缺点:如果要更新父类中的字段,每个子表都需要去更新
MappedSuperclass
如果父类不是 Entity,只是为子类提供公共属性,那么,将其注解为 @MappedSuperclass
即可。
@MappedSuperclassabstract public class Person { @Id private long id; @Column private String name;}@Entitypublic class Girl extend Person { private String wechat;}@Entitypublic class Boy extend Person { private String address;}
**
级联(Cascade)
比如说,一个部门有很多员工,它们是多对一的关系。如果我们要删除1号部门:
Dept d = session.load(Dept.class, 1L);session.delete(d);
我们会删除失败并得到一个异常,因为部门被员工数据引用,所以要删除部门前,需要先将引用到部门的所有员工删掉。
如果我们不想手动删除部门内部员工,那么可以采取 *级联操作*,即对 Dept
实体类中的 emps
属性这样设置:
@OneToMany(mappedBy="dept", cascade=CascadeType.REMOVE)private List<Emp> emps = new ArrayList<>();
那么,再去执行删除操作的时候,部门、连带它所有的员工,都会被删除。一步到位,快速绝伦。
除了删除操作,级联的类型还有:
- CascadeType.PERSIST
- CascadeType.MERGE
- CascadeType.REFRESH
- CascadeType.ALL (快捷方式,代指所有)
虽然 cascade 会让我们的代码更简介,使用更方便。但是,在工业环境中,*不建议使用 cascade 设置*。
删除数据的方式
第一种方法:
// 优点:快速简洁// 缺点:不能关联删除Product product = new Product();product.setId(44L);session.delete(product);
第二种方法:
// 优点,能关联删除// 缺点,不直接Product product = session.load(Product.class, id); // load, not getsession.delete(product);
第三种方法:
// 优点,更灵活// 缺点,跟第一种方式一样,不能删除关联int result = session .createQuery("delete Product where id = :id") .setParameter("id", 44L) .executeUpdate();
查询
get/load
根据主键进行查询。这是最基本,最高效的一种查询手段。
Query
//// 基本语法String hql = "from xxx where yyy";Query query = session.createQuery(hql);query.setParameter("aaa", "bbb");query.uniqueResult();// 可以用链式语法简化语句session.createQuery("from xxx where yyy").setParameter("aaa", "bbb").uniqueResult();//// select 语句 和 返回值from Emp e where e.name = 'x'; // 默认不需要写 select, 那么会将结果封装到 Emp 对象中select e from Emp e where e.name = 'x'; // 上面的语句,跟此句是一致的select name from Emp; // 返回值:Objectselect name, salary from Emp; // 返回值:Object[]select new list(name) from Emp; // 返回值:ArrayListselect new map(name, salary) from Emp; // 返回值:HashMapselect new map(name as name, salary as sal) from Emp; // 定制 key 值select new Boy(name, salary) from Emp; // 返回值:Boy 对象//// 得到返回结果session.createQuery("from Book", Book.class).uniqueResult();session.createQuery("from Book", Book.class).list();session.createQuery("from Book", Book.class).iterate().next();// 过滤操作session.createFilter(customer.getOrders(), "where price > 5000").list();//// 聚合函数及其他运算符的使用// 返回值:Object[]select max(salary), avg(salary), sum(salary) from Emp;// group byselect max(salary), avg(salary), sum(salary) from Emp e group by e.department;// 将结果封装到 map 中select new map(max(salary) as maxsal, avg(salary) as avgsal, sum(salary) as sumsal) from Emp e group by e.department;// 运算符和函数select sum(salary + nvl(commission, 0)) as res from Emp;//// join// Query 不能使用 JOIN 抓取策略。Query 默认使用 select 语句进行关联数据的加载。// 如果想强制使用 join 语句,需要通过 hql 语句指定:/// 1. 隐式设置from Emp e where e.department.location = 'NEW YORK';/// 2. 显式调用// fetch 决定最后结果的形式:// - 有 fetch: [Emp, Emp, ...]// - 无 fetch: [[Emp, Dept], [Emp, Dept]]from Emp e join e.dept where e.name = 'xxx';from Emp e left join e.dept where e.name = 'xxx';from Emp e left join fetch e.dept where e.name = 'xxx';//// 分页、总行数long count = session.createQuery("select count(*) from Emp", Long.class).uniqueResult();long count = session.createQuery("select count(*) from Emp", Long.class).iterate().next();// oracle: rownum/row_number()// sqlserver: top/row_number()// mysql/sqlite: limit x offset y// hibernate 通过下面语句屏蔽了底层细节:/// 从 80 行开始,取 5 行记录session.createQuery("from xxx").setFirstResult(80).setMaxResults(5).list();//// delete & updatedelete Emp where name = :oldName;update Emp set name = :newName where id = :id;// 级联操作的设置,对 Query 也是无效的,比如,想删除一个部门,需要先删除员工,再删部门:delete Emp e where e.department.deptno = '#DN';delete Dept where deptno = '#DN';
Criteria
Criteria,标准、规范,它是 Criterion 的复数形式。
优势:
- 面向对象
- 不用拼接sql,方便扩展
- 统一性,跨数据库
Criteria 接口: 表示特定类的一个查询
Criterion 接口: 表示一个限定条件
示例:
// Session 是 Criteria 的工厂// Criterion 的主要实现由 Example、Junction 和 SimpleExpression// Criterion 一般通过 Restrictions 提供的工厂方法获得List<Emp> emps = session.createCriteria(Emp.class) // 创建 .add( Restrictions.like("name", "K%") ) // 模糊 .add( Restrictions.gt( "salary", 2000F ) ) // 大于 .addOrder( Order.desc("salary") ) // 排序-1 .addOrder( Order.desc("commission") ) // 排序-2 .list();// 约束可以按逻辑分组List<Emp> emps = sess.createCriteria(Emp.class) .add( Restrictions.like("name", "K%") ) .add( Restrictions.or( Restrictions.ge( "salary", 3000F ), Restrictions.isNotNull("commission") ) ) .list();// Property~Example 是添加约束的另两种方法List<Emp> emps = session.createCriteria(Emp.class) .add(Property.forName("name").eq("KING")) // Property .add(Example.create(king)) // 将 king 上的数据封装成条件 .list();//// 关联查询List<Emp> emps = session.createCriteria(Emp.class) .createCriteria("depts") // vs. createAlias .add( Restrictions.eq("location", "NEW YORK") ) .list();//// Projections 提供投影查询,并能分组聚合// 投影条件ProjectionList projectionList = Projections.projectionList() .add( Projections.property("dept") ) .add( Projections.rowCount() ) .add( Projections.max("salary") ) .add( Projections.sum("salary", "sum" ) ) .add( Projections.groupProperty("dept") );// 查询结果List<Object[]> rs = session.createCriteria(Emp.class) .setProjection( projectionList ) .addOrder( Order.asc("sum") ) .list();
NativeSQL
基本语法,默认的返回的结果为 Object[]:
session.createNativeQuery("select ename, sal from emp").list();session.createNativeQuery("select * from emp").list();session.createNativeQuery("select * from emp e, dept d where e.deptno=d.deptno and d.loc=:loc") .setParameter("loc", "NEW YORK") .list();
可以通过 addScalar()
设置返回类型,并限定结果:
// 下面的查询,得到的结果为 Object[], 包含两个元素:0:id / 1:namesession.createNativeQuery("select * from emp where id=9999") .addScalar("empno", StandardBasicType.INTEGER) .addScalar("ename", StandardBasicType.STRING) .list();
也可以将结果封装到 Entity(实体类) 中:
// simplestsession.createNativeQuery("select * from emp where sal > 2000") .addEntity(Emp.class).list();// with aliassession.createNativeQuery("select e.* from emp e where sal > 2000") .addEntity("e", Emp.class) .list();// multiplesession.createNativeQuery("select e.*, d.* from emp e join dept d using (deptno) where e.sal > 2000") .addEntity("e", Emp.class) .addEntity("d", Dept.class) .list();
将结果封装到普通对象(非实体类)。注意,必须要使用 addScalar()
设置字段:
List<Person> persons = session.createSQLQuery("select * from emp") .addScalar("ename", StandardBasicType.INTEGER) .addScalar("salary", StandardBasicType.FLOAT) .setResultTransformer(Transforms.aliasToBean(Person.class)) .list();
NameQuery
Query Strategy
一个实体类对象,里面有各个属性,这些属性的值可能不是在同一张表中。
为了效率,需要有一定加载策略,主要两个方面:
- when,属性数据的加载时机,是否在加载这个实体类的时候就立刻加载。
- how,通过什么样的语句加载,select/join/其他。
比如,有一个实体类,叫 Girl
:
@Entitypublic class Girl { // 基本数据,保存在 girl 表中的数据: // select id, name from girl; // 这种数据的默认加载机制是: // 1. when: 立刻加载(EAGER) // 2. how: SELECT 语句 @Id private long id; private String name; // 关联数据,单结果,保存在 boy 表中的: // select * from boy where id='我的老父亲,您的编号'; // 这种方式的默认加载机制是: // 1. when: 立刻加载(EAGER) // 2. how: LEFT JOIN 连接 @ManyToOne private Boy father; // 关联数据,结果集,保存在 bag 表中的 // select * from bag where big_owner='女孩的编号'; // 这种属性数据的默认加载机制是: // 1. when: 延迟加载(LAZY) // 2. how: SELECT 语句 @OneToMany(mappedBy = "girl") private Set<Bag> bags = new HashSet();}
如果我们调用 session.load(Girl.class, 1L)
, 会加载编号为 1 的女孩的数据。
她的数据分为三种:
- 基本数据,包含在 girl 表中的,比如 =id/name=。
- 关联数据/XtoOne,比如
father
属性。 - 关联数据/XtoMany,比如
bags
属性。
可以通过 fetch 属性/@Fetch 注解
定制加载策略,分别对应 when/how
, 例:
@ManyToOne(fetch = FetchType.EAGER)// 定义加载的时机(when)@Fetch(FetchMode.SELECT) // 定义加载语句的样式(how)private Boy boyfriend;
- 如果 when 为
EAGER=,默认的 how 为 =FetchMode.JOIN
- 如果 when 为
EAGER=,可以定制使 how 为 =FetchMode.SELECT/SUBSELECT
- 如果 how 为
JOIN
, 那么 when 只能是EAGER
- 如果设置了
hibernate.default_batch_fetch_size
或在实体类/集合上标注了@BatchSize
, 会对LAZY
属性加载采取批量优化。 @Fetch(FetchMode.SUBSELECT)
可以优化 HQL 返回的列表的关联数据查询语句- *JOIN 策略对 Query 查询无效*,如需关联查询,在语句中显式调用 join 语句!
N+1 问题
比如,如果:
打印出编号大于10的部门中的所有员工姓名。
那么,语句大致如此:
String hql = "from Dept where depto > :dn";List<Dept> depts = session.createQuery(hql, Dept.class) .setParameter("dn", 10) .list();for(Dept dept: depts) { for(Emp emp : dept.getEmps()) { System.out.printf("部门: %s, 姓名: %s\n", dept.getName(), emp.getName()); }}
因为 @OneToMany
默认是 Lazy + SELECT
策略,所以,每个部门的员工只有使用的时候才去查询。
这就导致了上面的语句发送很多条 select 语句(N+1),严重影响效率。
*这就是 N+1 问题*。
解决方案有主要有下面几种:
- 在 hql 语句中,使用 join 语句进行关联查询。
- 将 Dept#emps 的策略设置为
SUBSELECT
方式。 - 采取批量抓取的优化方式(
BatchSize
),即在 Dept#emps 上面加上注解: =@BatchSize(size=n)=。 - 使用二级缓存。
缓存(Cache)
缓存分为三种:事务范围;应用范围;集群范围。
二级缓存是应用范围的缓存机制。适合放入二级缓存的数据:
- 很少修改,不会修改,或不允许被更改的数据(常量数据)
- 不是很重要,允许偶尔出错的数据
而一些重要的数据或者修改频繁的数据,是不适合放到缓存里的。
配置使用二级缓存过程:
- 加入 JAR 包支持:
"org.hibernate:hibernate-ehcache:5.2.11.Final"
- 配置 /ehcache.xml [可选]
- 在 hibernate.cfg.xml 中启用:
<prop key="hibernate.cache.use_second_level_cache">true</prop><prop key="hibernate.cache.use_query_cache">true</prop><prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.SingletonEhCacheRegionFactory</prop>
- 配置要被缓存的类或集合
@Cachable@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
- 使用示例
session.createQuery("from Employee where id=7782").setCacheable(true).list();session.createQuery("from Employee where id=7782").setCacheable(true).list();session.createQuery("from Employee where id=7782").setCacheable(true).list();
锁(Lock)
Hibernate 中,设置锁定有下面三种方式:
session.load(Male.class, 1L, LockMode.WRITE)session.lock(m, LockModeType.WRITE);session.createQuery(hql).setLockMode(LockModeType.PESSIMISTIC_WRITE);
Hibernate 中锁的类型,分为两种:
- 悲观锁。使用数据库底层的
for update
语句。数据会被锁定,直到事务结束。 - 乐观锁。使用实体类中的额外字段(
@Version
)。它不会真正在数据上加锁,而是用版本号区别记录的不同。-- 它会在初次读取数据时将 version 一起读出,得到【版本号】,比如 10-- 等到提交数据的时候,发送下面语句:update xxx set version = 10 + 1, ... where id = 2 and version = 10;-- 如果数据被别人修改过,那么 version 已经不是 10,所以上面语句不会更新到任何数据。-- 同样,hibernate 会抛出下面异常:---- javax.persistence.OptimisticLockException: Batch update returned unexpected row count from update [0]; actual row count: 0; expected: 1-- 从而防止了数据的修改冲突。
- hibernate
- Hibernate
- Hibernate
- Hibernate
- hibernate
- hibernate
- Hibernate
- Hibernate
- Hibernate
- hibernate
- Hibernate
- Hibernate
- hibernate
- hibernate
- hibernate
- Hibernate
- Hibernate
- hibernate
- 获取电脑的软硬件信息
- 简明Python教程笔记二 python3.x
- 欢迎使用CSDN-markdown编辑器
- python -- 格式化time
- vim字体配色
- Hibernate
- xx-net证书问题
- 大数据学习25:Hive 中 distribute by 的测试
- 关于线程
- java流程控制
- 端口映射
- JS获取当前地理位置方法
- 移动端初设置(使用rem作为单位)
- 关闭Linux中的串口打印