struts-2.3.1+spring-framework-3.2.2+hibernate-4.1.1整合历程<第二部分>(详解)

第一部分讲解了Struts2的建立过程，这部分将在其基础上完成Hibernate的整合。

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用。

步骤一：解压hibernate-release-4.1.1.Final.zip，然后到hibernate-release-4.1.1.Final\lib\required文件夹下将所有的jar包拷贝到项目所在的lib文件夹下，效果图如图1所示：



图1
其中相应的jar包以及作用如下所示:

jar包(.jar)	作用
antlr-2.7.7	语言转换工具，hibernate利用它实现HQL到SQL的转换
dom4j-1.6.1	对dom4j的封装，解析xml文件
hibernate-commons-annotations-4.0.1.Final	常见的反射代码用于支持注解处理
hibernate-core-4.1.1.Final	Hibernate的核心代码
hibernate-jpa-2.0-api-1.0.1.Final	用来定义Hibernate持久性
javassist-3.15.0-GA	一个开源的分析、编辑和创建Java字节码的类库
jboss-logging-3.1.0.GA	Jboss的日志框架
jboss-transaction-api_1.1_spec-1.0.0.Final	Jboss事务处理

其中的javassist-3.15.0-GA与Struts2中javassist-3.11.0-GA冲突，可以将低版本删除（这里不删除本文的搭建也没有异常抛出，但建议删除低版本的jar包）

步骤二：拷贝hibernate-release-4.1.1.Final\project\etc文件夹下hibernate.cfg.xml文件到项目src目录下，然后进行更改，具体的项目结构如图2所示：



图2
对配置文件hibernate.cfg.xml进行更改，如下所示：
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-configuration>
<session-factory>
<!-- mysql连接驱动，需要导入mysql驱动jar包 -->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<!-- mysql数据库连接地址 -->
<property name="connection.url">jdbc:mysql://localhost/steven</property>
<!-- 数据库用户名 -->
<property name="connection.username">root</property>
<!-- 数据库密码 -->
<property name="connection.password">mysqladmin</property>
<!-- 数据库方言 -->
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- 显示sql语句 -->
<property name="show_sql">true</property>
<!-- 格式化sql语句 -->
<property name="format_sql">true</property>

<!-- 加载hibernate自动更新数据库结构 -->
<property name="hbm2ddl.auto">update</property>

<!-- 映射实体类 -->
<mapping class="com.steven.entity.User" />
</session-factory>
</hibernate-configuration>

在这个过程中将用到数据库，本文采用Mysql5.0进行操作，具体的安装步骤将不再给出，可以参照/article/10411858.html文章进行配置。

打开命令提示符，连接Mysql，创建数据库steven，如图3所示：



图3
注：本文Hibernate映射采用全注解方式使用，首先，注解方式简单，灵活，简洁，其次在开发中在有源代码的情况下使用较多，建议使用注解方式。

由于在hibernate.cfg.xml配置文件中已经配置映射实体类User.java，下面给出添加注解后的实体类
User.java

package com.steven.entity;

import java.util.Date;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

