Hibernate开发实例

1. 创建HibernateDemo项目（也可以是其他名称）

（1）在Eclipse中，单击Eclipse菜单中的【File】选择【New】选项，选择创建【DynamicWebProject】（动态Web项目）；

（2）Project name我们填写为HibernateDemo（也可以是其他名称）；

（3）单击【Finish】，我们的项目便创建完成了。

2. 在Eclipse中部署Hibernate开发包和MySQL驱动包

在这里我们做的是简单项目，所以需要的开发包有限，主要用的是必须开发包。

（1）解压我们在上面“下载Hibernate开发包”步骤中下载好的hibernate-release-5.0.9.Final.zip，可以看到“lib”文件夹，进入其中，看到一个名为“required”的文件夹；

（2）我们拷贝“required”文件夹中所有jar包到我们在Eclipse中创建的项目StrutsDemo的“WebContent”目录下的“WEB-INF”目录下的“lib”文件夹中；

（3）在Eclipse中，选中HibernateDemo项目右键，选中【BuildPath】,将【Order and Export】选项中的所有jar包选中，然后单击按钮【Apply】,在单击按钮【OK】；

（6）通过以上步骤，我们算是把简单Hibernate所需开发包添加完了，下面就剩对代码的编写了。

注释：添加MySQL驱动包可以参考博文：在项目中安装部署MySQL驱动

3. 在数据库中创建数据表

在这里我们简单的实现一个用户登录的功能，因此创建一个简单的数据库User，包含了一个表格userInfo，userInfo表的结构如下：

在MySQL中创建创建数据库User，并创建userInfo表的SQL语句如下：

create database  User;

use User;

CREATE TABLE `userInfo` (

`userID` int(11) NOT NULL,

`userName` varchar(20) ,

`userPwd` varchar(20) ,

`userType` varchar(10) ,

PRIMARY KEY (`userID`)

);

4.  创建持久化类

持久化类指定是类的对象能够被持久化（保存）到数据库中。在Hibernate中使用POJOs(普通的java对象（Plain Old Java Objects）)的编程方法来进行持久化操作。在POJO类中包含了与数据库表中相对应的各个属性，并设置了getter和setter方法以便向外部隐藏内部的细节。

下面我们创建对应数据库表userInfo的持久化类User：

package edu.test.entity;

import java.io.Serializable;

public
class User implements Serializable{

private
intid;
//用户标识

private Stringname;//用户名

private Stringpassword;//用户密码

private Stringtype;//用户类型

//默认构造方法

public User(){

}

public
int getId() {

returnid;

}

public
void setId(int id) {

this.id =id;

}

public String getName() {

returnname;

}

public
void setName(String name){

this.name =name;

}

public String getPassword() {

returnpassword;

}

public
void setPassword(String password){

this.password =password;

}

public String getType() {

returntype;

}

public
void setType(String type){

this.type =type;

}

}

注意：持久化类必须遵循以下规则：

1.     所有的持久化类必须有一个默认的构造方法。（这是为了使Hibernate可以使用Java的反射机制，调用java.lang.reflect.Constructor.newInstance()方法来实例化持久化类。）

2.     持久化类应该提供一个标识属性，用于映射到底层数据库表中主键列，如：这里的id属性。

3.     必须为持久化类的各个属性声明getters方法和setters方法。

4.     建议不要将持久化类声明为final。因为Hibernate的延迟加载要求定义的持久化类是非final的、或者是该持久化类实现了某个接口。（如果确实需要将一个持久化类声明为final，且该类未实现某个接口，则必须禁止生产代理，即不采用延迟加载）

5.  设计映射文件

为了完成对象到关系数据库的映射，Hibernate需要知道持久化类的实例是如何存储和加载的，我们使用XML文件类设置它们之间的映射关系。

在这里我们创建一个名为User.hbm.xml的映射文件，在该文件中我们定义了持久化类User的属性如何映射到userInfo表的列上。

