Hibernate学习笔记（二）——创建一个简单的Hibernate项目

最新推荐文章于 2023-05-18 17:19:28 发布

fxdaniel

最新推荐文章于 2023-05-18 17:19:28 发布

阅读量7.7k

点赞数 2

分类专栏： JavaWeb 文章标签：入门 hibernate

本文链接：https://blog.csdn.net/fxdaniel/article/details/42420779

版权

JavaWeb 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

转载请指明出处：http://blog.csdn.net/fxdaniel/article/details/42420779

接上一篇文章：Hibernate学习笔记（一）——搭建Hibernate开发环境

首先来看看Hibernate开发的一个简单流程：

（1）准备开发环境，创建Hibernate项目。

（2）在数据库中创建数据表。

（3）创建持久化类。

（4）设计映射文件，使用Hibernate映射文件将POJO对象映射到数据库。

（5）创建Hibernate的配置文件Hibernate.cfg.xml。

（6）编写辅助工具类HibernateUtil类，用来实现对HIbernate的初始化并提供获得Session的方法，此步可根据情况取舍。

（7）编写DAO层类。

（8）编写Service层类。

（9）编写测试类。

下面来一步一步地做。

1.创建Eclipse项目

在Eclipse中创建一个Dynamic Web Project项目，命名为HibernateDemo。
在HibernateDemo项目名称上右击，在快捷菜单中选择New->Other选项，在弹出的对话框中找到Hibernate节点，选择Hibernate Configuration File(cfg.xml)选项，如下图所示：

点击Next按钮，在弹出的对话框中选择配置文件保存的目录，一般默认在src目录，同时需要输入配置文件的名称，一般默认为hibernate.cfg.xml即可。继续Next，在弹出的对话框中填写数据库方言（Database dialect）、数据库驱动（Driver class）、数据库URL、用户名、密码等。MySQL数据库的配置如下：

单击Finish，配置文件就创建成功了，后面有需要可以继续编辑该文件。

2.创建数据表USER

在MySQL中创建一个名为mysqldb的数据库，在该数据库中创建一张名为USER的表。创建USER表的语句如下：

create table user(
user_id int(11),
name varchar(20),
password varchar(12),
type varchar(6),
primary key(user_id));

创建好的USER表在MySQL中显示如下：

mysql> describe user;
+----------+-------------+------+-----+---------+-------+
| Field    | Type        | Null | Key | Default | Extra |
+----------+-------------+------+-----+---------+-------+
| user_id  | int(11)     | NO   | PRI | 0       |       |
| name     | varchar(20) | YES  |     | NULL    |       |
| password | varchar(12) | YES  |     | NULL    |       |
| type     | varchar(6)  | YES  |     | NULL    |       |
+----------+-------------+------+-----+---------+-------+

3.编写POJO映射类User.java

package org.hibernate.entity;

public class User {

	private int id;//持久化类的标识属性，映射到数据表中的主键列
	private String name;
	private String password;
	private String type;
	public User() {
		// TODO Auto-generated constructor stub
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}
	
}

4.编写映射文件User.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2014-12-28 22:18:36 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
	<!-- name 持久化类的类名，table 数据表的表名，MySQL不区分大小写 -->
    <class name="org.hibernate.entity.User" table="USER">
    	<!-- 将User类中的id属性映射为数据表USER中的主键列user_id -->
        <id name="id" type="int">
            <column name="USER_ID" />
            <generator class="native" />
        </id>
        <!-- 映射User类的name属性 -->
        <property name="name" type="java.lang.String">
            <column name="NAME" length="20"/>
        </property>
        <!-- 映射User类的password属性 -->
        <property name="password" type="java.lang.String">
            <column name="PASSWORD"  length="12"/>
        </property>
        <!-- 映射User类的type属性 -->
        <property name="type" type="java.lang.String">
            <column name="TYPE" length="6"/>
        </property>
    </class>
</hibernate-mapping>

5.编写hibernate.cfg.xml配置文件

