Hibernate( ORM框架 )
Hibernate是一个数据持久化层的ORM框架. 它通过JavaBean, 数据库中的表与自身的映射关系达到表中数据的增删改查
特性
1.对JDBC访问数据库的代码进行封装, 简化数据访问的重复性代码
2.使用反射机制完成对Bean的封装
3.轻量级框架,支持关系型数据库
核心配置文件的编写
Hibernate的核心配置文件用于连接数据库, 以及添加映射文件(映射文件就是JavaBean属性与数据表之间的对应关系)
核心配置文件文件名必须是: hibernate.cfg.xml //此处的cfg不是文件后缀类型
文件的地址位于src目录下
下面通过例子说明:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<!--session-factory就是对数据库连接的配置-->
<session-factory>
<!--以下都是固定写法-->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <!--配置数据库驱动类-->
<property name="hibernate.connection.url">jdbc:mysql:///test</property> <!--配置数据库服务地址-->
<property name="hibernate.connection.username">root</property> <!--配置数据库用户名-->
<property name="hibernate.connection.password">1234</property> <!--配置数据库登录密码-->
<!--向控制台打印Hibernate执行的sql语句-->
<property name="show_sql">true</property>
<!--优化控制台输出的sql语句格式-->
<property name="format_sql">true</property>
<!--表结构生成策略-->
<property name="hbm2ddl.auto">update</property>
<!--配置数据库使用的sql, 固定写法-->
<property name="hibernate.dialect">org.hibernate.dialect.MYSQLDialect</property>
<!--事务自动提交-->
<property name="hibernate.connection.autocommit">true</property>
<!--将hibernate核心Session与线程绑定, 使得线程安全-->
<property name="hibernate.current_session_context_class">thread</property>
<mapping resource="com/hibernatetest/User.hbm.xml"> <!--配置映射文件, resource对应映射文件的相对路径-->
</session-factory>
</hibernate-configuration>
表结构生成策略
在hibernate中, 如果数据库中没有对应的table, 在配置了hbm2ddl.auto属性, hibernate将为你自动生成表结构, 下面将详细介绍该属性的取值
- update: 当数据库中不存在表结构, hibernate将会自动创建表结构, 如果存在表结构, hibernate会检查数据库中的表结构与映射文件配置的结构是否对应, 如果不对应, 那么hibernate将会在原有的结构上添加不存在的列, 不存在的数据使用null填充
- create: 无论数据库中是否存在表结构, 每次启动hibernate, hibernate都会新建一个表结构, 表中原有的数据会丢失
- create-drop: 无论数据库中是否存在表结构, 每次启动hibernate, hibernate都会新建一个表结构, 在hibernate运行结束后, 删除表结构
- validate: 启动hibernate, 会自动检查表结构是否与映射文件结构对应, 不对应就抛异常, 它不会自动创建/删除/维护表结构
JavaBean与映射文件
- 数据库中表结构:
create table t_user(
id int auto_increment primary key,
username varchar(50),
password varchar(50)
);
- JavaBean就通过User表示
public class User{
private int id;
private String username;
private String password;
//下面一堆get/set操作,就不写了
}
- 映射文件:
就是建立JavaBean中属性与表结构相对应
文件名: 遵守规范, 与JavaBean同名, 例如: User.hbm.xml
文件位置: 放在JavaBean同一目录下
下面举例说明:
<?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">
<!--当设置了package的时候,在后面的class中就不用写完整的类名结构-->
<hibernate-mapping package="com.hibernatetest">
<class name="User" table="t_user">
<id name="id">
<generator class="native"></generator>
</id>
<property name="username" column="username" length="50" type="string"></property>
<property name="password" column="password"></property>
</class>
</hibernate-mapping>
id标签中的generator属性:配置主键生成策略
配置generator, 使得表中数据的主键可以由数据库自增, 我们自己指定, 或者由Hibernate自动生成(表必须有主键).
1.increment: 数据库auto_increment方式, Hibernate会从数据库中查找最大的主键值, 然后在该主键的基础上加一为Bean对象的id赋值
2.identity: 直接依赖于数据库的auto_increment
3.sequence: 序列,依赖于数据库的序列功能(Oracle专属)
4.hilo: 使用Hibernate自己实现的序列算法,自己生成主键为Bean对象id赋值
5.native: 自动根据数据库类型判断, 自动从identity, sequence, hilo中选择
6.uuid 使用生成的32为不重复随机字符串作为主键
7.assigned 使用自己指定的主键值
property标签常用属性:
property主要用于配置数据库中column与Bean的对应关系, 以及column的属性(数据类型, 长度, 有效位, 是否为空, 是否唯一)
1.name: Bean中属性名称
2.column: 表中列名称
3.type: 配置数据类型, 使用java的数据类型 或 数据库数据类型 或 Hibernate数据类型中任意一个
4.length: 数据长度范围
5.scale: 数字的有效位
6.precision: 小数点后精度
7.not-null: 指定属性的约束是否为空
8.unique: 指定属性约束是否使用唯一
使用Hibernate进行数据库操作
下面使用一个简单的例子说明:
@Test
public void demo(){
//1. 加载核心配置文件和映射文件
//由于核心配置文件文件名符合规则, 使用默认的configure方法来加载
Configuration c = new Configuration().configure();
//2.获得SessionFactory, 相当于获得数据库连接池
SessionFactory factory = c.buildSessionFactory();
//3.获得Session对象, 相当于获得connection
Session session = factory.openSession();
//4.开启事务
Transaction transaction = session.beginTransaction();
//5.执行数据库增删改查操作
................
//6.提交事务
transaction.commit();
//7.释放资源
session.close();
factory.close();
}
上面的7个步骤就可以完成数据库的操作, 操作过程与JDBC差不多
封装Hibernate工具类
由于加载配置文件, 获得session对象, 关闭资源都是相同的代码, 所以将相同的代码封装为工具类
package com.utils;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernateUtils {
private static SessionFactory sf;
static {
Configuration cf = new Configuration().configure();
sf = cf.buildSessionFactory();
Runtime.getRuntime().addShutdownHook(new Thread(new Runnable(){
//当虚拟机关闭的时候关闭资源
@Override
public void run() {
System.out.println("虚拟机关闭, 释放资源");
sf.close();
}
}));
}
public static Session openSession(){
return sf.openSession();
}
//用于获得ThreadLocal中的Session
public static Session getCurrentSession(){
return sf.getCurrentSession();
}
}
HibernateAPI解析:
- Configuration配置核心文件
1.new Configuration().configure(): Hibernate能做到自动加载src下的Hibernate核心配置文件和Bean同目录下的User.hbm.xml, 前提必须是文件放置的位置符合规范.
2.当放置的文件不符合规则的时候使用new Configuration().configure(file/path); 通过file/path进行加载
3.手动加载映射文件:
configure.addResource("com/hibernatetest/User.hbm.xml");
configure.addClass(User.class);
- SessionFactory
SessionFactory用于管理所有的Session,线程安全, 使用configure.buildSessionFactory()获得
factory.openSession()与factory.getCurrentSession的区别:
openSession: 是直接就打开一个session, 不去看ThreadLocal是否存有Session
getCurrentSession: 先去ThreadLocal中检查是否存有, 若存在就使用ThreadLocal中的Session, 不存在再new
注: 使用getCurrentSession, 必须在核心配置文件中配置
<property name="hibernate.current_session_context_class">thread</property>
-
Session对象
Session对象就相当于JDBC中的Connection操作,单线程, session可以用来对数据库中数据进行增删改查操作(都是建立在有主键的情况下). -
Transaction事务
开启事务: session.beginTransaction();
获得事务: session.getTransaction();
提交事务: transaction.commit();
回滚事务: transaction.rollback();
事务处理结构:
try{
//开启事务
//session操作
} catch(e){
//事务回滚
}
Session对象基本操作:
准备操作:
Configuration c = new Configuration().configure();
SessionFactory factory = c.buildSessionFactory();
Session session = factory.openSession();
- get查找数据库中对象
获得数据库中对应id为1的User对象
User u = session.get(User.class, 1);
- load查找数据库中对象
User u = (User)session.load(User.class, 3);
- createQuery批量查询
Query q = session.createQuery("from com.hibernate.User");//内部的字符串是HQL语言(Hibernate自制的SQL)
List<User> list = q.list();
User u = (User) q.uniqueResult(); //只返回一条记录, 就是list.get(0);
使用Query可以进行分页操作, 数据库的limit:
q.setFirstResult(int i); //开始索引
q.setMaxResult(int i); //每页显示个数
- createCriteria批量查询
Criteria criteria = session.createCriteria(User.class);
List<User> list = criteria.list();
// 查找id小于3的用户
criteria.add(Restrictions.le("id", "3")); //使用add方法添加查询的过滤条件
List<User> list = criteria.list();
注: Criteria做到面向对象查询, 完全不需要使用SQL语句, 但是在一定程度上缺少灵活性
- createSQLQuery执行原生SQL实现批量查询
SQLQuery query = session.createSQLQuery("select * from t_user");
query.addEntity(User.class);//将查询结果封装到指定的对象中
List<User> list = query.list();
- save将Bean对象保存到数据库中
//由于前面指定主键生成策略是native, 所以这里就不指定主键
//使用数据库的auto_increment
User u = new User();
u.setUsername("AAA");
u.setPassword("123");
session.save(u);
- update对数据库中数据进行修改
首先查询数据库中是否存在对应的User
User u = (User) session.get(User.class,1);
if (!u){
u.setUsername("BBB"); //当User存在的时候进行修改
session.update(u);
}
- delete删除数据库中对应的对象
User u = (User) session.get(User.class, 2);
session.delete(u);
load与get的区别
get: 一旦调用get操作,Hibernate就会使用SQL去数据库中查找指定对象, 然后将这个对象封装到User中
load: 调用load操作的时候, Hibernate先在内部使用动态代理, 生成只具有id属性的代理对象, 只有当使用该代理对象的属性的时候, 才会去数据库中查询指定对象, 然后初始化该动态代理对象
总结: get操作立马就SQL查询, load操作只有在使用该对象属性才会去查询(延迟操作,一定程度上节约资源)
Hibernate持久化类
- 持久化类编写规则:
1.提供无参public修饰的构造方法
2.提供一个"主键"属性, 映射表中的主键
3.所有属性提供public修饰的get, set方法
4.属性尽量使用包装类 (防止基本数据类型自动初始化为0/""/false/0.0…, 使用包装类就直接初始化为null, 便于数据库操作)
5.不要使用final修饰实例 (无法生存代理对象) - 持久化对象的唯一标识OID
对象的id要与表中的主键对应, 为了保证OID的唯一性, 应该使用OID赋值 - 类型对应
196
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
