Hibernate_day01总结
Hibernate_day01总结
第1章 Hibernate_day01总结
今日内容
Hibernate框架的概述
Hibernate的快速入门
Hibernate核心API的介绍
Hibernate的持久化类
主键的生成策略
1.1 Hibernate的学习路线:
第一天:Hibernate的入门.配置,常用操作.
第二天:Hibernate的一级缓存,对象关系映射.
第三天:Hibernate的查询方式,检索策略,事务管理.
第四天:Hibernate的二级缓存.
1.2 Hibernate的概述:
Struts2一个基于MVC设计模式的WEB层的框架.
Hibernate一个ORM的持久层的框架
Spring一个EE开发的一站式的框架.
1.3 Hibernate框架的概述:
1.3.1 Hibernate的框架的介绍:
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
1.3.2 什么是ORM:
ORM:Object Relational Mapping对象关系映射.
1.3.3 Hibernate的优点:
• Hibernate对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码
• Hibernate是一个基于jdbc的主流持久化框架，是一个优秀的orm实现，它很大程度的简化了dao层编码工作
• Hibernate使用java的反射机制，而不是字节码增强程序类实现透明性
• Hibernate的性能非常好，因为它是一个轻量级框架。映射的灵活性很出色。它支持很多关系型数据库，从一对一到多对多的各种复杂关系
1.3.4 常见持久层的框架:
JPA :Java Persistence API是一套接口规范
DBUtils :一个轻量级JDBC的工具类.
MyBatis :SSH(Struts2+Spring+Hibernate),SSI(Spring MVC+Spring+Ibatis)
Hibernate :ORM的持久层框架
JdbcTemplate :Spring框架中提供的持久层的解决方案.
1.3.5 常见的Hibernate的版本:
Hibernate3.x 和 Hibernate4.x
1.4 Hibernate的快速入门:
1.4.1 步骤一:下载Hibernate的开发环境:
http://sourceforge.net/projects/hibernate/files/hibernate3/
1.4.2 步骤二:查看Hibernate的目录结构:
目录结构:
documentation :开发文档
lib :Hibernate开发的所需的jar包
project :Hibernate的项目
1.4.3 步骤三:创建一个Java项目,引入相应的jar包.
HIBERNATE_HOME/hibernate3.jar
HIBERNATE_HOME/lib/ required/*.jar
HIBERNATE_HOME/lib/ jpa/*.jar
数据库连接的驱动：mysql-connector-java-5.0.4-bin.jar
日志记录的包:
l Log4j
l Slf4j整合log4j
1.4.3.1 日志记录:(了解)
输出错误信息,或者调试的时候:System.out.println(“==========”);
可以将日志记录看做是System.out.println();只能向控制台输出.日志向控制台,文件,邮件中输出.日志记录是有级别的.
Log4j进行日志的记录:日志分为6个级别.fetal(致命错误),error(普通错误),warn(警告信息),info(普通信息),debug(调试信息),trace(堆栈信息)
Log.fetail(“xxx”);
Log.error(“yyy”);
Log.warn(“aaa”);
Log.info(“zzz”);
Log4j
输出源:
布局:
记录器:
1.4.4 创建数据库和表:
create database hibernate_day01;
use hibernate_day01;
create table customer(
id int primary key auto_increment,
name varchar(20),
age int,
salary double
);
1.4.5 创建实体:
publicclass Customer {
private Integer id;
private String name;
private Integer age;
private Double salary;
…
}
1.4.6 创建对象和关系的映射:
映射文件必须是XML格式的名称任意.但是通常情况下命名规范:类名.hbm.xml
引入约束文件:
Hibernate3.jar/org/hibernate/hibernate-mapping-3.0.dtd
<hibernate-mapping>
<!--
class标签
name :类名
table :表名
-->
<class name="cn.itcast.hibernate.demo1.Customer"table="customer">
<!--
id标签:专门用来进行主键映射
name :类中属性名
column :表中的字段名
-->
<id name="id"column="id">
<generator class="native"/>
</id>
<!--
property标签:用来非主键属性映射.
name :类中属性名
column :表中的字段名
-->
<property name="name"column="name"length="20"/>
<property name="age"column="age"/>
<property name="salary"column="salary"/>
</class>
</hibernate-mapping>
1.4.7 创建Hibernate核心配置文件:
在src下创建一个hibernate.cfg.xml
引入约束:hibernate3.jar/org/hibernate/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:///hibernate_day01
</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">123</property>
<!-- Hibernate的方言 -->
<property name="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</property>
<!-- 显示SQL -->
<property name="hibernate.show_sql">true</property>
<!-- 格式化SQL -->
<property name="hibernate.format_sql">true</property>
<!-- 根据映射文件Hibernate自动创建表 -->
<property name="hibernate.hbm2ddl.auto">update</property>
<!-- 映射文件的加载 -->
<mapping resource="cn/itcast/hibernate/demo1/Customer.hbm.xml"/>
</session-factory>
</hibernate-configuration>
1.4.8 编写测试程序:
向数据库中插入一条记录:
/**
* 步骤一:加载Hibernate的核心配置文件.
* 步骤二:创建一个SessionFactory.(类似连接池)
* 步骤三:获得Session对象.(连接对象,想象成Connection)
* 步骤四:开启事务.
* 步骤五:编写代码.
* 步骤六:提交事务.
* 步骤七:释放资源.
*/
// 加载Hibernate的核心配置文件hibernate.cfg.xml
Configuration configuration = new Configuration().configure();
// 创建一个SessionFactory对象.
SessionFactory sessionFactory = configuration.buildSessionFactory();
// 获得session对象.
Session session = sessionFactory.openSession();
// 开启事务:
Transaction tx = session.beginTransaction();
// 执行相应操作:
session.save(customer);
// 提交事务:
tx.commit();
session.close();
1.5 Hibernate完成CRUD的操作:
1.5.1 保存一条数据:
@Test
/**
* 保存一条记录
*/
publicvoid save() {
// 加载核心配置:
Configuration configuration = new Configuration().configure();
// 创建SessionFactory
SessionFactory sessionFactory = configuration.buildSessionFactory();
// 获得Session:
Session session = sessionFactory.openSession();
// 开启事务
Transaction tx = session.beginTransaction();
// 执行操作:
Customer customer = new Customer();
customer.setName("凤姐");
customer.setAge(38);
customer.setSalary(4000d);
session.save(customer);
// 提交事务
tx.commit();
// 释放资源
session.close();
}
1.5.2 查询一条数据:
@Test
/**
* 查询一个
*/
publicvoid findById(){
// 加载核心配置:
Configuration configuration = new Configuration().configure();
// 创建SessionFactory
SessionFactory sessionFactory = configuration.buildSessionFactory();
// 获得Session:
Session session = sessionFactory.openSession();
// 开启事务
Transaction tx = session.beginTransaction();
// 执行操作:
Customer customer = (Customer) session.get(Customer.class, 2);
System.out.println(customer);
// 提交事务
tx.commit();
// 释放资源
session.close();
}
1.5.3 修改一条记录:
@Test
/**
* 修改一条记录
*/
publicvoid update() {
// 加载核心配置:
Configuration configuration = new Configuration().configure();
// 创建SessionFactory
SessionFactory sessionFactory = configuration.buildSessionFactory();
// 获得Session:
Session session = sessionFactory.openSession();
// 开启事务
Transaction tx = session.beginTransaction();
// 执行操作:
// 修改的方式一:创建新对象然后修改.
/* Customer customer = new Customer();
customer.setId(1);
customer.setName("小马");*/
// 修改方式二:先查询该对象,再进行修改.
Customer customer = (Customer) session.get(Customer.class, 1);
customer.setName("小马");
session.update(customer);
// 提交事务
tx.commit();
// 释放资源
session.close();
}
1.5.4 删除一条记录:
@Test
/**
* 删除一条记录
*/
publicvoid delete() {
// 加载核心配置:
Configuration configuration = new Configuration().configure();
// 创建SessionFactory
SessionFactory sessionFactory = configuration.buildSessionFactory();
// 获得Session:
Session session = sessionFactory.openSession();
// 开启事务
Transaction tx = session.beginTransaction();
// 执行操作:
// 删除方式一:创建新对象然后删除.
/*Customer customer = new Customer();
customer.setId(1);
session.delete(customer);*/
// 删除方式二:先查询再删除(级联删除)
Customer customer = (Customer) session.get(Customer.class, 2);
session.delete(customer);
// 提交事务
tx.commit();
// 释放资源
session.close();
}
1.5.5 查询所有记录:
1.5.5.1 HQL的方式:
/**
* 查询所有记录:
* * HQL:Hibernate Query Language.面向对象的查询语言.
*/
@Test
publicvoidfindAll() {
// 加载核心配置:
Configuration configuration = new Configuration().configure();
// 创建SessionFactory
SessionFactory sessionFactory = configuration.buildSessionFactory();
// 获得Session:
Session session = sessionFactory.openSession();
// 开启事务
Transaction tx = session.beginTransaction();
Query query = session.createQuery("from Customer");
List<Customer> list = query.list();
for (Customer customer : list) {
System.out.println(customer);
}
// 提交事务
tx.commit();
// 释放资源
session.close();
}
1.5.5.2 QBC方式:Query By Criteria.
/**
* 查询所有记录:
* * QBC:Query By Criteria .条件查询
*/
@Test
publicvoidfindAllByCriteria() {
// 加载核心配置:
Configuration configuration = new Configuration().configure();
// 创建SessionFactory
SessionFactory sessionFactory = configuration.buildSessionFactory();
// 获得Session:
Session session = sessionFactory.openSession();
// 开启事务
Transaction tx = session.beginTransaction();
// 执行操作:
Criteria criteria =session.createCriteria(Customer.class);
List<Customer> list = criteria.list();
for (Customer customer : list) {
System.out.println(customer);
}
// 提交事务
tx.commit();
// 释放资源
session.close();
}
1.5.5.3 SQL方式:
/**
* 查询所有记录:
* * SQL的方式:
*/
@Test
publicvoid findAllBySQL() {
// 加载核心配置:
Configuration configuration = new Configuration().configure();
// 创建SessionFactory
SessionFactory sessionFactory = configuration.buildSessionFactory();
// 获得Session:
Session session = sessionFactory.openSession();
// 开启事务
Transaction tx = session.beginTransaction();
// 执行操作:
/*SQLQuery query = session.createSQLQuery("select * from customer");
List<Object[]> list = query.list();
for (Object[] objects : list) {
System.out.println(Arrays.toString(objects));
}*/
SQLQuery query = session.createSQLQuery("select * from customer");
query.addEntity(Customer.class);
List<Customer> list = query.list();
for (Customer customer : list) {
System.out.println(customer);
}
// 提交事务
tx.commit();
// 释放资源
session.close();
}
1.6 Hibernate的常见配置
1.6.1 Hibernate的映射配置:
完成实体与表的映射关系.
<class>标签 :用来将实体类与表建立映射.
* name :类的全路径名
* table :表名.(可以省略的.)默认使用类名.
* catalog :数据库名
<id>标签 :用来将表中主键与类中属性建立映射.
* name :类中的属性名
* column :表中的字段名(可以省略.)
* length :表中字段的长度.
* type :表中的字段的类型.
* 写成Java类型.
* 写成SQL类型.
* 写成Hibernate类型.
<property>标签 :用来将表中普通的字段与类中属性进行映射.
* name :类中的属性名
* column :表中的字段名(可以省略.)
* length :表中字段的长度.
* type :表中的字段的类型.
* 写成Java类型.
* type=”java.lang.String”
* 写成SQL类型.
* <column name=”” sql-type=”varchar(20)”/>
* 写成Hibernate类型.
* type=”string”
1.6.2 Hibernate的核心配置:
Hibernate的核心配置:连接数据库的基本参数,Hibernate的属性,映射文件的加载.
Hibernate的核心配置有两种方式:
* hibernate.properties
* hibernate.connection.driver_class = com.mysql.jdbc.Driver
* 缺点:不能加载映射文件.手动编写代码加载映射.
* 加载核心配置
* Configuration cfg = new Configuration();
* hibernate.cfg.xml
* <property name=” hibernate.connection.driver_class”>com.mysql.jdbc.Driver</property>
* 加载核心配置
* Configuration cfg = new Configuration().configure();
Hibernate.cfg.xml方式的核心配置文件的详解:
基本连接数据库的信息:
<!-- 配置连接数据库的基本信息 -->
<propertyname="hibernate.connection.driver_class">
com.mysql.jdbc.Driver
</property>
<propertyname="hibernate.connection.url">
jdbc:mysql:///hibernate_day01
</property>
<propertyname="hibernate.connection.username">root</property>
<propertyname="hibernate.connection.password">123</property>
Hibernate属性
<!-- Hibernate的方言 -->
<propertyname="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</property>
<!-- 显示SQL -->
<propertyname="hibernate.show_sql">true</property>
<!-- 格式化SQL -->
<propertyname="hibernate.format_sql">true</property>
<!-- 根据映射文件Hibernate自动创建表 -->
<propertyname="hibernate.hbm2ddl.auto">update</property>
* create :每次都会新创建一个表,如有表,先删除这个表,然后再创建.(测试)
* create-drop :每次都会创建新的表,执行完成后,将这个表删除了.(测试)
* update :如果有表,使用原来的表,如果没有表.创建一个新的表.而且更新表结构.
* validate :如果没有表,不会创建表.只能使用原有表.校验映射文件与表是否正确.
映射文件加载:
<!-- 映射文件的加载 -->
<mappingresource="cn/itcast/hibernate/demo1/Customer.hbm.xml"/>1.7 Hibernate的核心API:
1.7.1 Hibernate核心API: sConfiguration.
加载配置文件:
使用Configuration加载核心配置文件:
* hibernate的核心是属性文件的方式:
Configuration cfg = new Configuration();
* hibernate.cfg.xml的方式:
Configuration cfg = new Configuration().configure();
手动加载映射文件:
// 手动加载映射文件:
configuration.addResource("cn/itcast/hibernate/demo1/Customer.hbm.xml");
// 手动加载映射文件:实体类需要和映射文件在同一个路径下
configuration.addClass(Customer.class);
1.7.2 Hibernate核心API: SessionFactory.
SessionFactory维护了数据库基本配置,预定义SQL,映射文件.
SessionFactory是线程安全的对象.
SessionFactory维护了Hibernate的二级缓存.
SessionFactory重量级对象,每次不应该都去创建该对象.一个应用中应当只有一个该对象.应该抽取:
publicclassHibernateUtils {
privatestaticfinal Configuration cfg;
privatestaticfinal SessionFactory sessionFactory;
static{
cfg = new Configuration().configure();
sessionFactory = cfg.buildSessionFactory();
}
publicstatic Session openSession(){
returnsessionFactory.openSession();
}
}1.7.3 Hibernate核心API:Session.
相当于Connection.
是Hibernate框架与数据库交互的桥梁.
Session线程不安全的.
Session对象内部维护了Hibernate一级缓存.
常用的方法:
Serializable save(Object obj);
Object get(Class clazz,Serializable id);
* session.get(Customer.class,new Integer(1)); // JDK1.5自动拆装箱
Object load(Class clazz,Serializable id);
void update(Object obj);
void delete(Object obj);面试题:
* get方法和load方法的区别?
* get方法立即加载,执行到该语句的时候就会发送SQL语句.load方法延迟加载,在真正使用该对象的时候才会发送SQL语句查询.
*get方法返回的是真实对象本身.load方法返回的是代理对象.
* get方法查询一个找不到的对象的时候返回null.而load方法抛出一个ObjectNotFoundException异常.
Query createQuery(String hql);
Criteria createCriteria(Class clazz);
SQLQuery createSQLQuery(String sql);
void saveOrUpdate(Object obj);1.7.4 Hibernate核心API:Transaction
常用的方法:
如果没有开启事务，那么每个Session的操作，都相当于一个独立的事务
1.7.5 Hibernate核心API:Query
Query query = session.createQuery(String hql);
HQL:Hibernate Query Language.Hibernate 查询语言.
@Test
/**
* HQL:
*/
publicvoid demo7() {
Session session = HibernateUtils.openSession();
Transaction tx = session.beginTransaction();
// 查询所有
/*String hql = "from Customer";
Query query = session.createQuery(hql);
List<Customer> list = query.list();
for (Customer customer : list) {
System.out.println(customer);
}*/
// 条件查询:按位置绑定参数
/*String hql = "from Customer where name = ?";
Query query = session.createQuery(hql);
query.setString(0, "老马");
List<Customer> list = query.list();
for (Customer customer : list) {
System.out.println(customer);
}*/
/*String hql = "from Customer where name = ? and age = ?";
Query query = session.createQuery(hql);
query.setString(0, "老马");
query.setInteger(1, 42);
List<Customer> list = query.list();
for (Customer customer : list) {
System.out.println(customer);
}*/
// 条件查询:按名称绑定:
/*String hql = "from Customer where name = :aaa and age = :bbb";
Query query = session.createQuery(hql);
query.setString("aaa", "老马");
query.setInteger("bbb", 42);
List<Customer> list = query.list();
for (Customer customer : list) {
System.out.println(customer);
}*/
String hql = "from Customer";
Query query = session.createQuery(hql);
query.setFirstResult(6);
query.setMaxResults(3);
List<Customer> list = query.list();
for (Customer customer : list) {
System.out.println(customer);
}
tx.commit();
session.close();
}1.7.6 Hibernate核心API:Criteria
Criteria criteria = session.createCriteria(Customer.class);
QBC:Query By Criteria(条件).
@Test
/**
* Criteria:
*/
publicvoid demo8(){
Session session = HibernateUtils.openSession();
Transaction tx = session.beginTransaction();
// 查询所有
/*Criteria criteria = session.createCriteria(Customer.class);
List<Customer> list = criteria.list();
for (Customer customer : list) {
System.out.println(customer);
}*/
// 条件查询:
/*Criteria criteria = session.createCriteria(Customer.class);
criteria.add(Restrictions.eq("name", "老马"));// eqle(less equal) lt(less than) gt(great than) ge(great equal) like in
List<Customer> list = criteria.list();
for (Customer customer : list) {
System.out.println(customer);
}*/
/* Criteria criteria = session.createCriteria(Customer.class);
criteria.add(Restrictions.eq("name", "老马"));// eqle(less equal) lt(less than) gt(great than) ge(great equal) like in
criteria.add(Restrictions.gt("age",40));
List<Customer> list = criteria.list();
for (Customer customer : list) {
System.out.println(customer);
}*/
Criteria criteria = session.createCriteria(Customer.class);
criteria.setFirstResult(3);
criteria.setMaxResults(3);
List<Customer> list = criteria.list();
for (Customer customer : list) {
System.out.println(customer);
}
tx.commit();
session.close();
}1.7.7 Hibernate核心API:SQLQuery
@Test
publicvoid demo9(){
Session session = HibernateUtils.openSession();
Transaction tx = session.beginTransaction();
SQLQuery sqlQuery = session.createSQLQuery("select * from customer");
List<Object[]> list = sqlQuery.list();
for (Object[] objects : list) {
System.out.println(Arrays.toString(objects));
}
}
1.8 持久化类的编写:
1.8.1 什么是持久化类:
Hibernate :冬眠.将对象持久化.
* 持久化类:一个Java类,这个Java类与数据库的表建立了映射关系.这个类就称为是持久化类.
* 持久化类 = JavaBean + hbm.xml
1.8.2 持久化类的编写规则:
1.需要提交一个无参数的构造方法 :反射.
2.需要提供属性的get和set方法 :赋值.
3.需要提供一个标识属性与表的主键映射. :Java中区分是否是同一个对象.对象的地址.数据库中区分是否是同一条记录.主键.Hibernate中区分对象在内存中是否是同一个?通过标识属性区分.
4.属性尽量使用包装类型 :使用包装类使用null作为默认值.
5.持久化类不要使用final修饰 :设置为final.hibernate的延迟加载就会失效.不能产生代理对象.
1.8.3 自然主键和代理主键:
自然主键 :创建一个人员表.人员有一个身份证号唯一标识.使用身份证号作为表的主键.
代理主键:创建一个人员表.在人员表中创建一个新的字段pid.使用pid作为主键.
1.8.4 主键的生产策略:
Hibernate的主键生成策略:帮助我们生成主键.
increment :自动增长.(short,int,long).采用的是hibernate中的自动增长,不是使用数据库底层的自动增强.
* select max(id) from Customer; 将最大值加1作为下一条记录的主键.不能再多线程环境下使用.
identity : (short,int,long)对MYSQL,MS SQL,DB2这种数据库生效(short int long).对Oracle不生效.采用的是数据库的自动增长的机制.
sequence : (short,int,long)对DB2,Oracle生效.对MYSQL MSSQL不生效.
native : (short,int,long)本地策略.根据底层的数据库自动选择使用identity还是sequence.
* 如果数据库底层使用MYSQL.那么配置native相当于identity.如果数据库底层使用Oracle.那么native相当于sequence.
uuid :适用于字符串类型的主键.
assigned :主键Hibernate不进行管理.需要自己在程序中设置主键.
foreign :主要使用在一对一的关联关系中.
1.8.5 复合主键的配置:
配置:
<hibernate-mapping>
<class name="cn.itcast.hibernate.demo2.Person"table="person">
<composite-id>
<key-property name="firstName"/>
<key-property name="lastName"/>
</composite-id>
</class>
</hibernate-mapping>使用条件:持久化类必须实现序列化接口.