Hibernate01 - 入门概念 搭建环境 api
Hibernate02 - 缓存 一对多 多对多：
Hibernate03 -查询方式 OID hql QBC
实体类
实体类编写规则
1、所有的属性都是private
2、所有的属性都需要有公开的getter setter
3、要求我们实体类中有一个唯一值(一般使用id)
4、实体类中的属性 建议不适用基本数据类型 使用包装类
为什么使用包装类？
比如 表示学生的分数，假如 int score;
- 比如学生得了0分 ，int score = 0;
- 如果表示学生没有参加考试，int score = 0;不能准确表示学生是否参加考试
解决：使用包装类可以了， Integer score = 0，表示学生得了0分，
表示学生没有参加考试，Integer score = null;
Hibernate主键生成策略
1 hibernate要求实体类里面有一个属性作为唯一值，对应表主键，主键可以不同生成策略
2 hibernate主键生成策略有很多的值
3 在class属性里面有很多值
（1）native： 根据使用的数据库帮选择哪个值
（2）uuid：之前web阶段写代码生成uuid值，hibernate帮我们生成uuid值
4 演示生成策略值 uuid
（1）使用uuid生成策略，实体类id属性类型必须字符串类型
（2）配置部分写出uuid值
实体类对象状态（概念）
实体类状态有三种
（1）瞬时态：对象里面没有id值，对象与session没有关联
（2）持久态：对象里面有id值，对象与session关联
(3）托管态：对象有id值，对象与session没有关联
演示操作实体类对象的方法
（1）saveOrUpdate方法：实现添加、实现修改
// 如果对象状态是瞬时态 做添加操作
// 如果对象状态是持久态 做修改操作
// 如果对象状态是托管态 做修改操作
User user = new User();
// user.setId(1) 决定性因素
user.setUsername("小李");
user.setPassword("1234");
ser.setAddress("安阳");
// 调用session的方法实现添加
session.saveOrUpdate(user);
Hibernate的一级缓存
什么是缓存
数据存到数据库里面，数据库本身是文件系统，使用流方式操作文件效率不是很高。
- （1）把数据存到内存里面，不需要使用流方式，可以直接读取内存中数据
- （2）把数据放到内存中，提供读取效率
Hibernate缓存
hibernate框架中提供很多优化方式，hibernate的缓存就是一个优化方式
hibernate缓存特点：
第一类 hibernate的一级缓存
-
（1）hibernate的一级缓存默认打开的
-
（2）hibernate的一级缓存使用范围，是session范围，从session创建到session关闭范围
-
（3）hibernate的一级缓存中，存储数据必须持久态数据
第二类 hibernate的二级缓存
-
(1)目前已经不使用了，替代技术 redis
-
(2)二级缓存默认不是打开的，需要配置
-
(3)二级缓存使用范围，是sessionFactory范围
Hibernate事务
事务模板
@Test
public void testTx() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction transaction = null;
try {
sessionFactory = HibernateUtils.getSessionFactory();
session = sessionFactory.openSession();
// 开启事务
transaction = session.beginTransaction();
// ---- 事件操作 ----
// ---- 操作结束 ----
// 提交事务
transaction.commit();
} catch (Exception e) {
transaction.rollback();
}finally {
// 关闭
session.close();
sessionFactory.close();
}
}
Hibernate绑定Session
session类似于jdbc的connection，之前web阶段学过的threadLocal
帮实现与本地线程绑定session
获取与本地线程session
1、在hibernate核心配置文件中配置
2、调用sessionFactory里面的方法得到
获取与本地线程绑定session的时候 ，关闭session报错，不需要手动关闭！
// hibernate的Util类
public class HibernateUtils {
private static Configuration configuration = null;
private static SessionFactory sessionFactory = null;
// 静态代码块实现
static {
// 加载核心配置文件
configuration = new Configuration();
configuration.configure();
sessionFactory = configuration.buildSessionFactory();
}
// 提供返回与本地线程绑的session方法
public static Session getSessionObject(){
return sessionFactory.getCurrentSession();
}
}
@Test // 测试类
public void testSession() {
Transaction transaction = null;
try {
Session session = HibernateUtils.getSessionObject();
// 开启事务
transaction = session.beginTransaction();
// ---- 事件操作 -
// ---- 操作结束 ----
// 提交事务
transaction.commit();
} catch (Exception e) {
transaction.rollback();
}
}
Hibernate的api使用
Quary对象
1、使用query对象 ，不需要写sql语句，但是需要写hql语句
hql：hibernate query language，是hibernate提供的查询语言(和sql语句很相似)
hql和sql的区别：
使用sql操作和表字段
使用hql操作实体类和属性
2、查询所有的hql语句
1、from 实体类名称
3、query对象的使用：
创建Qurey对象
调用Qurey对象里面的方法得到结果
@Testpublic void testQuery(){
Transaction transaction = null;
try {
Session session = HibernateUtils.getSessionObject();
transaction = session.beginTransaction();
// 操作
// 1、创建Query对象
// 方法中写hql语句
Query query = session.createQuery("from User");
// 2、调用query对象里面的方法 得到结果
List<User> users = query.list();
for (User user : users) {
System.out.println(user);
}
transaction.commit();
}catch (Exception e){
transaction.rollback();
}
}
Criteria对象(5.x弃用)
使用这个对象查询操作，但是使用这个对象的时候，不需要写语句了，直接调用方法实现
实现过程
- 创建criteria对象
- 调用对象里面的方法得到结果
@Test
public void testCriteria(){
Transaction transaction = null;
try {
Session session = HibernateUtils.getSessionObject();
transaction = session.beginTransaction();
// 操作
Criteria criteria = session.createCriteria(User.class);
List<User> users = criteria.list();
for (User user : users) {
System.out.println(user);
}
transaction.commit();
}catch (Exception e){
transaction.rollback();
}
}
SQLQuery对象
使用hibernate时候，调用底层sql实现
实现过程
- 创建对象
- 调用对象的方法得到结果
方法1 返回数组集合
@Test
public void testSQLQuery(){
Transaction transaction = null;
try {
Session session = HibernateUtils.getSessionObject();
transaction = session.beginTransaction();
// 操作
NativeQuery sqlQuery = session.createSQLQuery("select * from user");
// 返回list集合每部分是数组
List<Object[]> list = sqlQuery.list();
for (Object[] objects : list) {
System.out.println(Arrays.toString(objects));
}
transaction.commit();
}catch (Exception e){
transaction.rollback();
}
}
输出的数组集合
方法2返回对象集合
@Test
public void testSQLQuery(){
Transaction transaction = null;
try {
Session session = HibernateUtils.getSessionObject();
transaction = session.beginTransaction();
// 操作
NativeQuery sqlQuery = session.createSQLQuery("select * from user");
//方法2：返回list集合每部分是对象
sqlQuery.addEntity(User.class);
List<User> list = sqlQuery.list();
for (User user : list) {
System.out.println(user);
}
transaction.commit();
}catch (Exception e){
transaction.rollback();
}
}
Hibernate的一对多操作（重点）
一对多配置
第一步 创建两个实体类，客户和联系人
第二步 让两个实体类之间互相表示
（1）在客户实体类里面表示多个联系人
一个客户里面有多个联系人
（2）在联系人实体类里面表示所属客户
一个联系人只能属于一个客户
public class Customer {
// 客户id
private Integer cid;
// 客户名称
private String custName;
// 客户级别
private String custLevel;
// 客户来源
private String custSource;
// 联系电话
private String custPhone;
// 手机
private String custMobile;
// 在客户中表示多个联系人
// 在hibernate要求使用集合表示表示多的数据 使用set集合
private Set<LinkMan> linkManSet = new HashSet<LinkMan>();
}
public class LinkMan {
// 联系人 编号；
private Integer lkm_id;
// 联系人 姓名；
private String lkm_name;
// 联系人 性别；
private String lkm_gender;
// 联系人 办公电话；
private String lkm_phone;
// 在联系中表示所属客户 一个联系人 只能属于一个客户
private Customer customer;
}
第三步 配置映射关系
（1）一般一个实体类对应一个映射文件
（2）把映射最基本配置完成
（3）在映射文件中，配置一对多关系
- 在客户映射文件中，表示所有联系人
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<!-- 1 配置类和表对应
class标签
name属性：实体类全路径
table属性：数据库表名称
-->
<class name="com.jsu.entity.Customer" table="t_customer">
<id name="cid" column="cid">
<generator class="native"></generator>
</id>
<property name="custName" column="custName"></property>
<property name="custLevel" column="custLevel"></property>
<property name="custSource" column="custSource"></property>
<property name="custPhone" column="custPhone"></property>
<property name="custMobile" column="custMobile"></property>
<!-- 在客户映射文件中，表示所有联系人
使用set标签表示所有联系人
set标签里面有name属性：
属性值写在客户实体类里面表示联系人的set集合名称
inverse属性默认值：false不放弃关系维护
true表示放弃关系维护
-->
<set name="linkManSet" inverse="true">
<!-- 一对多建表，有外键
hibernate机制：双向维护外键，在一和多那一方都配置外键
column属性值：外键名称
-->
<key column="clid"></key>
<!-- 客户所有的联系人，class里面写联系人实体类全路径 -->
<one-to-many class="com.jsu.entity.LinkMan"/>
</set>
</class>
</hibernate-mapping>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<!-- 1 配置类和表对应
class标签
name属性：实体类全路径
table属性：数据库表名称
-->
<class name="com.jsu.entity.LinkMan" table="t_linkman">
<id name="lkm_id" column="lkm_id">
<generator class="native"></generator>
</id>
<property name="lkm_name" column="lkm_name"></property>
<property name="lkm_gender" column="lkm_gender"></property>
<property name="lkm_phone" column="lkm_phone"></property>
<!-- 表示联系人所属客户
name属性：因为在联系人实体类使用customer对象表示，写customer名称
class属性：customer全路径
column属性：外键名称
-->
<many-to-one name="customer" class="com.jsu.entity.Customer" column="clid"></many-to-one>
</class>
</hibernate-mapping>
第四步 引入核心文件
测试：
一对多级联保存
添加
方法1：
@Test
public void testOneByMoreAdd() {
Transaction transaction = null;
try {
Session session = HibernateUtils.getSessionObject();
transaction = session.beginTransaction();
// ----- 一对多的级联保存
// 需求： 添加一个客户 给客户绑定一个联系人
// 1、添加客户和联系人对象
// 1.1 客户对象
Customer customer = new Customer();
customer.setCustName("alibaba");
customer.setCustLevel("vip");
customer.setCustMobile("001-21311");
customer.setCustSource("网略");
customer.setCustPhone("123334");
// 1.2 联系人
LinkMan linkMan = new LinkMan();
linkMan.setLkm_name("Yue");
linkMan.setLkm_gender("女");
linkMan.setLkm_phone("120");
// 2、在客户中表示联系人 在联系人中表示客户
// 建立客户对象和联系人对象关系
// 2.1 把联系人对象 放到客户的set集合中
customer.getLinkManSet().add(linkMan);
// 2.2 把客户对象放到联系人的customer中
linkMan.setCustomer(customer);
// 3、保存到数据库中
session.save(customer);
session.save(linkMan);
// 提交事务
transaction.commit();
} catch (Exception e) {
transaction.rollback();
}
}
**方法2：**简约版
第一步：在xml的set中配置
第二步：
@Test
public void testOneByMoreAdd2() {
Transaction transaction = null;
try {
Session session = HibernateUtils.getSessionObject();
transaction = session.beginTransaction();
// 1、添加客户和联系人对象
// 1.1 客户对象
Customer customer = new Customer();
customer.setCustName("tengxun");
customer.setCustLevel("普通客户");
customer.setCustMobile("001-21421");
customer.setCustSource("网略");
customer.setCustPhone("123334");
// 1.2 联系人
LinkMan linkMan = new LinkMan();
linkMan.setLkm_name("红");
linkMan.setLkm_gender("女");
linkMan.setLkm_phone("120");
// 2、在客户中表示联系人 在联系人中表示客户
// 把联系人对象 放到客户的set集合中
customer.getLinkManSet().add(linkMan);
// 3、保存到数据库中
session.save(customer);
// 提交事务
transaction.commit();
} catch (Exception e) {
transaction.rollback();
}
}
删除
1 删除某个客户，把客户里面所有的联系人删除
2 具体实现
第一步 在客户映射文件set标签，进行配置
（1）使用属性cascade属性值 delete
第二步 在代码中直接删除客户
（1）根据id查询对象，调用session里面delete方法删除
@Test
public void testOneByMoreDelete() {
Transaction transaction = null;
try {
Session session = HibernateUtils.getSessionObject();
transaction = session.beginTransaction();
// 1、 根据id 查询客户
Customer customer = session.get(Customer.class, 2);
// 调用方法删除
session.delete(customer);
// 提交事务
transaction.commit();
} catch (Exception e) {
transaction.rollback();
}
}
3 执行过程：
- 根据id查询客户
- 根据外键id值查询联系人
- 把联系人外键设置为null
- 删除联系人和客户
修改
// 修改
@Test
public void testOneByMoreUpdate() {
Transaction transaction = null;
try {
Session session = HibernateUtils.getSessionObject();
transaction = session.beginTransaction();
// 1、 根据id 查询客户
Customer customer = session.get(Customer.class, 1);
LinkMan linkMan = session.get(LinkMan.class, 2);
// 设置持久态的值
// 把联系人放到客户里面
customer.getLinkManSet().add(linkMan);
// 把客户方法哦联系人里面
linkMan.setCustomer(customer);
// 提交事务
transaction.commit();
} catch (Exception e) {
transaction.rollback();
}
}
inverse属性
（1）因为hibernate双向维护外键，在客户和联系人里面都需要维护外键，修改客户时候修改一次外键，修改联系人时候也修改一次外键，造成效率问题
（2）解决方式：让其中的一方不维护外键
- 一对多里面，让其中一方放弃外键维护
- 一个国家有总统，国家有很多人，总统不能认识国家所有人，国家所有人可以认识总统
（3）具体实现：
在放弃关系维护映射文件中，进行配置，在set标签上使用inverse属性
Hibernate的多对多操作
多对多映射配置
第一步 创建实体类
第二步 让两个实体类之间相互表示
用户之间表示所有角色
一个角色有多个用户、
public class User {
private Integer user_id;//用户id
private String user_name;//用户名称
private String user_password;//用户密码
//一个用户可以有多个角色
private Set<Role> setRole = new HashSet<Role>();
}
public class Role {
private Integer role_id;//角色id
private String role_name;//角色名称
private String role_memo;//角色描述
// 一个角色有多个用户
private Set<User> setUser = new HashSet<User>();
}
第三步 配置映射关系
基本配置
配置多对多的关系
第四步 在核心配置文件中引入映射文件
多对多级联保存
//演示多对多修级联保存
@Test
public void testSave() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try {
//得到sessionFactory
sessionFactory = HibernateUtils.getSessionFactory();
//得到session
session = sessionFactory.openSession();
//开启事务
tx = session.beginTransaction();
//添加两个用户，为每个用户添加两个角色
//1 创建对象
User user1 = new User();
user1.setUser_name("lucy");
user1.setUser_password("123");
User user2 = new User();
user2.setUser_name("mary");
user2.setUser_password("456
Role r1 = new Role();
r1.setRole_name("总经理");
r1.setRole_memo("总经理");
Role r2 = new Role();
r2.setRole_name("秘书");
r2.setRole_memo("秘书");
Role r3 = new Role();
r3.setRole_name("保安");
r3.setRole_memo("保安");
//2 建立关系，把角色放到用户里面
// user1 -- r1/r2
user1.getSetRole().add(r1);
user1.getSetRole().add(r2);
// user2 -- r2/r3
user2.getSetRole().add(r2);
user2.getSetRole().add(r3);
//3 保存用户
session.save(user1);
session.save(user2);
//提交事务
tx.commit();
}catch(Exception e) {
tx.rollback();
}finally {
session.close();
//sessionFactory不需要关闭
sessionFactory.close();
}
}
多对多级联删除(一般不用 有bug)
维护第三张表关系
1、用户和角色多对多关系，维护关系通过第三张表维护
2、让某个用户有某个角色
- 第一步 根据id查询用户和角色
- 第二步把角色放到用户里面
（1）把角色对象放到用户set集合
3、让某个用户没有某个角色
第一步根据id查询用户和角色
第二步 从用户里面把角色去掉 
Hibernate01 - 入门概念 搭建环境 api
Hibernate02 - 缓存 一对多 多对多：
Hibernate03 -查询方式 OID hql QBC
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