前面我们通过Hibernate Tools的向导工具新建了一个hibernate.cfg.xml配置文件，其实我们也可以直接在src目录下新建一个XML文件将其命名为hibernate.cfg.xml。现在我们需要编辑这个文件，增加一些配置，修改后的文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
                                         "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
	<session-factory>
		<!-- 数据库的JDBC驱动 -->
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<!-- 数据库的URL -->
		<property name="hibernate.connection.url">jdbc:mysql://127.0.0.1:3306/mysqldb</property>
		<!-- 数据库的用户名和密码 -->
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password"></property>
		<!-- 数据库的方言 -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
		<!-- Hibernate自动根据映射文件创建或者更新数据表 -->
		<property name="hibernate.hbm2ddl.auto">update</property>
		<!-- 在控制台输出运行时生成的SQL语句，方便调试 -->
		<property name="show_sql">true</property>
		<!-- 连接池大小 -->
		<property name="connection.pool_size">1</property>
		<!-- 列出所有映射文件 -->
		<mapping resource="org/hibernate/entity/User.hbm.xml" />
	</session-factory>
</hibernate-configuration>

6.编写辅助工具类HibernateUtil.java

package org.hibernate.entity;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {

	private static SessionFactory sessionFactory;
	// 创建线程局部变量threadLocal，用来保存Hibernate的Session
	private static final ThreadLocal<Session> threadLocal=new ThreadLocal<Session>();
	// 使用静态代码块初始化Hibernate
	static
	{
		try
		{
			// 读取配置文件
			Configuration cfg=new Configuration().configure();
			// 创建SessionFactory
			sessionFactory=cfg.buildSessionFactory();
		}catch(Throwable ex)
		{
			throw new ExceptionInInitializerError(ex);
		}
	}
	// 获得SessionFactory的实例
	public static SessionFactory getsSessionFactory()
	{
		return sessionFactory;
	}
	// 获得ThreadLocal对象管理的Session
	public static Session getsSession() throws HibernateException
	{
		Session session=(Session) threadLocal.get();
		if(session==null||!session.isOpen())
		{
			if(sessionFactory==null)
			{
				rebuildSessionFactory();
			}
			// 通过SessionFactory对象创建Session对象
			session=(sessionFactory!=null)?sessionFactory.openSession():null;
			// 将Session对象保存到线程局部变量threadLocal中
			threadLocal.set(session);
		}
		return session;
	}
	// 关闭Session实例
	public static void closeSession()
	{
		// 从线程局部变量threadLocal中获取之前存入的Session实例
		Session session=(Session)threadLocal.get();
		threadLocal.set(null);
		if(session!=null)
		{
			session.close();
		}
	}
	// 重建SessionFactory
	public static void rebuildSessionFactory()
	{
		Configuration configuration=new Configuration();
		configuration.configure("/hibernate.cfg.xml");
		sessionFactory=configuration.buildSessionFactory();
	}
	// 关闭缓存和连接池
	public static void shutdown()
	{
		getsSessionFactory().close();
	}
}

7.编写DAO层接口UserDAO.java

package org.hibernate.dao;

import org.hibernate.entity.User;

public interface UserDAO {

	void save(User user);
	User findById(int id);
	void delete(User user);
	void update(User user);
}

8.编写DAO层实现类UserDAOImpl.java

package org.hibernate.dao;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.entity.HibernateUtil;
import org.hibernate.entity.User;

public class UserDAOImpl implements UserDAO {

	// 添加用户
	@Override
	public void save(User user) {
		// TODO Auto-generated method stub
		// 创建Session实例
		Session session = HibernateUtil.getsSession();
		// 创建Transaction实例
		Transaction tx = session.beginTransaction();
		try {
			// 使用Session的save方法将持久化对象保存到数据库
			session.save(user);
			// 提交事务
			tx.commit();
		} catch (Exception e) {
			e.printStackTrace();
			// 出现异常，回滚事务
			tx.rollback();
		} finally {
			// 关闭Session连接
			HibernateUtil.closeSession();
		}
	}