/**
* 实体类
*
* @author Steven
*
*/
// 标示这个类为映射实体类
@Entity
// 改变数据库中映射表的名称，不加默认表名称为类名即User
@Table(name = "t_user")
public class User {
// 用户Id
private int userId;
// 用户名
private String userName;
// 用户年龄
private int age;
// 用户生日
private Date birthday;
// 用户是否是会员 true:是 false:不是
private boolean isVip;

public User() {
}

// 有参构造
public User(String userName, int age, Date birthday, boolean isVip) {
this.userName = userName;
this.age = age;
this.birthday = birthday;
this.isVip = isVip;
}

// 标识此字段为数据库中的主键
@Id
// 标识此字段为数据库中成序列增长的列，不同的数据库，Hibernate会自动匹配
@GeneratedValue
public int getUserId() {
return userId;
}

public void setUserId(int userId) {
this.userId = userId;
}

public String getUserName() {
return userName;
}

public void setUserName(String userName) {
this.userName = userName;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public Date getBirthday() {
return birthday;
}

public void setBirthday(Date birthday) {
this.birthday = birthday;
}

public boolean getIsVip() {
return isVip;
}

public void setIsVip(boolean isVip) {
this.isVip = isVip;
}

@Override
public String toString() {
return "用户信息： [年龄是" + this.getAge() + ", 生日是" + this.getBirthday()
+ ", 用户编号是" + this.getUserId() + ", 用户名是" + userName
+ isVip(this.getIsVip()) + "]";
}

/**
* 用来进行测试使用
*
* @param isVip
* @return
*/
public String isVip(boolean isVip) {
return ", " + (isVip == true ? "是" : "不是") + "会员";
}

}

然后建立测试类，首先建立一个Source Folder，用来存放所有的测试代码，点击项目名称，右键New—>Source Folder,如图4所示：



图4
点击Finish，完成创建，然后，创建包com.steven.test，创建后的目录结构如图5所示：



图5
下面将创建JUnit Test Case，点击包名com.steven.test，右键New->Other，弹出New选项窗口，选择JUnit
Test Case，如图6所示：



图6
点击Next进入下一步，然后如图7所示进行选择和填写,



图7
点击Finish，弹出如图8所示的窗口，点击OK完成创建，



图8
此时项目结构图如图9所示：



图9
打开HibernateTest.java,然后更改代码如下所示：
HibernateTest.java

package com.steven.test;

import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.Test;

/**
* Hibernate测试类
*
* @author Steven
*
*/
public class HibernateTest {
// JUnit注解，可以通过此进行测试
@Test
/**
* 测试1，自动创建数据表，因为在配置文件Hibernate.cfg.xml中配置了<property name="hbm2ddl.auto">update</property>
*/
public void testSchemaExport() {
new SchemaExport(new Configuration().configure()).create(true, true);
}
}

接着进行测试，选中要测试的方法，右击Run As->JUnit Test,此时控制台会发现出现异常信息，

ERROR: HHH000231: Schema export unsuccessful
org.hibernate.HibernateException: Specified JDBC Driver com.mysql.jdbc.Driver class not found
at org.hibernate.service.jdbc.connections.internal.DriverManagerConnectionProviderImpl.configure(DriverManagerConnectionProviderImpl.java:104)
at org.hibernate.service.internal.StandardServiceRegistryImpl.configureService(StandardServiceRegistryImpl.java:75)
at org.hibernate.service.internal.AbstractServiceRegistryImpl.initializeService(AbstractServiceRegistryImpl.java:159)
at org.hibernate.service.internal.AbstractServiceRegistryImpl.getService(AbstractServiceRegistryImpl.java:131)
at org.hibernate.tool.hbm2ddl.ManagedProviderConnectionHelper.prepare(ManagedProviderConnectionHelper.java:55)
at org.hibernate.tool.hbm2ddl.DatabaseExporter.<init>(DatabaseExporter.java:52)
at org.hibernate.tool.hbm2ddl.SchemaExport.execute(SchemaExport.java:368)
at org.hibernate.tool.hbm2ddl.SchemaExport.create(SchemaExport.java:305)
at org.hibernate.tool.hbm2ddl.SchemaExport.create(SchemaExport.java:294)
at com.steven.test.HibernateTest.testSchemaExport(HibernateTest.java:20)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:597)
at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44)
at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41)
at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)
at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28)
at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:73)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:46)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:180)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:41)
at org.junit.runners.ParentRunner$1.evaluate(ParentRunner.java:173)
at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28)
at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31)
at org.junit.runners.ParentRunner.run(ParentRunner.java:220)
at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:46)
at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)
Caused by: java.lang.ClassNotFoundException: com.mysql.jdbc.Driver
at java.net.URLClassLoader$1.run(URLClassLoader.java:200)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:188)
at java.lang.ClassLoader.loadClass(ClassLoader.java:307)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301)
at java.lang.ClassLoader.loadClass(ClassLoader.java:252)
at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:320)
at java.lang.Class.forName0(Native Method)
at java.lang.Class.forName(Class.java:169)
at org.hibernate.internal.util.ReflectHelper.classForName(ReflectHelper.java:192)
at org.hibernate.service.jdbc.connections.internal.DriverManagerConnectionProviderImpl.configure(DriverManagerConnectionProviderImpl.java:101)
... 33 more
2013-12-10 19:26:52 org.hibernate.tool.hbm2ddl.SchemaExport execute
INFO: HHH000230: Schema export complete

Specified JDBC Driver com.mysql.jdbc.Driver class not found, 原因是因为没有导入Mysql的驱动包，此时需要加入mysql-connector-java-5.1.7-bin.jar（http://pan.baidu.com/s/1efRMV）到lib下，此时再次执行测试方法，会发现控制台出现以下信息

…………………………………………………………
INFO: HHH000046: Connection properties: {user=root, password=****}

drop table if exists t_user