1.   在Eclipse中，选中HibernateDemo项目中的【src】目录中User.java类的包目录（这里是edu.test.entity）右键，选中【New】,将【other】选项，在弹出框中的【Wizards】输入框中输入Hibernate，然后在结果中选择【Hibernate XML Mapping file（hbm.xml）】,在单击按钮【Next】；

2.   进入如下的新建配置文件对话框，我们单击【AddClass】，

3.   弹出如下图所示的界面

4.   选中刚才添加的类，单击【Next】；

5.   可以看到类以及与类对应的映射文件

6.   可以看到可以开始创建User.hbm.xml文件了，单击【Finish】按钮，文件创建完成；

7.   编写后，User.hbm.xml的代码如下：

<?xmlversion="1.0"?>

<!DOCTYPEhibernate-mapping

SYSTEM

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mappingpackage="edu.test.entity">

<!--name指定持久化类的类名，table指定数据表的表名 -->

<class   name="User"   table="userInfo">

<!-- 将User类中的id属性映射为数据表中的主键userID
-->

<idname="id"  type="java.lang.Integer" 
 column="userID">

<generatorclass="increment"/>

</id>

<!-- 映射User类中name属性为数据表userInfo中的userName列
-->

<propertyname="name"   type="java.lang.String" 
 column="userName"   length="20"/>

<!-- 映射User类中password属性为数据表userInfo中的userPwd列
-->

<propertyname="password"  type="java.lang.String"
  column="userPwd"   length="20"/>

<!-- 映射User类中type属性为数据表userInfo中的userType列
-->

<propertyname="type"  type="java.lang.String" 
 column="userType"   
length="10"/>

</class>

</hibernate-mapping>

或者如下：

<?xmlversion="1.0"?>

<!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/HibernateMapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<!-- Generated 2016-7-13 0:12:08 by Hibernate Tools 3.4.0.CR1-->

<hibernate-mapping>

<classname="edu.test.entity.User"  table="userInfo">

<idname="id"  type="int">

<columnname="userID"/>

<generatorclass="assigned"/>

</id>

<propertyname="name"  type="java.lang.String">

<columnname="userName"/>

</property>

<propertyname="password"   type="java.lang.String">

<columnname="userPwd"/>

</property>

<propertyname="type"   type="java.lang.String">

<columnname="userType"/>

</property>

</class>

</hibernate-mapping>

注意：上面创建的User.hbm.xml文件同User.java 文件放在同一个包edu.test.entity中。

6. 创建配置文件Hibernate.cfg.xml

Hibernate为了能够适应各种不同的工作环境，它需要使用配置文件，我们可以通过它提供的大量的配置参数，来进行配置。这些参数大都有直观的默认值，在使用时所要做的仅仅是根据使用环境来修改配置文件中的相关的参数值。

Hibernate的配置文件主要是用来配置数据库连接以及Hibernate运行时所需要的各个属性的值。

Hibernate的配置文件的格式有两种：一种是properties属性文件格式的配置文件，使用键值对的形式存放信息，默认文件为hibernate.properties；还有一种是XML格式的配置文件，默认名称是hibernate.cfg.xml。（两个文件的配置是等价的，若两个文静同时存在，则hibernate.cfg.xml文件会覆盖hibernate.properties文件）

大多数情况下，我们都选择配置hibernate.cfg.xml文件（易于修改），下面我们就讲解一下hibernate.cfg.xml文件的配置。

1.   在Eclipse中，选中HibernateDemo项目中的【src】目录右键，选中【New】,将【other】选项，在弹出框中的【Wizards】输入框中输入Hibernate，然后在结果中选择【Hibernate Configuration File（cfg.xml）】,在单击按钮【Next】；

2.   进入如下的新建配置文件对话框，我们输入相关相关信息（如：文件名为hibernate.cfg.xml），单击【Next】；

3.   进入如下图的对话框，在这里我们可以进行Hibernate配置文件相关属性的配置；

4.   单击【Finish】按钮，弹出如下图的界面，表示Hibernate配置文件创建完成；

