hibernate 系列
hibernate（一）helloworld、api、事务、配置文件、映射文件
hibernate（二）对象的三种状态、一级缓存、多对一、inverse、cascade
hibernate（三）多对多、加载策略、懒加载、HQL查询、整合c3p0、乐观锁悲观锁
hibernate（四）整合log4j、一对一、二级缓存
1、hibernate 介绍
2、ORM 介绍
3、Java 种常用的 ORM 技术
4、hibernate hello world 程序
5、Hibernate-api详解
5.1、Configuration对象
5.2、SessionFactory对象
5.3、Session-增删改
5.4、Session-HQL查询
5.5、Session-Criteria&Sql查询
5.6、session.load()
5.7、Transaction详解
5.8、Query详解
5.9、Criteria详解(了解，开发中用得不多)
5.10、封装Hibernate工具类
6、Hibernate-配置文件
7、Hibernate-实体配置详解-实体规则
8、映射文件详解
1、hibernate 介绍 <--返回目录
hibernate 在 javaEE 三层架构的位置
2、ORM 介绍 <--返回目录
ORM：对象关系映射（Object Relational Mapping，简称ORM）是通过使用描述对象和数据库之间映射的元数据，将面向对象语言程序中的对象自动持久化到关系数据库中。本质上就是将数据从一种形式转换到另外一种形式。
对象 Object：java 对象，此处特指 JavaBean
关系 Relational：二维表，数据库的表
映射 Mapping：对象的属性 与表字段 存在对应关系
3、Java 种常用的 ORM 技术 <--返回目录
1）JPA（Java Persistence API）：JPA 通过 JDK5 注解或 XML 描述对象-关系表的映射关系（只有接口规范）
2）Hibernate：ORM 框架，通过对象-关系映射配置，可以完全脱离底层 sql
3）mybatis：apache 开源项目 ibatis，支持普通 sql 查询，存储过程和高级映射的优秀持久层框架
4）apache DBUtils、Spring JDBCTemplate
4、hibernate hello world 程序 <--返回目录
demo 最终结构
新建一个 Java Project
依赖
链接：https://pan.baidu.com/s/12nwIyodOhVCEemaAyPVPtQ 提取码：tp9w
依赖 Add to Build Path
创建实体类
package com.oy.helloworld; public class User { private Integer id; private String username; private String password; public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } }
mysql 创建表
CREATE TABLE `user` ( `id` int(11) NOT NULL AUTO_INCREMENT, `username` varchar(100) DEFAULT NULL, `password` varchar(100) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
hibernate 配置文件 hibernate.cfg.xml
<?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> <!-- 连接数据库的驱动 --> <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <!-- 连接数据库的地址 --> <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8</property> <!-- 连接数据库的用户名 --> <property name="hibernate.connection.username">root</property> <!-- 连接数据库的密码 --> <property name="hibernate.connection.password">123456</property> <!-- show_sql: 操作数据库时, 会向控制台打印 sql 语句 --> <property name="show_sql">true</property> <!-- format_sql: 打印 sql 语句前, 会先将 sql 语句格式化 --> <property name="format_sql">true</property> <!-- hbm2ddl.auto: 生成表结构的策略配置。 update(最常用)：如果当前数据库中不存在表结构，那么自动创建表结构。如果存在表结构，并且表结构与实体一致， 那么不做修改。如果存在表结构,并且表结构与实体不一致，那么会修改表结构，会保留原有列。 create(很少用)：无论是否存在表结构，每次启动 Hibernate 都会重新创建表结构(数据会丢失) 。 create-drop(极少用)：无论是否存在表结构，每次启动 Hibernate 都会重新创建表结构。 每次 Hibernate 运行结束时，删除表结构。 validate(很少用)：不会自动创建表结构，也不会自动维护表结构。Hibernate只校验表结构。 如果表结构不一致将会抛出异常。 --> <property name="hbm2ddl.auto">update</property> <!-- 数据库方言配置 org.hibernate.dialect.MySQLDialect (选择最短的) --> <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> <!-- hibernate.connection.autocommit: 事务自动提交，默认false --> <property name="hibernate.connection.autocommit">true</property> <!-- 引入ORM 映射文件 填写src之后的路径 --> <mapping resource="com/oy/helloworld/User.hbm.xml" /> </session-factory> </hibernate-configuration>
映射文件 User.hbm.xml
<?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"> <!-- ORM元数据 表对象关系映射文件 package: 配置该配置文件 实体类 所在的包 --> <hibernate-mapping package="com.oy.helloworld"> <!--class: 配置实体与表的关系 name : 填写实体的完整类名 table: 与实体对应表的名称 dynamic-insert:动态插入，默认值是false true => 如果字段值为null，不参与 insert 语句 dynamic-update:动态更新，默认值"false" true => 没改动过的属性，将不会生成到 update 语句中 --> <class name="User" table="user"> <!--id: 配置实体与表中 id对应 name: user对象中标识主键的属性名称 column: 主键在表中的列名 length: 列的数据长度 unsaved-value(不常用): 指定主键为什么值时，当做null来处理. access(强烈推荐不要用): field 那么在操作属性时，会直接操作对应的字段而不是get/set方法 --> <id name="id" column="id" length="100"> <!-- generator:主键生成策略 1.increment 数据库自己生成主键. 先从数据库中查询最大的ID值,将ID值加1作为新的主键 2.identity 依赖于数据的主键自增功能 3.sequence 序列,依赖于数据中的序列功能(Oracle). 4.hilo(了解) : Hibernate自己实现序列的算法,自己生成主键. (hilo算法 ) 5.native 自动根据数据库判断,三选一. identity|sequence|hilo 6.uuid 生成32位的不重复随机字符串当做主键 7.assigned 自己指定主键值. 表的主键是自然主键时使用。--> <generator class="identity"></generator> </id> <!-- property : 实体中属性与表中列的对应 name : 实体中属性名称 column : 表中列的名称 length : 数据长度 precision: 小数点后的精度 scale: 有效位数 insert(一般不用): 该属性是否加入insert语句. update(一般不用): 该属性是否加入update语句. not-null : 指定属性的约束是否使用 非空 unique : 指定属性的约束是否使用 唯一 --> <!-- type: 表达该属性的类型 可以用三种方式指定属性 java类型 数据库类型指定 Hibernate类型指定 java.lang.String varchar string --> <property name="username" column="username" update="true" type="string" ></property> <property name="password" column="password"></property> <!-- <property name="sal" column="sal" precision="2" scale="3" ></property> --> </class> </hibernate-mapping>
测试类
package com.oy.helloworld; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.Configuration; import org.junit.Test; public class TestHelloWorld { @Test public void fun1() { // 读取配置文件 Configuration conf = new Configuration().configure(); // 根据配置 创建Factory SessionFactory sessionFactory = conf.buildSessionFactory(); // 通过获得操作数据库的session对象 Session session = sessionFactory.openSession(); // 操作数据库 User u = new User(); u.setUsername("tom"); u.setPassword("222"); session.save(u); // 关闭资源 session.close(); sessionFactory.close(); } }
测试结果：控制台打印
Hibernate:
insert
into
user
(username, password)
values
(?, ?)
数据库记录插入成功
需要注意的地方：
1）hibernate 默认需要手动开启提交事务，也可以配置自动提交事务
<!-- hibernate.connection.autocommit: 事务自动提交，默认false --> <property name="hibernate.connection.autocommit">true</property>
2）mysql 引擎 MyISAM 不支持事务，所以如果使用 MyISAM 引擎，事务失效，插入总是成功（不会回滚），也即
<property name="hibernate.connection.autocommit">false</property> 配置成 false，也会插入成功。
测试 事务
<property name="hibernate.connection.autocommit">false</property>
hibernate.connection.autocommit 配置成 false，事务不会自动提交，插入记录被回滚了
5、Hibernate-api详解 <--返回目录
5.1、Configuration对象 <--返回目录
加载src下名为hibernate.cfg.xml
Configuration conf = new Configuration().configure();
如果配置文件不符合默认加载规则，调用
Configuration conf = new Configuration().configure(File file);//通过file加载 Configuration conf = new Configuration().configure(String path);//通过路径加载
可以通过Configuration对象加载映射文件（不推荐）。conf.addClass(User.class);之所以可以这样实现加载，因为有下面规范
规范1：ORM映射文件名称与实体名称一致；
规范2：ORM映射文件需要与实体类放在同一包下
推荐使用hibernate.cfg.xml 使用mapping属性引入映射文件
<mapping resource="com/oy/domain/User.hbm.xml"/>
5.2、SessionFactory对象 <--返回目录
创建 Factory
Configuration conf = new Configuration().configure(); // 读取配置文件 SessionFactory sessionFactory = conf.buildSessionFactory();
获取一个全新的 session 对象
Session session = sessionFactory.openSession();
获得与当前线程绑定的 session 对象，如果没有，获取一个新的 session
先配置：<property name="hibernate.current_session_context_class">thread</property>
将session与线程绑定，只有配置了该参数，才能使用getCurrentSession()
Session session = sessionFactory.getCurrentSession();
5.3、Session-增删改 <--返回目录
增
User user = new User(); user.setUname("李四"); user.setPassword("123"); session.save(user);
改
//先查 //开启事务 Transaction ts= session.beginTransaction(); //查 User _user = (User) session.get(User.class, 1);//取一个User对象，id=1 System.out.println(_user); //改 _user.setPassword("abc"); //修改密码 _user.setUname("张三"); //修改密码 session.update(_user); //执行修改 //关闭事务 ts.commit();
或者
User user1 = new User(); user1.setUid(1); //指定id user1.setPassword("def"); //修改密码 user1.setUname("zhangsan"); //修改用户名 Transaction ts= session.beginTransaction(); //修改操作必须先开启事务 session.update(user1); //执行修改 ts.commit(); //提交事务
删(根据id删除，只有对象有id就行)
//User _user = (User) session.get(User.class, 1);//取一个User对象，id=1 User user2 = new User(); user2.setUid(1); //指定id Transaction ts= session.beginTransaction(); //删除操作必须先开启事务 session.delete(user2); ts.commit(); //提交事务
5.4、Session-HQL查询 <--返回目录
HQL语言：Hibernate Query Language
session.createQuery("HQL语句");
查询所有
Query query = session.createQuery("from com.oy.domain.User");
List<User> userList = query.list();//list()将语句执行，并返回结果
5.5、Session-Criteria&Sql查询 <--返回目录
Criteria查询==>Hibernate独创的面向对象的查询==>无语句
//查询所有 Criteria criteria = session.createCriteria(User.class); List<User> userList = criteria.list();
原生的sql查询，查询所有
SQLQuery query = session.createSQLQuery("select * from t_user ");
query.addEntity(User.class);
List<User> userList = query.list();
5.6、session.load() <--返回目录
问题1：load()方法，返回一个代理对象，获得其内容时，会查询数据库，是每次访问属性都会查询数据库吗？
答：不是每次都查。代理对象中有一个表识是否被初始化的boolean型变量，记录是否被初始化过。
问题2：代理都是要基于接口的，用load()方法返回的代理，就没有实现任何接口？
答：java中的动态代理是基于接口；而Hibernate是使用javassist-3.12.0.GA.jar产生代理对象，
该代理与被代理对象之间的关系是继承关系。代理对象是被代理对象的子类。
5.7、Transaction详解 <--返回目录
* 开启事务 Transaction ts= session.beginTransaction();
* 提交事务 ts.commit();
回滚事务 ts.rollback();
* 获得已经打开的事务对象（很少用）
session.getTransaction();
* 事务关闭时，会自动把与当前线程关联的session关闭，并删除
事务代码规范写法
Session session = null; Transaction tx = null; try { session = HibernateUtils.openSession(); tx = session.beginTransaction(); // 开启事务 // ============================================== // ============================================== tx.commit(); // 提交事务 } catch (Exception e) { tx.rollback(); // 回滚事务 } finally { session.close(); // 关闭操作 }
5.8、Query详解 <--返回目录
* Query对象：封装HQL语句的对象
* 查询所有
Query query = session.createQuery("from com.oy.domain.User");
List<User> userList = query.list();//list()方法将hql句执行，并返回List<User>
* 查询一条记录
Query query = session.createQuery("from com.oy.domain.User where uname='张三'");
User u = (User)query.uniqueResult();//执行hql语句，返回一个User对象
* 分页 limit Index,count;
query.setFirstResult(index);//指定结果从第index个取
query.setMaxResults(count);//指定取几条记录
5.9、Criteria详解(了解，开发中用得不多) <--返回目录
* Criteria查询==>Hibernate独创的面向对象的查询==>无语句
* 查询所有
Criteria criteria = session.createCriteria(User.class);
List<User> userList = criteria.list();
* 查询一条记录
Criteria criteria = session.createCriteria(User.class);
criteria.add(Restrictions.eq("uname","张三"));//查询name=张三的记录
User u = (User)criteria.uniqueResult();
* 查询uname字段中包含"三"的记录
criteria.add(Restrictions.like("uname","%三%"));
List<User> userList = criteria.list();
* 查询uid>1的记录
criteria.add(Restrictions.gt("uid",1));
List<User> userList = criteria.list();
* > gt < lt = eq >=ge <=le like between
5.10、封装Hibernate工具类 <--返回目录
import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.Configuration; public class HibernateUtils { // 会话工厂，整个程序只有一份。 private static SessionFactory sf; static { // 1 加载配置 Configuration config = new Configuration().configure(); // 2 获得工厂 sf = config.buildSessionFactory(); // 3 关闭虚拟机时,释放SessionFactory Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() { public void run() { System.out.println("虚拟机关闭!释放资源"); sf.close(); } })); } // 获得一个新的session public static Session openSession() { return sf.openSession(); } // 获得当前线程中绑定session public static Session getCurrentSession() { return sf.getCurrentSession(); } }
6、Hibernate-配置文件 <--返回目录
hbm2ddl
* <property name="hbm2ddl.auto">create</property>
- update:最常用，如果当前数据库中不存在表结构，自动创建表结构；如果存在表结构，并且表结构与实体一致，那么不做修改；
如果存在表结构，并且表结构与实体不一致，那么会修改表结构，会保留原有列。
- create(很少用):无论是否存在表结构，每次启动Hibernate都会重新创建表结构（数据会丢失）。
- create-drop(很少用)：无论是否存在表结构，每次启动Hibernate都会重新创建表结构；运行结束时删除表。
- validate(很少用)：不会自动创建表结构，也不会自动维护表结构，只会校验表结构。如果表结构不一致，抛出异常。
方言
* <property name="hibernate.dialect">org.hibernate.dialect.MySqlDialect</property>
7、Hibernate-实体配置详解-实体规则 <--返回目录
* 实体编写规则
- 提供一个无参数 public访问控制符的构造器
- 提供一个标识属性，映射数据表主键字段
- 所有属性提供public访问控制符的 set get 方法(javaBean)
- 标识属性应尽量使用基本数据类型的包装类型
** 基本数据类型和包装类型对应hibernate的映射类型相同
** 基本类型无法表达null、数字类型的默认值为0。
** 包装类默认值是null。当对于默认值有业务意义的时候需要使用包装类。
- 不要用final修饰实体 （将无法生成代理对象进行优化）
** 生成代理对象，代理对象是被代理对象的子类，final类不能被继承
* 持久化对象的唯一标识-oid&主键
- 关系数据库用主键区分同一条记录
- Hibernate使用OID来建立内存中的对象和数据库中记录的对应关系
- 结论: 对象的OID和数据库的表的主键对应。为保证OID的唯一性，应该让Hibernate来为OID赋值
* 区分自然主键和代理主键
- 主键需要具备: 不为空/不能重复/不能改变
- 自然主键: 在业务中，某个属性符合主键的三个要求。那么该属性可以作为主键列。
- 代理主键: 在业务中，不存符合以上3个条件的属性，那么就增加一个没有意义的列作为主键。
8、映射文件详解 <--返回目录
* <hibernate-mapping package="com.oy.d_hbm">
<class name="User" table="t_user">
配置了package属性，则User前面无需加包名
* <class name="com.oy.d_hbm.User" table="t_user">
- 属性dynamic-insert：动态插入，默认为false，true=>如果字段为null，不参与insert语句
- 属性dynamic-update:动态修改，默认为false，true=>如果字段为null，不参与update语句
* <id name="uid" column="uid">
- 属性length:修改表uid的数据长度，演示不成功
- unsaved-value(不常用):指定主键为什么值时，当做null来处理
** 我们建实体类的规则，主键使用包装类
- access(不推荐使用):field，那么在操作属性时，直接操作对应的字段，而不是get/set方法
* 主键生成策略
<id name="uid" column="uid">
<!-- 主键生成策略：native表示由数据库维护主键（数据库中主键设置为自增） -->
<generator class="native"></generator>
</id>
- <generator class="">主键生成策略
- 1)increment:数据库自己生成。先从数据库总查询最大的ID值，将ID值加1
** 当主键生成策略为increment，save()方法会使用语句select max(uid) from t_user来给user设置uid；
** save()方法不会使用insert语句；
** 此时，需要使用事务提交，才会使用insert语句，把数据持久化到数据库中；
- 2)identity:依赖数据的主键自增功能
** 当主键生成策略是identity，save()方法使用insert语句获取uid；
** 由于使用了insert语句，save()方法后数据已经持久化到数据库中了；
- 3)sequence:序列，依赖于数据中的序列功能（Oracle）
- 4)hilo(了解,永远用不到):Hibernate自己实现序列的算法，自己生成主键，hilo算法
- 5)native:自动根据数据库判断，identity, sequence, hilo三选一
- 6)uuid:生成不重复的32位随机字符串当做主键
- 7)assigned:自己设置主键值。一般在表的主键是自然主键时使用该策略。
* 实体其他属性<property name="" column=""></property>
- length:数据长度
- precision:小数点后的精度，（字段为double类型时使用）
- scale:有效位数，（字段为double类型时使用）
- insert(一般不用):false表示该属性是否加入inset语句
- update(一般不用):false表示该属性是否加入update语句
- not-null:知道属性的约束是否使用非空
- unique:指定属性的约束是否使用唯一
- type:表达该属性的类型，可以使用三种方式来指定属性
java类型 数据库类型 Hibernate类型
java.lang.String varchar string
---