Hibernate入门教程（一）

讲师：钟昕灵，叩丁狼教育高级讲师。原创文章，转载请注明出处。

框架的介绍

什么是框架?

框架其实就是一个半成品,为某一领域提供解决方案,我们可以在这个基础之上继续开发,完成实际的业务需求

三层架构

在实际开发中,为了项目的可维护性和可拓展性,我们往往将项目按照功能性分为三层:

• 表现层:主要对用户的请求接受，以及数据的返回，为客户端提供应用程序的访问;代表框架:Struts2/SpringMVC
• 业务层:负责业务逻辑运算,处于表现层和持久层之间;代表框架:Spring
• 持久层:负责与数据库或者存储设备的交互,如,对数据的CRUD,代码框架:Hibernate/MyBatis

  hibernate(冬眠)简介

  Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任—-百度百科

通过以上的介绍,相信大家对hibernate框架相关的基本概念有了一定的认识和了解,那么,接下来,我们就开始学习hibernate吧!

环境搭建及相关准备

• JDK版本: 1.8
• hibernate版本: 5.2.13
• 开发工具(IDE): STS(Spring Tool Suite)

hibernate中的文件介绍:

• documentation: hibernate相关的文档资源,如API,参考手册等
• lib: 该文件夹存放Hibernate框架的核心类库以及Hibernate的第三方类库。该文件夹下的required子目录存放运行Hibernate项目的必须的核心类库
• project: hibernate中各个项目的源代码

所以,在开发hibernate应用之前,首先在项目中导入lib/required/目录中的jar包

使用hibernate实现数据的增删改操作

数据准备

• 创建user表和实体类User

  CREATE TABLE `user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `username` varchar(20) DEFAULT NULL,
  `password` varchar(50) DEFAULT NULL,
  `age` tinyint(4) DEFAULT NULL,
  `hiredate` date DEFAULT NULL,
  PRIMARY KEY (`id`)
  ) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8;
  

  ```
  //lombok插件中的注解:自动生成getter/setter方法
  @Getter@Setter
  public class User {
  private Long uid;
  private String uusername;
  private String upassword;
  private Integer uage;
  private Date uhiredate;
  }

注:刻意使列名和属性名不一致,期待hibernate帮我们解决这个问题
-  hibernate.cfg.xml
hibernate的主配置文件,可以在该配置文件中配置连接数据库的基本信息
在项目中创建一个[source folder],命名为resources
从hibernate的project/etc目录中拷贝hibernate.cfg.xml,然后做如下配置

<!DOCTYPE hibernate-configuration PUBLIC
“-//Hibernate/Hibernate Configuration DTD 3.0//EN”
“http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<!-- hibernate的主配置文件 -->

<hibernate-configuration>
<session-factory>
<!-- 连接数据库的基本信息 -->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.url">jdbc:mysql:///hibernate</property>
<property name="connection.username">root</property>
<property name="connection.password">admin</property>
<!-- 在控制台中显示执行的sql -->
<property name="show_sql">true</property>
<!-- 关联映射文件 -->
<mapping resource="cn/wolfcode/_01_hello/User.hbm.xml" />
</session-factory>
</hibernate-configuration>

- User.hbm.xml
实现数据库中的表和Java中的类的映射

<?xml version=”1.0”?>
<!DOCTYPE hibernate-mapping PUBLIC “-//Hibernate/Hibernate Mapping DTD 3.0//EN”
“http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
<class name="cn.wolfcode._01_hello.User" table="user">
<id name="uid" column="id">
<generator class="native" />
</id>
<property name="uusername" column="username" />
<property name="upassword" column="password" />
<property name="uage" column="age" />
<property name="uhiredate" column="hiredate" />
</class>
</hibernate-mapping>

以上是使用hibernate实现CRUD的基本准备,那么接下来我们来测试一下
创建一个DAO接口及其实现类:在实现类中使用hibernate相关API实现数据的增删改操作

package cn.wolfcode._01_hello;

public interface IUserDAO {
void save(User u);

void delete(User u);

void update(User u);

}

保存数据:session.save(Object object);

package cn.wolfcode._01_hello;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
public class UserDAOImpl implements IUserDAO {
@Override
public void save(User u) {
// 创建hibernate的配置对象
Configuration conf = new Configuration();
// 加载hibernate的配置文件
conf.configure(“/hibernate.cfg.xml”);
// 创建SessionFactory对象:可理解为一个连接池对象
SessionFactory factory = conf.buildSessionFactory();
// 创建Session对象:可理解为一个连接对象
Session session = factory.openSession();
// 获取事务管理对象
Transaction transaction = session.getTransaction();
// 开启事务
transaction.begin();
// 调用session的save方法完成数据的保存操作
session.save(u);
// 提交事务
transaction.commit();
// 释放资源
session.close();
}
}