5.   编写后，hibernate.cfg.xml文件的代码如下：

<?xmlversion="1.0"encoding="UTF-8"?>

<!DOCTYPEhibernate-configuration PUBLIC

"-//Hibernate/Hibernate Configuration DTD 3.0//EN"

"htt//hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

<!-- 数据库连接配置 -->

<!-- 配置数据库JDBC驱动 -->

<propertyname="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>

<!-- 配置数据库连接URL -->

<propertyname="hibernate.connection.url">jdbc:mysql://localhost:3306/user</property>

<!-- 配置数据库用户名 -->

<propertyname="hibernate.connection.username">root</property>

<!-- 配置数据库用户密码 -->

<propertyname="hibernate.connection.password">123456</property>

<!-- 配置JDBC内置连接池的个数 -->

<propertyname="hibernate.connection.pool_size">1</property>

<!-- 配置数据库方言 -->

<propertyname="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

<!-- 输出运行时生成的SQL语句 -->

<propertyname="hibernate.show_sql">true</property>

<!-- 列出所有的映射文件 -->

<mappingresource="edu/test/entity/User.hbm.xml"/>

</session-factory>

</hibernate-configuration>

下面我们对hibernate.cfg.xml文件中的相关属性进行简单讲解：

1.   Hibernate JDBC属性（可以参考博文：）

Hibernate JDBC的相关属性：

注释：关于常用的三种数据库的驱动和连接URL可以参考博文：JDBC连接数据库详细指南（包含MySQL、SQLServer、Oracle三种数据库）

2.   hibernate.dialect属性

该属性用于定义建立数据库连接是所使用的方言，该属性是为了使Hibernate能够针对特定的关系数据库生成适合的SQL语句。大部分情况下，Hibernate可以根据JDBC驱动返回的JDBC metadata来选择正确的org.hibernate.dialect.Dialect方言。

例如：

MySQL数据库中：

<propertyname="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

Oracle数据库中：

<propertyname="hibernate.dialect">org.hibernate.dialect.OracleDialect</property>

SQLServer数据库中：

<propertyname="hibernate.dialect">org.hibernate.dialect.SQLServerDialect</property>

3.   hibernate.show_sql属性

该属性可以将SQL语句输出到控制台，它的作用是为了方便调试，我们可以在控制台看到Hibernate执行的SQL语句。

4.   映射文件列表

为了将对象的映射信息加入到Hibernate的配置文件中，加入的方法就是在hibernate.cfg.xml配置文件中加入类似以下语句：

<mappingresource="edu/test/entity/User.hbm.xml"/>

其中，resource属性指定了映射文件的位置和名称，如果有多个映射文件，则需要使用多个mapping元素进行分别指定每个映射文件的位置和名称。

注释：在配置文件中指定了项目中所有的映射文件后，每次启动Hibernate时就可以自动装载映射文件，而无须手动处理。

7.  编写测试类

新建一个类HibernateTest，相关信息如下：

编写代码如下：

package edu.test.test;

import java.util.List;

import org.hibernate.Query;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.Transaction;

import org.hibernate.cfg.Configuration;

import edu.test.entity.User;

public
class HibernateTest {

public
staticintid=1;

public
staticvoidmain(String[]
args){

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

SessionFactory sf=cfg.buildSessionFactory();

Session session=sf.openSession();

Transaction ts=session.beginTransaction();

User user=new User( );

user.setId(id);

user.setName("test"+id);

user.setPassword("123456");

user.setType("学生");

session.save(user);

ts.commit( );

Query query=session.createQuery("from User");

List list=query.list();

User user2=(User)list.get(0);

System.out.println("用户标识："+user2.getId());

System.out.println("用户名："+user2.getName());

System.out.println("用户密码："+user2.getPassword());

System.out.println("用户类型："+user2.getType());

session.close( );

id++;

}

}

测试结果为：

用户标识：1

用户名：test1

用户密码：123456

用户类型：学生

从上面可以看出我们使用Hibernate进行持久化操作已经成功啦！