	// 根据id查找用户
	@Override
	public User findById(int id) {
		// TODO Auto-generated method stub
		User user = null;
		Session session = HibernateUtil.getsSession();
		Transaction tx = session.beginTransaction();
		try {
			// 使用session的get方法获取指定id的用户
			user = (User) session.get(User.class, id);
			tx.commit();
		} catch (Exception e) {
			e.printStackTrace();
			tx.rollback();
		} finally {
			HibernateUtil.closeSession();
		}
		return user;
	}

	// 删除用户
	@Override
	public void delete(User user) {
		// TODO Auto-generated method stub
		Session session = HibernateUtil.getsSession();
		Transaction tx = session.beginTransaction();
		try {
			// 使用session的delete方法将持久化对象删除
			session.delete(user);
			tx.commit();
		} catch (Exception e) {
			e.printStackTrace();
			tx.rollback();
		} finally {
			HibernateUtil.closeSession();
		}
	}

	// 修改用户信息
	@Override
	public void update(User user) {
		// TODO Auto-generated method stub
		Session session = HibernateUtil.getsSession();
		Transaction tx = session.beginTransaction();
		try {
			// 使用session的update方法更新持久化对象
			session.update(user);
			tx.commit();
		} catch (Exception e) {
			tx.rollback();
			e.printStackTrace();
		} finally {
			HibernateUtil.closeSession();
		}
	}

}

通过以上步骤，一个Hibernate项目就完成了，下面我们来测试一下。

9.编写测试类UserTest.java

在HibernateDemo项目名称上右击，选择Properties，在弹出的窗口左侧选择Java Build Path选项，然后在右侧界面中选择Libraries标签，点击Add Library按钮，在弹出的窗口中选择Junit，如下图所示：

然后点击Next，在version一栏选择Junit 4，然后点击Finish。这样Junit包就引入到项目中了。

接下来在项目中新建org.hibernate.test包，在包名上右击，依次选择New->Junit Test Case菜单，在弹出的窗口中填写测试类的名称和需要测试的类的名称（这个需要填写完整包名），如下图所示：

点击Next按钮，可以选择需要测试的方法，根据需要选择即可。

点击Finish，系统会自动生成UserTest类的框架，里面包含了一些空方法，我们将需要测试的方法进行重写就可以了。

这里以save方法为例，重写testSave方法。

package org.hibernate.test;

import org.hibernate.dao.UserDAO;
import org.hibernate.dao.UserDAOImpl;
import org.hibernate.entity.User;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;

public class UserTest {

	@AfterClass
	public static void tearDownAfterClass() throws Exception {
	}

	@Before
	public void setUp() throws Exception {
	}

	// @Test 注释表名是一个测试方法
	@Test
	public void testSave() {
		UserDAO userDAO=new UserDAOImpl();
		try{
			User u=new User();
			// 设置User对象的各个属性
			u.setId(20);
			u.setName("zhangsan");
			u.setPassword("123456");
			u.setType("admin");
			// 使用UserDAOImpl的save方法将User对象存入到数据库
			userDAO.save(u);
		}catch(Exception e){
			e.printStackTrace();
		}
	}
}

接下来在UserTest.java文件名称上右击，依次选择Run As ->Junit Test菜单，我们可以在Eclipse的Junit View中看到测试结果，如果进度条正确，表示结果正确，如果进度条为红色，表明有错误，我们可以看到有什么错误。

然后我们到数据库中看看数据有没有正确保存到数据库。

mysql> select * from user;
+---------+----------+----------+-------+
| USER_ID | NAME     | PASSWORD | TYPE  |
+---------+----------+----------+-------+
|       1 | zhangsan | 123456   | admin |
+---------+----------+----------+-------+

这里可能有人会感到奇怪，为什么UserTest类中设置了id为20，结果保存到数据库中确是1呢？

因为我们在User.hbm.xml文件中将id设置成了主键，如下所示：

    	<!-- 将User类中的id属性映射为数据表USER中的主键列user_id -->
        <id name="id" type="int">
            <column name="USER_ID" />
            <generator class="native" />
        </id>

其中的generator元素指的是主键生成策略，hibernate会按照主键生成策略为id赋值，而不会将程序中的id值存储到数据库。

