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进行操作，具体的安装步骤将不再给出，可以参照http://blog.csdn.net/digyso888/article/details/3552981文章进行配置。

打开命令提示符，连接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的实现方式，在此一样恭祝大家学习愉快。

行走木马

发布了23 篇原创文章 · 获赞 12 · 访问量 13万+

私信关注

struts-2.3.1+spring-framework-3.2.2+hibernate-4.1.1整合历程(详解)

使用c#强大的表达式树实现对象的深克隆之解决循环引用的问题

free AI online tools All In One

痞子衡嵌入式：恩智浦i.MX RT1xxx系列MCU启动那些事（12.A）- uSDHC eMMC启动时间(RT1170)

linux安装cuda和cudnn

Mellanox网卡开启SR-IOV

模拟手机设备：使用 Playwright 实现移动端自动化测试

HTML 00 Tutorial

全面系统的AI学习路径，帮助普通人也能玩转AI

从零开始：使用 Playwright 脚本录制实现自动化测试

uni-app实现上拉加载

一起學Maven(eclipse項目構建)

Java實現的AES加解密程序

JDBC的項目開發實例

一起學Maven(初識Maven)

一起學Maven(Maven中的生命週期與插件機制)

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結