orm思想
（1）hibernate使用orm思想对数据库进行crud（增加，查询，更新，删除）操作
（2）orm：对象关系映射
A . 让实体类和数据库表进行一一对应关系（使用配置文件完成）
实体类与数据库表对应
实体类属性和表中的字段对应
B . 不需要直接操作数据库表，操作表对印的实体类对象
搭建环境
（1）导入hibernate中的required中的jar包和mysql驱动jar包，另外 还有日志jar包
（2）创建实体类
public class User {
//自动建表
/*hibernate要求实体类中有一个属性的值是唯一的*/
private int uid;
private String uid;
private String username;
private String password;
private String address;
public int getUid() {
return uid;
（3）编写配置文件（xml）
A.名称：实体类名称.hbm.xml
B.引入dtd约束
C.在实体类所在的包中创建
<?xml version="1.0" encoding="UTFD-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
D.配置文件：
<hibernate-mapping>
<!-- 1 配置类和表对应
class标签
name属性：实体类全路径
table属性：数据库表名称
-->
<class name="cn.itcast.entity.User" table="t_user">
<!-- 2 配置实体类id和表id对应
hibernate要求实体类有一个属性唯一值
hibernate要求表有字段作为唯一值
-->
<!-- id标签
name属性：实体类里面id属性名称
column属性：生成的表字段名称
-->
<id name="uid" column="uid">
<!-- 设置数据库表id增长策略
native:生成表id值就是主键自动增长
-->
<generator class="uuid"></generator>
</id>
<!-- 配置其他属性和表字段对应
name属性：实体类属性名称
column属性：生成表字段名称
-->
<property name="username" column="username"></property>
<property name="password" column="password"></property>
<property name="address" column="address"></property>
</class>
</hibernate-mapping>
（4）核心配置文件
（1）位置固定，名称固定
（2）引入dtd约束
（3）hibernate操作过程中，只会加载核心配置文件，其他配置文件不会加载
<hibernate-configuration>
<session-factory>
<!-- 第一部分： 配置数据库信息 必须的 -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql:///hibernate_day01</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
<!-- 第二部分： 配置hibernate信息 可选的-->
<!-- 输出底层sql语句 -->
<property name="hibernate.show_sql">true</property>
<!-- 输出底层sql语句格式 -->
<property name="hibernate.format_sql">true</property>
<!-- hibernate帮创建表，需要配置之后
update: 如果已经有表，更新，如果没有，创建
-->
<property name="hibernate.hbm2ddl.auto">update</property>
<!-- 配置数据库方言
在mysql里面实现分页 关键字 limit，只能使用mysql里面
在oracle数据库，实现分页rownum
让hibernate框架识别不同数据库的自己特有的语句
-->
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- 第三部分： 把映射文件放到核心配置文件中 必须的-->
<mapping resource="cn/itcast/entity/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>
代码
@Test
public void testAdd() {
// 第一步 加载hibernate核心配置文件
// 到src下面找到名称是hibernate.cfg.xml
//在hibernate里面封装对象
Configuration cfg = new Configuration();
cfg.configure();
// 第二步 创建SessionFactory对象
//读取hibernate核心配置文件内容，创建sessionFactory
//在过程中，根据映射关系，在配置数据库里面把表创建
SessionFactory sessionFactory = cfg.buildSessionFactory();
// 第三步 使用SessionFactory创建session对象
// 类似于连接
Session session = sessionFactory.openSession();
// 第四步 开启事务
Transaction tx = session.beginTransaction();
// 第五步 写具体逻辑 crud操作
//添加功能
User user = new User();
user.setUsername("小王");
user.setPassword("250");
user.setAddress("日本");
//调用session的方法实现添加
session.save(user);
// 第六步 提交事务
tx.commit();
// 第七步 关闭资源
session.close();
sessionFactory.close();
}
实体类编写规则
1 实体类里面属性私有的
2 私有属性使用公开的set和get方法操作
3 要求实体类有属性作为唯一值（一般使用id值）
4 实体类属性建议不使用基本数据类型，使用基本数据类型对应的包装类
（1）八个基本数据类型对应的包装类
- int – Integer
- char—Character、
- 其他的都是首字母大写 比如 double – Double
（2）比如 表示学生的分数，假如 int score; - 比如学生得了0分 ，int score = 0;
- 如果表示学生没有参加考试，int score = 0;不能准确表示学生是否参加考试
解决：使用包装类可以了， Integer score = 0，表示学生得了0分，
表示学生没有参加考试，Integer score = null;
主键生成策略
（1）实体类中唯一值作为主键
（2）生成策略有多个值
<!-- 设置数据库表id增长策略
native:生成表id值就是主键自动增长
-->
<generator class="uuid"></generator>
举例：uuid（常用）
对实体类的crud操作
（1）修改
（2）刪除
（3）添加
（4）查訊
实体类的三种状态
（1）瞬时态：对象里面没有id值，对象与session没有关联
（2）持久态：对象里面有id值，对象与session关联
（3）托管态：对象有id值，对象与session没有关联
hibernate事务代码规范
1 代码结构
try {
开启事务
提交事务
}catch() {
回滚事务
}finally {
关闭
例子
@Test
public void testTx() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try {
sessionFactory = HibernateUtils.getSessionFactory();
session = sessionFactory.openSession();
//开启事务
tx = session.beginTransaction();
//添加
User user = new User();
user.setUsername("小马");
user.setPassword("250");
user.setAddress("美国");
session.save(user);
int i = 10/0;
//提交事务
tx.commit();
}catch(Exception e) {
e.printStackTrace();
//回滚事务
tx.rollback();
}finally {
//关闭操作
session.close();
sessionFactory.close();
}
}
hibernate绑定session（本地线程）
（1）在hibernate核心配置文件中配置
（2）调用sessionFactory里面的方法得到
获取与本地线程绑定session时候，关闭session报错，不需要手动关闭了
hibernate的api使用
Query
使用query对象，不需要写sql语句，但是写hql语句
（1）hql：hibernate query language，hibernate提供查询语言，这个hql语句和普通sql语句很相似
（2）hql和sql语句区别：
- 使用sql操作表和表字段
- 使用hql操作实体类和属性
查询所有的hql语句
from 实体类名称
Query对象使用
（1）创建Query对象
（2）调用Query对象中的方法得到结果
Query query = session.createQuery("from User");
List<User> list = query.list();
for (User user : list) {
System.out.println(user);
}
Criteria
使用该对象不需要写语句
Criteria对象使用
（1）创建Criteria对象
（2）调用Criteria对象中的方法得到结果
Criteria criteria = session.createCriteria(User.class);
List<User> list = criteria.list();
SQLQuery
调用底层sql实现
使用
（1）创建对象
（2）调用对象中的方法得到结果
SQLQuery sqlQuery = session.createSQLQuery("select * from t_user");
List<User> list = sqlQuery.list();
for (User user : list) {
System.out.println(user);
}
表与表之间的关系
一对多：在 “多” 的一方创建字段作为外键，指向 “一” 的那一方的主键
多对多：创建第三张表，至少两个字段作为外键，指向两个表的主键
hibernate的一对多操作
映射配置
以客户和联系人为例
（1）创建两个实体类
（2）让两个实体类之间互相表示
①：在客户实体类中表示多个联系人
一个客户中有多个联系人
private Set<LinkMan> setLinkMan = new HashSet<LinkMan>();
public Set<LinkMan> getSetLinkMan() {
return setLinkMan;
}
public void setSetLinkMan(Set<LinkMan> setLinkMan) {
this.setLinkMan = setLinkMan;
}
}
②：再联系人实体类中表示所属客户
一个联系人只能属于一个客户
private Customer customer;
public Customer getCustomer() {
return customer;
}
public void setCustomer(Customer customer) {
this.customer = customer;
}
（3）配置映射关系
①：一般一个实体类在对应一个映射文件
②：在映射文件中配置一对多关系
<!---客户映射文件-!>
<!-- 在客户映射文件中，表示所有联系人
使用set标签表示所有联系人
set标签里面有name属性：
属性值写在客户实体类里面表示联系人的set集合名称
inverse属性默认值：false不放弃关系维护
true表示放弃关系维护
-->
<set name="setLinkMan" inverse="true">
<!-- 一对多建表，有外键
hibernate机制：双向维护外键，在一和多那一方都配置外键
column属性值：外键名称
-->
<key column="clid"></key>
<!-- 客户所有的联系人，class里面写联系人实体类全路径 -->
<one-to-many class="cn.itcast.entity.LinkMan"/>
</set>
<!-- 表示联系人所属客户
name属性：因为在联系人实体类使用customer对象表示，写customer名称
class属性：customer全路径
column属性：外键名称
-->
<many-to-one name="customer" class="cn.itcast.entity.Customer" column="clid"></many-to-one>
（4）创建核心配置文件，将映射文件引入其中
<mapping resource="cn/itcast/entity/Customer.hbm.xml"/>
<mapping resource="cn/itcast/entity/LinkMan.hbm.xml"/>
级联操作
级联保存
（1）添加一个客户，为这个客户添加多个联系人
级联删除
（1）删除某一个客户，这个客户里面的所有的联系人也删除
级联保存
一般根据客户添加联系人
第一步 在客户映射文件中进行配置
- 在客户映射文件里面set标签进行配置
<set name="setLinkMan" cascade="save-update">
第二步 创建客户和联系人对象，只需要把联系人放到客户里面就可以了，最终只需要保存客户就可以了
@Test
public void testAddDemo2() {
SessionFactory sessionFactory = null;
Session session = null;
Transaction tx = null;
try {
//得到sessionFactory
sessionFactory = HibernateUtils.getSessionFactory();
//得到session
session = sessionFactory.openSession();
//开启事务
tx = session.beginTransaction();
// 添加一个客户，为这个客户添加多个联系人
//1 创建客户和联系人对象
Customer customer = new Customer();
customer.setCustName("传智播客");
customer.setCustLevel("vip");
customer.setCustSource("网络");
customer.setCustPhone("110");
customer.setCustMobile("999");
LinkMan linkman = new LinkMan();
linkman.setLkm_name("luvy");
linkman.setLkm_gender("男");
linkman.setLkm_phone("911");
//2 为客户添加联系人
customer.getSetLinkMan().add(linkman);
//3 保存客户
session.save(customer);
//提交事务
tx.commit();
}catch(Exception e) {
tx.rollback();
}finally {
session.close();
//sessionFactory
sessionFactory.close();
}
}
级联删除
第一步 在客户映射文件中进行配置
在客户映射文件里面set标签进行配置
<set name="setLinkMan" cascade="save-update，delete">
第二步 代码中直接删除客户
（1）根据id查询对象，调用session里面delete方法删除
Customer customer = session.get(Customer.class, 3);
session.delete(customer);
多对多操作
映射配置
第一步 创建实体类，用户和角色
第二步 让两个实体类之间互相表示
（1）一个用户里面表示所有角色，使用set集合
（2）一个角色有多个用户，使用set集合
第三步 配置映射关系
（1）基本配置
（2）配置多对多关系
- 在用户里面表示所有角色，使用set标签
<!-- 在用户里面表示所有角色，使用set标签
name属性：角色set集合名称
table属性：第三张表名称
-->
<set name="setRole" table="user_role">
<!-- key标签里面配置
配置当前映射文件在第三张表外键名称
-->
<key column="userid"></key>
<!-- class：角色实体类全路径
column：角色在第三张表外键名称
-->
<many-to-many class="cn.itcast.manytomany.Role" column="roleid"></many-to-many>
</set>
<!-- 在角色里面表示所有用户，使用set标签 -->
<set name="setUser" table="user_role">
<!-- 角色在第三张表外键 -->
<key column="roleid"></key>
<many-to-many class="cn.itcast.manytomany.User" column="userid"></many-to-many>
</set>
第四步 在核心配置文件中引入映射文件
级联操作
根据用户保存角色
第一步 在用户配置文件中set标签进行配置，cascade值save-update
<set name="setRole" table="user_role" cascade="save-update,delete">
第二步 写代码实现
（1）创建用户和角色对象，把角色放到用户里面，最终保存用户就可以了
sessionFactory = HibernateUtils.getSessionFactory();
session = sessionFactory.openSession();
tx = session.beginTransaction();
//添加两个用户，为每个用户添加两个角色
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();
HQL查询
HQL（Hibernate Query Languge，Hibernate 查询语言）查询，是一种面向对象的查询语言，其中没有表和字段的概念，只有类、对象和属性的概念
HQL查询步骤
– 获取Session对象
– 编写HQL查询语句
– 以HQL语句为参数，调用session的createQuery方法，创建查询对象Query；
– 如果HQL语句中带有参数，则调用Query的setXxx方法，对参数赋值。
– 调用Query的list, uniqueResult等方法，查询获得结果
Query 接口用来执行 HQL，Query 接口实例可以从 Session 对象 session 中生成：
session.createQuery(String hql)
常见的hql语句
（1）查询所有： from 实体类名称
（2）条件查询： from 实体类名称 where 属性名称=?
（3）排序查询： from 实体类名称 order by 实体类属性名称 asc/desc
查询所有
条件查询
语法:
from 实体类名称 where 实体类属性名称=? and实体类属性名称=?
from 实体类名称 where 实体类属性名称 like ?
排序查询
567
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
