第一章 Hibernate 基础入门
发布时间
阅读量：
阅读量
Hibernate介绍
Hibernate是一种ORM框架，全称为 Object_Relative DateBase-Mapping，在Java对象与关系数据库之间建立某种映射，以实现直接存取Java对象！
Hibernate开放源代码的对象关系映射框架，它对JDBC进行了轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架,核心内容是ORM（Object Relational Mapping 对象关系映射）,可以根据对象自动的生成数据库相关表的信息，使得开发更加的面向对象。这样作为程序员就可以使用面向对象的思想来操作数据库，而不用关心繁琐的JDBC。
Hibernate 项目搭建步骤
1. 新建maven 普通项目
2. 添加相关依赖坐标
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.39</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.3.7.Final</version>
</dependency>3. 添加hibernate.cfg.xml 主配置文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<!--初始化hibernate配置文件-->
<hibernate-configuration>
<!-- 通常，一个session-factory节点代表一个数据库 -->
<session-factory>
<!-- 1. 数据库连接配置 -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql:///hibernate?SSL=false</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">123456</property>
<!--
数据库方法配置， hibernate在运行的时候，会根据不同的方言生成符合当前数据库语法的sql
-->
<property name="hibernate.dialect">org.hibernate.dialect.MySQL57Dialect</property>
<!--建表方式 update：如果表不存在，则自动创建表-->
<property name="hibernate.hbm2ddl.auto">update</property>
<!--显示sql语句-->
<property name="show_sql">true</property>
<!--格式化sql语句-->
<property name="format_sql">true</property>
<!--3. 加载映射文件-->
<mapping resource="cn/sm1234/domain/Customer.hbm.xml"/>
</session-factory>
</hibernate-configuration>4. 添加实体类Customer
package cn.sm1234.domain;
import java.io.Serializable;
/** * Description:
* * @author 郭新
*/
public class Customer implements Serializable{
private static final long serialVersionUID = 1L;
private Integer id;
private String name;
private String gender;
private Integer age;
private String level;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getLevel() {
return level;
}
public void setLevel(String level) {
this.level = level;
}
@Override
public String toString() {
return "Customer [id=" + id + ", name=" + name + ", gender=" + gender
+ ", age=" + age + ", level=" + level + "]";
}
}5. 编写映射文件
Customer.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指定包名-->
<hibernate-mapping package="cn.sm1234.domain">
<!--
name:类名
table:表名
-->
<class name="Customer" table="t_customer">
<!--主键映射，name:对象属性名为，column:数据库表列名-->
<id name="id" column="c_id">
<!--根据底层数据库主键自动增长-->
<!--native自增-->
<!--assigned自己指定-->
<generator class="native"></generator>
</id>
<!-- 其他属性 -->
<property name="name" column="c_name"></property>
<property name="gender" column="c_gender"></property>
<property name="age" column="c_age"></property>
<property name="level" column="c_level"></property>
</class>
</hibernate-mapping>6. 编写测试类
@Test
public void test1(){
Customer customer = new Customer();
customer.setName("老王222");
customer.setAge(40);
customer.setGender("男");
customer.setLevel("VIP客户");
//1.读取hibernate.cfg.xml文件
Configuration cfg = new Configuration();
cfg.configure();
//2.创建SessionFactory工厂
SessionFactory factory = cfg.buildSessionFactory();
//3.创建Session对象
Session session = factory.openSession();
//4.开启事务
Transaction tx = session.beginTransaction();
//5.执行添加操作
session.save(customer);
//6.提交事务
tx.commit();
//7.关闭资源
session.close();
}7. 读取配置文件
(maven中不设置读取配置文件就无法访问到除resources外的文件)
<build>
<!--读取配置文件-->
<resources>
<resource>
<directory>src/main/resources</directory>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
</build>Hibernate 操作数据库的流程分析
- 加载配置文件
Configuration configuration= new Configuration().configure("hibernate.cfg.xml");- 通过注册中心生成SessionFactory
SessionFactory factory = configuration.buildSessionFactory();- 生成Session
Session session = sessionFactory.openSession();- 调用Hibernate 接口操作数据库
User user = (User)session.get(User.class,1);
- 关闭session
hibernate.cfg.xml 配置详解
hibernate.cfg.xml 是 hibernate 的核心配置文件
一共分为三个部分：
-
数据库连接的参数
hibernate.connection.driver_class(注册驱动)
hibernate.connection.url(链接地址)
hibernate.connection.username(数据库用户名)
hibernate.connection.password(数据库密码)
hibernate.dialect(数据库方言) -
hibernate 扩展参数
hibernate.show_sql : 是否输出 hibernate 生成的 sql 语句
hibernate.format_sql： 是否格式化 hibernate 生成的 sql 语句
hibernate.hbm2ddl.auto ：update:维护表结构。没有表的时候创建表，有表的时候不创建。 -
映射信息
*.hbm.xml对象映射文件详解
*.hbm.xml 这个文件是 hibernate 对象关系映射文件
hibernate-mapping 标签：根标签
package 属性： 类所在的包
class 标签： 代表映射一个类
name：类的限定名（包名+类名） 如果有了 package 属性，那么 name 只写类名即可
table：表名称
id 标签： 代表映射一个表的主键字段，必须的
name 属性： 类的属性名称，属性名称指定是实体类里面的 getter 和 setter方法的名称，而不是私有成员名称。
column 属性： 表的字段名称
generator 标签： 代表主键策略
property 标签： 代表映射类的普通字段
name 属性： 类的属性名称，属性名称指定是实体类里面的 getter 和 setter
方法的名称，而不是私有成员名称。
column 属性： 表的字段名称
Hibernate核心Api介绍
Hibernate 主要的 API 分别为：Session、SessionFactory、Transaction、Query、Criteria 和 Configuration。通过这些接口，可以对持久化对象进行存取、事务控制。
- Session
session 接口负责对象的 CRUD 操作。但需要注意的是 Session 对象是非线程安全的同mybatis 中 sqlsession。(注意跟 http 中 session 不一样，这里指的是数据库会话对象)。- SessionFactory
SessionFactory 接口充当数据存储源的代理，并负责创建 Session 对象。单例只需要初始化一次即可- Transaction
Transaction 接口是一个可选的 API，可以选择不使用这个接口，取而代之的是Hibernate 的设计者自己写的底层事务处理代码。Transaction 接口是对实际事务实现的一个抽象，这些实现包括 JDBC 的事务、JTA 中的UserTransaction、甚至可以是 CORBA 事务。之所以这样设计是能让开发者能够使用一个统一事务的操作界面，使得自己的项目可以在不同的环境和容器之间方便地移植。- Query
Query 接口让你方便地对数据库及持久对象进行查询，它可以有两种表达方式：HQL语言或本地数据库的 SQL 语句。Query 经常被用来绑定查询参数、限制查询记录数量，并最终执行查询操作。- Criteria
接口的作用用于执行基于对象的查询（QBC 查询）- Configuration
Configuration 类的作用是对 Hibernate 进行配置，以及对它进行启动。在 Hibernate的启动过程中，Configuration 类的实例首先定位映射文档的位置，读取这些配置，然后创建一个 SessionFactory 对象。虽然 Configuration 类在整个 Hibernate 项目中只扮演着一个很小的角色，但它是启动 hibernate 时所遇到的第一个对象。Hibernate 工具类
/** * Description: * * @author 郭新 */public class HibernateUtil { private static Configuration configuration = null; private static SessionFactory sessionFactory = null; //只需要执行1次 static{ configuration = new Configuration(); configuration.configure(); sessionFactory = configuration.buildSessionFactory(); } /** * 让外部获取Session对象 */ public static Session getSession(){ //return factory.openSession(); return sessionFactory.openSession(); } public static void closeSession(){ getSession().close(); }}使用 Session 接口进行增删改查
session 接口的常用方法
- session.save(obj); 【保存一个对象】
- session.update(obj); 【更新一个对象】
- session.delete(obj); 【删除一个对象】
- session.get(obj); 【查询一个对象】// 立即查询
- session.load(obj); 【查询一个对象】 // 懒加载
public class Demo3 { /** *save(Object obj) : 保存对象 */ @Test public void test1(){ Customer customer = new Customer(); customer.setName("老王3333"); customer.setAge(40); customer.setGender("男"); customer.setLevel("VIP客户"); Session session = HibernateUtil.getSession(); //4.开启事务 Transaction tx = session.beginTransaction(); //5.执行添加操作 session.save(customer); //6.提交事务 tx.commit(); //7.关闭资源 session.close(); } /** *update(Object obj)： 更新对象 */ @Test public void test2(){ Customer customer = new Customer(); //给Customer的id赋值，才可以更新 customer.setId(1); customer.setName("老王44444"); customer.setAge(45); customer.setGender("男"); customer.setLevel("VIP客户"); Session session = HibernateUtil.getSession(); //4.开启事务 Transaction tx = session.beginTransaction(); //5.执行添加操作 session.update(customer); //6.提交事务 tx.commit(); //7.关闭资源 session.close(); } /** *saveOrUpdate(Object obj): 添加或修改对象 */ @Test public void test3(){ Customer customer = new Customer(); //给Customer的id赋值，才可以更新 customer.setId(1); customer.setName("老王666"); customer.setAge(45); customer.setGender("男"); customer.setLevel("VIP客户"); Session session = HibernateUtil.getSession(); //4.开启事务 Transaction tx = session.beginTransaction(); //5.执行添加操作 session.saveOrUpdate(customer); //6.提交事务 tx.commit(); //7.关闭资源 session.close(); } /** *delete(Object obj): 删除对象 */ @Test public void test4(){ Session session = HibernateUtil.getSession(); //4.开启事务 Transaction tx = session.beginTransaction(); //5.执行添加操作，设置id后才可删除 Customer customer = new Customer(); customer.setId(1); session.delete(customer); //6.提交事务 tx.commit(); //7.关闭资源 session.close(); } /** *get(Class clz,Serialize id): 获取对象 *load(Class clz,Serialize id): 获取对象 */ @Test public void test5(){ Session session = HibernateUtil.getSession(); //4.开启事务 Transaction tx = session.beginTransaction(); //5.执行添加操作 //Customer cust = session.get(Customer.class, 1); Customer cust = session.load(Customer.class, 1); System.out.println(cust); //6.提交事务 tx.commit(); //7.关闭资源 session.close(); }}Hibernate 对象状态
瞬时态(transient)
数据库中没有数据与之对应，超过作用域会被 JVM 垃圾回收器回收，一般是new 出来且与 session没有关联的对象。如果 session 中和数据库中都不存在该对象 ，那么该对象就是瞬时对象。session中没有，数据库中也没有
持久态(persistent)
数据库中有数据与之对应，当前与session有关联，并且相关联的session没有关闭，事务没有提交 ；持久对象状态发生改变，在事务提交时会影响到数据库(hibernate能检测到)。session中有，数据库中也有
游离态(detached)
数据库中有数据与之对应，但当前没有 session 与之关联；托管对象状态发生改变，hibernate不能检测到。session中没有，数据库中有
@Test public void test8() { // 获取session会话 Session session = HibernateUtil.getSession(); // 开启事务 Transaction transaction = session.beginTransaction(); User user=new User(); user.setUsername("张三"); user.setPassword("123456"); // user 瞬时态(session和数据库中都没有) session.save(user); // 持久态(session和数据库中都已保存) transaction.commit(); // 关闭session会话 HibernateUtil.closeSession(); // 游离态(session中没有，数据库中有) }全部评论 (0)
还没有任何评论哟~