在测试类中测试dao中的save方法

package cn.wolfcode._01_hello;
import java.util.Date;
import org.junit.Test;
public class UserDAOImplTest {
private IUserDAO dao = new UserDAOImpl();
@Test
public void testSave() {
User u = new User();
u.setUage(10);
u.setUusername(“admin”);
u.setUpassword(“123456”);
u.setUhiredate(new Date());
dao.save(u);
}
}

执行SQL

Hibernate: insert into user (username, password, age, hiredate) values (?, ?, ?, ?)

在完成数据的保存之后,我们可以使用相同的方式实现数据的删除和修改操作,如下

删除数据: session.delete(Object object);

public void delete(User u) {
// 创建hibernate的配置对象
Configuration conf = new Configuration();
// 加载hibernate的配置文件
conf.configure(“/hibernate.cfg.xml”);
// 创建SessionFactory对象:可理解为一个连接池对象
SessionFactory factory = conf.buildSessionFactory();
// 创建Session对象:可理解为一个连接对象
Session session = factory.openSession();
// 获取事务管理对象
Transaction transaction = session.getTransaction();
// 开启事务
transaction.begin();
// 调用session的delete方法完成数据的删除操作
session.delete(u);
// 提交事务
transaction.commit();
// 释放资源
session.close();
}

执行SQL

Hibernate: delete from user where id=?

修改数据: session.update(Object object);

public void update(User u) {
// 创建hibernate的配置对象
Configuration conf = new Configuration();
// 加载hibernate的配置文件
conf.configure(“/hibernate.cfg.xml”);
// 创建SessionFactory对象:可理解为一个连接池对象
SessionFactory factory = conf.buildSessionFactory();
// 创建Session对象:可理解为一个连接对象
Session session = factory.openSession();
// 获取事务管理对象
Transaction transaction = session.getTransaction();
// 开启事务
transaction.begin();
// 调用session的delete方法完成数据的删除操作
session.update(u);
// 提交事务
transaction.commit();
// 释放资源
session.close();
}

执行SQL

Hibernate: update user set username=?, password=?, age=?, hiredate=? where id=?

####查询数据: 
查询单条数据:session.get(Class<T> type, Serializable id)
数据查询可以脱离事务执行

public User get(long id) {
// 创建hibernate的配置对象
Configuration conf = new Configuration();
// 加载hibernate的配置文件
conf.configure(“/hibernate.cfg.xml”);
// 创建SessionFactory对象:可理解为一个连接池对象
SessionFactory factory = conf.buildSessionFactory();
// 创建Session对象:可理解为一个连接对象
Session session = factory.openSession();
// 调用session的delete方法完成数据的删除操作
User user = session.get(User.class, id);
// 释放资源
session.close();
return user;
}

执行sql

Hibernate:
select
user0.id as id1_0_0, user0.username as username2_0_0, user0.password
as password3_0_0, user0.age as age4_0_0, user0.hiredate as hiredate5_0_0
from
user user0
where
user0.id=?

查询多条数据:session.createQuery(String hql);

public List<User> list() {
// 创建hibernate的配置对象
Configuration conf = new Configuration();
// 加载hibernate的配置文件
conf.configure(“/hibernate.cfg.xml”);
// 创建SessionFactory对象:可理解为一个连接池对象
SessionFactory factory = conf.buildSessionFactory();
// 创建Session对象:可理解为一个连接对象
Session session = factory.openSession();
// 调用session的delete方法完成数据的删除操作
List<User> list = session.createQuery(“FROM User”).list();
// 释放资源
session.close();
return list;
}

执行SQL

Hibernate:
select
user0.id as id1_0, user0.username as username2_0, user0.password
as password3_0, user0.age as age4_0, user0.hiredate as hiredate5_0
from
user user0_
```

小结

以上,我们使用Hibernate相关的API实现了数据的基本CRUD操作,下面我们小结一下基本的开发流程,在下一节中我们再来分析Hibernate的执行流程

1. 创建表以及实体类
2. 导入hibernate应用必须的jar包
3. 编写配置文件:hibernate.cfg.xml / user.hbm.xml
4. 在dao中实现数据的保存操作
   // 创建hibernate的配置对象
   // 加载hibernate的配置文件
   // 创建SessionFactory对象:可理解为一个连接池对象
   // 创建Session对象:可理解为一个连接对象
   // 获取事务管理对象
   // 开启事务
   // 调用session的delete方法完成数据的删除操作
   // 提交事务
   // 释放资源

1. 完成各个测试
2.