create table t_user (
userId integer not null auto_increment,
age integer not null,
birthday datetime,
isVip boolean not null,
userName varchar(255),
primary key (userId)
)
2013-12-10 19:37:59 org.hibernate.service.jdbc.connections.internal.DriverManagerConnectionProviderImpl stop
INFO: HHH000030: Cleaning up connection pool [jdbc:mysql://localhost/steven]
2013-12-10 19:37:59 org.hibernate.tool.hbm2ddl.SchemaExport execute
INFO: HHH000230: Schema export complete

在观察数据库，会发现数据表t_user已经被创建，如图10所示：



图10
数据表t_user已经创建，并且所有的字段，类型，包括主键和序列增长都已经被创建，这就是Hibernate带来的好处，但是很多类型都是Hibernate默认创建的，如果想自己定义也是可以通过注解的方式更改，在此没有给出，有兴趣的可以参照其他博文进行学习。
注：在开发过程中是先写实体类还是先建表，面向对象标准开发流程推荐第一种方法，但实际开发中大部分是第二种，主要是因为在表里设置外键比在类里写关联属性要简单，使得不熟悉Hibernate的人用第二种也可以轻松的建立好mapping，而且更加灵活的创建表结构。
此时就可以测试数据库的增删改查的方法了，为了方便测试，可以为Hibernate封装一个Util类(这个类可以在Hibernate的参考文档中找到)，专门用来对Session的获取(也就相当于JDBC中连接的概念)，此时项目结构如图11所示：



图11
HibernateUtil.java内容如下：

package com.steven.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;

/**
* 创建Hibernate工具类
*
* @author Steven
*
*/
public class HibernateUtil {
// Session 工厂
private static SessionFactory factory;

static {
Configuration cfg = new Configuration().configure();
ServiceRegistry sr = new ServiceRegistryBuilder().applySettings(
cfg.getProperties()).buildServiceRegistry();
factory = cfg.buildSessionFactory(sr);
// 已经过时(主要出现在Hibernate3.x版本)
// factory = new
// AnnotationConfiguration().configure().buildSessionFactory();
}

public static SessionFactory getSessionFactory() {
return factory;
}

public static Session getSession() {
return factory.openSession();
}

public static void closeSession(Session session) {
if (session != null) {
if (session.isOpen()) {
session.close();
}
}
}
}

此时进行创建表数据的测试，在HibernateTest.java中添加如下代码：

@Test
/**
* 测试2，用来测试创建表数据
*/
public void testCreate() {
User u1 = new User("Steven", 1, new Date(), true);
Session session = HibernateUtil.getSession();
session.beginTransaction();
session.save(u1);
session.getTransaction().commit();
HibernateUtil.closeSession(session);
}

然后一样进行JUnit测试，运行后控制台输出信息：

Hibernate:
insert
into
t_user
(age, birthday, isVip, userName)
values
(?, ?, ?, ?)

在查看数据库，发现增加了一条数据，如图12所示：



图12

这样可以确定Hibernate整合已经没有问题了，下面就可以进行具体的Hibernate对数据库增删改查操作的封装，因为在开发过程中会有着很多不同的项目结构层次，但为了便于学习，一般情况下可以分为entity(实体类层)，dao(数据访问对象层)，service(业务层，主要可以通过Spring进行事物处理（稍后讲解）),action(执行层)，有时候用到的工具包可以放在util包下，这样就可以基本架构整个项目的层次，比如在有些时候可以用到dto(数据传输对象层)，都是很常见的，所以开发过程中需要具体问题具体分析，本文不需要那么复杂，仅仅在于搭建框架，可以让初学者迅速掌握搭建框架中的流程以及注意事项就可以了，以后的深入讨论，我会有其他的博文讲解，下面继续进行框架的搭建。
具体的架构呈现会在整合Spring时候完全给出，暂时的架构如图13所示：



图13
此时具体的类的内容如下：
IBaseDao.java

package com.steven.dao.iface;

import java.util.List;

/**
* 将常用的数据库增删改查进行封装
*
* @author Steven
*
* @param <T>
*/
public interface IBaseDao<T> {
/**
* 保存对象
*
* @param t
* @return
*/
public void insert(T t);

/**
* 删除对象
*
* @param t
* @return
*/
public void delete(T t);

/**
* 更新对象
*
* @param t
* @return
*/
public void update(T t);

/**
* 根据Id查找单个对象
*
* @param id
* @return
*/
public T getById(int id);

/**
* 查询对象集合
*
* @return
*/
public List<T> getAll();
}

IUserDao.java

package com.steven.dao.iface;

import com.steven.entity.User;

/**
* 用来继承接口，如果有个别自己的方法可以在此进行添加
*
* @author Steven
*
*/
public interface IUserDao extends IBaseDao<User> {

}

UserDao.java

package com.steven.dao.impl;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;

import com.steven.dao.iface.IUserDao;
import com.steven.entity.User;
import com.steven.util.HibernateUtil;

/**
* 主要对方法进行编写，在这里主要实现了增加和查询所有的方法，其他的没有实现，在整合Spring过程中会进行再次的封装，到时候会编写所有的方法
*
* @author Steven
*
*/

public class UserDao implements IUserDao {

public void delete(User t) {
// TODO Auto-generated method stub

}

@SuppressWarnings("unchecked")
public List<User> getAll() {
Session sesson = HibernateUtil.getSession();
// 由于Hibernate4已经没有了HibernateSupport和HibernateTemplate这两个辅助类，可以通过以下实现，
Query query = sesson.createQuery("from User");
return (List<User>) query.list();
}

public User getById(int id) {
// TODO Auto-generated method stub
return null;
}

public void insert(User t) {
Session session = HibernateUtil.getSession();
session.beginTransaction();
session.save(t);
session.getTransaction().commit();
HibernateUtil.closeSession(session);
}

public void update(User t) {
// TODO Auto-generated method stub

}

}

此时可以将UserAction.java更改成如下代码：

UserAction.java

package com.steven.action;

import java.util.Date;
import java.util.List;
import java.util.Map;

import org.apache.struts2.interceptor.RequestAware;

import com.opensymphony.xwork2.ActionSupport;
import com.steven.dao.impl.UserDao;
import com.steven.entity.User;

/**
* 通过继承ActionSupport获得Struts2的已有功能，
* 通过实现RequestAware获取request(这种方式常用，还有其他三种方式，这里不再赘述)
* 四种获取request方式请参照http://blog.csdn.net/ms2146/article/details/5406004
*
* @author Steven
*
*/
public class UserAction extends ActionSupport implements RequestAware {
private static final long serialVersionUID = 1L;
private Map<String, Object> request;
private UserDao userDao = new UserDao();

@Override
public String execute() throws Exception {
userDao.insert(new User("Lily", 1, new Date(), false));
userDao.insert(new User("Tom", 1, new Date(), false));
// 创建一个用户集合
List<User> userList = userDao.getAll();
// 创建用户并添加到用户集合中
// userList.add(new User("Steven", 1, new Date(), true));
// userList.add(new User("Lily", 1, new Date(), false));
// userList.add(new User("Tom", 1, new Date(), false));

// 将用户存储到ActionContext中(可以通过ognl表达式获取)
request.put("userList", userList);
return SUCCESS;
}

public void setRequest(Map<String, Object> request) {
this.request = request;
}

}

此时在启动Tomcat，在浏览器输入http://localhost:8080/SSH,如图14所示:



图14
运行结果如图15所示：



图15
此时控制台输出信息如下所示：

…………………………………………
Hibernate:
insert
into
t_user
(age, birthday, isVip, userName)
values
(?, ?, ?, ?)
Hibernate:
insert
into
t_user
(age, birthday, isVip, userName)
values
(?, ?, ?, ?)
Hibernate:
select
user0_.userId as userId0_,
user0_.age as age0_,
user0_.birthday as birthday0_,
user0_.isVip as isVip0_,
user0_.userName as userName0_
from
t_user user0_

因此可以看出所有的操作都是通过Hibernate操作数据库的，然后通过Struts将获得的用户集合显示到页面中，所以在这个过程中，Hibernate起到的作用仅仅是对数据库的操作，而且Hibernate可以不要依靠Tomcat运行就可以使用，而Struts2主要负责接收处理数据，进行操作后然后返回到页面中呈现，典型的MVC，而且Struts依靠Tomcat的运行。

如图16所示，可以查看到数据库中的数据：



图16
注：在此，Struts2和Hibernate的简单整合已经实现，下面将进行Spring的整合，而Spring又是SSH中用到的最多而且最重要的框架之一，所以在Spring整合中我将重点讲解器IOC，AOP所代表的含义，具体的会通过例子讲解，当然到时候层次架构会发生改变，而且Dao实现会完成企业级应用的封装，到时候会改变Dao的实现方式，在此一样恭祝大家学习愉快。