最后结合上面的项目我们再看看Hibernate的工作原理：

（1）Hibernate初始化，创建Configuration对象。

a）从Hibernate配置文件hibernate.properties或者hibernate.cfg.xml中读取配置信息，存放到Configuration对象中。

b）根据配置文件中的mapping元素加载所有实体类对应的映射文件到Configuration对象中。

说明：Hibernate可以采取两种形式的配置文件，一种是hibernate.properties文件，另一种是hibernate.cfg.xml文件。这两种文件本质上是一样的，都可以完成对Hibernate的配置工作，在实际开发中，更多地采用XML格式的配置文件。若两种配置文件同时存在且都有相同的配置信息，则hibernate.cfg.xml中的配置会覆盖掉hibernate.properties中的配置，这其中的原因结合代码来解释。看如下代码：

Configuration cfg=new Configuration().configure();

这是创建Configuration实例并读取配置文件的代码。

当执行new Configuration()方法时，Hibernate会在classpath的根目录下查找hibernate.properties文件。如果找到了该文件，则所有的hibernate.*的属性被装载到Configuration对象中。
当调用configure()方法时，Hibernate会在classpath根目录下查找hibernate.cfg.xml。如果找不到则抛出HibernateException。如果hibernate.cfg.xml中的某些属性和hibernate.properties中的重复了，则会覆盖。

（2）创建SessionFactory实例。

Configuration对象将配置信息存入SessionFactory的属性中，创建完SessionFactory实例，Configuration对象的使命就结束了，SessionFactory与Configuration之间的关联也断开了。SessionFactory充当数据源的代理，并负责创建Session对象。

SessionFactory实例是全局唯一的，它对应着应用程序中的数据源，一个数据源只需要一个SessionFactory实例，只有当应用中有多个数据源时，才为每个数据源建立一个SessionFactory实例。
SessionFactory的实例是重量级的，创建和销毁都要消耗较多资源，因此只创建一次。
通过SessionFactory可以获得多个Session实例。
SessionFactory是线程安全的，可以被多个线程共享。Session不是线程安全的，多个并发线程同时操作一个Session实例时会出现问题，通常使用ThreadLocal模式管理Session。

（3）创建Session实例，建立数据库连接。

SessionFactory可以有两种方式创建Session。

a）openSession()方法。此方法直接创建一个新的Session实例，使用完之后需要调用close方法手动关闭。

b）getCurrentSession()方法。此方法创建的Session实例会绑定到当前线程，在事务提交（commit）或回滚（rollback）后会自动关闭。使用此方法必须在hibernate.cfg.xml配置文件中添加如下配置：

  <!-- 如果使用的是本地事务 -->
  <propertyname="hibernate.current_session_context_class">thread</property>
  <!-- 如果使用的是全局事务 -->
  <propertyname="hibernate.current_session_context_class">jta</property>

（4）创建Transaction实例，开始一个事务。

Hibernate的事务是对数据库底层事务的封装，在对Hibernate进行增、删、改操作的时候必须先创建一个Transaction对象，一个事务就是一个原子操作。

（5）利用Session的方法进行持久化操作。将实体对象持久化到数据库中。

（6）提交事务。

（7）关闭Session，断开与数据库的连接。

项目的源代码点此下载：HibernateDemo

fxdaniel

关注

2
点赞
踩
13

收藏

觉得还不错? 一键收藏
2
评论
Hibernate学习笔记（二）——创建一个简单的Hibernate项目

首先来看看Hibernate开发的一个简单流程：（1）准备开发环境，创建Hibernate项目。（2）在数据库中创建数据表。（3）创建持久化类。（4）设计映射文件，使用Hibernate映射文件将POJO对象映射到数据库。（5）创建Hibernate的配置文件Hibernate.cfg.xml。（6）编写辅助工具类HibernateUtil类，用来实现对HIbernate的初始化并提供获得Session的方法，此步可根据情况取舍。（7）编写DAO层类。（8）编写Service层类。（9）编
复制链接

扫一扫