SSH框架网上商城项目第1战之整合Struts2、Hibernate4.3和Spring4.2

本文开始做一个网上商城的项目,首先从搭建环境开始,一步步整合S2SH。这篇博文主要总结一下如何整合Struts2、Hibernate4.3和Spring4.2。

整合三大框架得先从搭建各部分环境开始,也就是说首先得把Spring,Hibernate和Struts2的环境搭建好,确保它们没有问题了,再做整合。这篇博文遵从的顺序是:先搭建Spring环境-->然后搭建Hibernate环境--> 整合Spring和Hibernate --> 搭建Struts2环境 --> 整合Spring和Struts2。

1. 整个项目jar包的管理

Spring的jar包很多,开发的时候建议将它们分个类,然后依次添加到User Library,方便管理,也一目了然。这里我总结一下整个SSH所需要的基本jar包,看下图:

从图中可以看出,首先将Spring的jar分为四类:spring-4.2.4-core、spring-4.2.4-aop、spring-4.2.4-persistence以及spring-4.2.4-web。将spring的核心包都放到core中,与aop相关的都放到aop中,与持久化(与Hibernate整合)相关的放到persistence中,与web(与struts2整合)相关的放到web中。每个部分都有哪些jar包呢?请看下面的截图:

注:以上每个分类的包中,并非包含原来包中所有的jar,有些jar文件并没有用到,等具体项目需要的时候再往里加就行了,上图是保证项目的环境可以搭建所需要的的最基本的jar包。

2.搭建Spring环境

上面的jar包截图是最后整合好的所有jar包,刚开始搭建环境的时候不需要一次性全部加进来,可以一点一点的加,这样也更利于理解每个部分的jar包都有什么作用,当然,一次都加进来也是可以的。

2.1 添加配置文件beans.xml和相应的jar包

新建一个工程,然后添加在User Library中添加自己的库,这里主要添加两个,即spring-4.2.4-core和spring4.2.4-aop,添加jar包不再赘述。添加完了后,在src目录下添加beans.xml文件,这个文件的模板网上很多,Spring自带的例子里也有,考一份过来就行,见下图:

2.2 测试Spring的IoC环境

我们写一个普通的java类java.util.Date类来测试一下Spring IoC是否正常,如果在测试程序中能正常注入,则说明Spring的IoC环境搭建成功,下面我们写一个测试用例:

/**
 * @Description TODO(采用Spring的注解调试,仅仅支持Spring3.1及以上)
 * @author Ni Shengwu
 *
 */
/*
 * Spring3.1后多了个spring-test-4.2.4.RELEASE.jar包,这个jar包专门用来支持JUnit基于注解的测试的,该jar包在spring-4.2.4-core中
 * 该jar包里有个SpringJUnit4ClassRunner.class,用@RunWith注解加进来即可
 *
 * 注解@ContextConfiguration表示将ApplicationContext对象注入进来,就不用像以往那样在测试程序里先new了,直接使用
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:beans.xml")
public class SSHTest { 

 @Resource
 private Date date; 

 @Test //测试Spring IOC的开发环境
 public void springIoc() {
 System.out.println(date);
 }
}

最后能正常输出:Thu Apr 28 22:45:13 CST 2016。说明Date对象已经被Spring给注入进来了,从而验证了Spring IoC功能正常,为此,Spring的环境搭建完成。

3. 搭建Hibernate环境

Hibernate的环境搭建相比于Spring要复杂一些,因为用到了MyEclipse中的逆向工程。我们按以下步骤来搭建Hibernate开发环境:

3.1 添加相应的jar包

这里主要是向User Library中添加两项jar包:hibernate4.3.11和MySQL驱动包mysql-connector-java-5.1.26,不再赘述。

3.2 新建数据库和表

drop database if exists shop;
create database shop default character set utf8;
use shop;
drop table if exists category;
create table category
(
 /* 类别编号,自动增长 */
 id int not null auto_increment,
 /* 类别名称 */
 type varchar(20),
 /* 类别是否为热点类别,热点类别才有可能显示在首页*/
 hot bool default false,
 /* 设置类别编号为主键*/
 primary key (id)
);

3.3 DB浏览器连接到Mysql数据库

DB浏览器指的是MyEclipse中的一个视图窗口,可以很直观的看到MySQL中都有哪些数据库和表,打开DB浏览器的方法:Window->Open Perspective->DB Browser打开DB浏览器工作窗口。如果没有DB Browser,按照下面:Window->Show View->other->输入DB Browser,找到打开即可。

打开后,我们开始连接到MySQL数据库了,在DB Browser窗口的空白处右键->new,就会弹出下面的对话框:

填好后,点击Test Driver测试一下,测试通过表示DataBase connection Driver已经配置好,然后finish即可,这样我们就能在DB浏览器窗口中看到数据库MySQL5.6了,右键打开就能看到数据库中已有的库和表了,如下:

3.4 创建xml映射文件和sessionFactory

sessionFactory是用来创建session的,我们通过如下方式创建:工程名右键->myeclipse->Add Hibernate Capabilities,如果没有Add Hibernate Capabilities,就点击project facets->Install Hibernate Facets,会弹出如下窗口:

下一步,在MyEclipse中添加Hibernate Support,即hibernate.cfg.xml映射文件和sessionFactory。这里主要是给sessionFactory建个包,默认包不行。

下一步,添加驱动,由于我们之前已经配置好了一个驱动了,所以在这里直接选择刚刚配置好的即可。

下一步,由于之前我们已经添加过自己的jar保留,这里不用选择,直接finish。

这样我们就完成了Hibernate配置文件和sessionFactory的创建。下面我们简单看一下MyEclipse创建的sessionFactory里面都有啥:

public class HibernateSessionFactory { 

 private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>(); //sessionFactory中用的是线程池技术
 private static org.hibernate.SessionFactory sessionFactory; //sessionFactory:创建session的工厂 

 private static Configuration configuration = new Configuration();
 private static ServiceRegistry serviceRegistry; 

 static { //类加载时初始化sessionFactory
 try {
 configuration.configure();
 serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties()).buildServiceRegistry();
 sessionFactory = configuration.buildSessionFactory(serviceRegistry); //Hibernate4中创建sessionFactory的方法
 } catch (Exception e) {
 System.err.println("%%%% Error Creating SessionFactory %%%%");
 e.printStackTrace();
 }
 }
 private HibernateSessionFactory() { //私有构造方法阻止new出对象,保证sessionFactory的单例
 } 

 public static Session getSession() throws HibernateException {
 Session session = (Session) threadLocal.get(); //从线程池中拿session 

 if (session == null || !session.isOpen()) { //如果线程池是空的,或者session打开失败
 if (sessionFactory == null) {
 rebuildSessionFactory(); //如果sessionFactory是空的,那就再创建一次,和static部分一样的
 }
 session = (sessionFactory != null) ? sessionFactory.openSession() : null; //sessionFactory不为空就创建一个session
 threadLocal.set(session); //然后把这个session放到线程池中,下次再拿
 } 

 return session;
 } 

 public static void rebuildSessionFactory() {
 try {
 configuration.configure();
 serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties()).buildServiceRegistry();
 sessionFactory = configuration.buildSessionFactory(serviceRegistry);
 } catch (Exception e) {
 System.err.println("%%%% Error Creating SessionFactory %%%%");
 e.printStackTrace();
 }
 } 

 public static void closeSession() throws HibernateException {
 Session session = (Session) threadLocal.get();
 threadLocal.set(null); 

 if (session != null) {
 session.close();
 }
 } 

 public static org.hibernate.SessionFactory getSessionFactory() {//提供一个公共接口让外界获得这个单例sessionFactory
 return sessionFactory;
 } 

 public static Configuration getConfiguration() {
 return configuration;
 } 

} 

从创建的HibernateSessionFactory中可以看出,主要用到了单例模式和线程池技术。也不难理解。

3.5 通过逆向工程生成model、orm映射文件

下面开始使用逆向工程创建实例对象了,也就是数据库的表对应的model。在DB Browsera窗口右击我们刚刚创建的表shop,选择Hibernate Reverse Engineering开始创建:

创建的时候有两种方式,基于配置文件的和基于注解的,具体的看开发人员心情了,可以选择:

然后下一步,选择一下native主键自增方式,然后便完成了逆向工程创建model和orm映射了。

完成后,会有Category的model生成,同时在hibernate.cfg.xml文件中也会生成相应的映射,前面基于配置文件的和基于注解的在hibernate.cfg.xml中生成的映射时不同的。

3.6 测试Hibernate持久化数据库

因为这里还没有与Spring整合,只是单纯的搭建Hibernate开发环境,所以我们没有必要使用注解,我们通过直接new一个service的方式执行数据入库。

先写CategoryService接口和实现类:

public interface CategoryService {
 public void save(Category category); //用来测试Hibernate环境
} 

public class CategoryServiceImpl implements CategoryService { 

 @Override //没有和Spring整合的情况
 public void save(Category category) {
 //通过刚刚生成的sessionFactory获取session
 Session session = HibernateSessionFactory.getSession();
 try {
 //手动事务
 session.getTransaction().begin();
 //执行业务逻辑
 session.save(category);
 //手动提交
 session.getTransaction().commit();
 } catch(Exception e) {
 session.getTransaction().rollback();
 throw new RuntimeException(e);
 } finally {
 HibernateSessionFactory.closeSession();
 }
 }
}

下面在刚刚的测试用例中添加对Hibernate的测试:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:beans.xml")
public class SSHTest { 

 @Resource
 private Date date; 

 @Test //测试Spring IOC的开发环境
 public void springIoc() {
 System.out.println(date);
 } 

 @Test //测试Hibernate的开发环境,因为没有整合,可以直接new
 public void hihernate() {
 CategoryService categoryService = new CategoryServiceImpl();
 Category category = new Category("男士休闲", true);
 categoryService.save(category);
 }
}

我们查看数据库,发现多了刚刚插入的这项,说明Hibernate环境没有问题。至此,Hibernate的开发环境我们就搭建好了。

4. 整合Spring和Hibernate

搭建好了Spring和Hibernate的开发环境后,我们开始整合这两者。整合Spring和Hibernate后就可以使用AOP让Spring来管理Hibernate的事务了。整合Spring和Hibernate主要从两大方面入手,一是导入必要的jar包,二是配置beans.xml文件。下面我们一步步整合Spring和Hibernate。

4.1 导入相应的jar包

整合Spring和Hibernate时需要导入的jar包有两大块,spring4.2.4-persistence和c3p0-0.9.5.1,每一块jar包中的具体jar文件请参见上面的截图,这里不再赘述。下面开始配置beans.xml文件了。

4.2 配置数据源dataSource

首先配置一下dataSource,然后hibernate.cfg.xml中相应的部分可以干掉了。因为在Spring中配置好了,Spring会去初始化这个dataSource,也就是说这就交给Spring来完成了,hibernate.cfg.xml中的相应部分可以删掉了。如下:

<!-- com.mchange.v2.c3p0.ComboPooledDataSource类在c3p0-0.9.5.1.jar包的com.mchange.v2.c3p0包中 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
 <property name="driverClass" value="com.mysql.jdbc.Driver" />
 <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/shop" />
 <property name="user" value="root" />
 <property name="password" value="root" />
</bean> 

hibernate.cfg.xml中需要干掉的部分:

4.3 配置sessionFactory

配置sessionFactory是用来产生一个session的,另外HibernateTemplate也可以,但是这里采用sessionFactory而不用HibernateTemplate,是因为HibernateTemplate是Spring提供的,依赖于Spring,如果哪天不用Spring了,就会报错。而sessionFactory是Hibernate提供的,没有问题。HibernateTemplate的依赖性太强了。下面看一下具体配置:

<!-- org.springframework.orm.hibernate4.LocalSessionFactoryBean类在spring-orm-4.2.4.RELEASE.jar包的org.springframework.orm.hibernate4包中 -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
 <property name="dataSource" ref="dataSource" />
 <property name="configLocation" value="classpath:hibernate.cfg.xml" /> <!-- 加载hibernate配置文件 -->
</bean>

sessionFactory中的dataSource我们用刚刚配好的dataSource,用ref属性引用进来即可,configLocation我们不在这配了,直接加载hibernate.cfg.xml文件,使用hibernate配置文件中的配置,更加简洁方便。

4.4 配置事务管理器

配置事务管理器,是用来管理sessionFactory的,这样所有的由sessionFactory产生的session将会有声明式的管理。配置如下:

<!-- org.springframework.orm.hibernate4.HibernateTransactionManager类spring-orm-4.2.4.RELEASE.jar包的org.springframework.orm.hibernate4包中 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
 <property name="sessionFactory" ref="sessionFactory" />
</bean>

同样,sessionFactory我们用刚刚配置好的sessionFactory,用ref属性引用进来即可。到这里就会发现,从上面一直配下来,都是一连串的操作,一个个引用下来。

4.5 配置advice(通知)

配置advice的目的是指定哪些方法需要什么类型的事务模式。看配置:

<tx:advice id="advice" transaction-manager="transactionManager">
 <tx:attributes>
 <tx:method name="save*" propagation="REQUIRED"/>
 <tx:method name="update*" propagation="REQUIRED"/>
 <tx:method name="delete*" propagation="REQUIRED"/>
 <tx:method name="*" propagation="SUPPORTS"/>
 </tx:attributes>
</tx:advice>

REQUIRED表示如果存在事务,则支持当前的事务,如果没有则创建一个新的事务,这个事务模式应用在所有以save、update和delete开头的方法上,也就是说对数据库的增删改的时候需要添加事务支持。SUPPORTS表示如果存在事务,则支持当前的事务,如果没有就算了。

4.6 配置AOP切面

<aop:config>
 <!-- 配置哪些包的类要切入事务 -->
 <aop:pointcut id="pointcut" expression="execution(* cn.it.shop.service.impl.*.*(..))" />
 <aop:advisor advice-ref="advice" pointcut-ref="pointcut"/><!-- 连接了<span style="font-family:Microsoft YaHei;">上</span>面的advice和上面的pointcut -->
 <!-- aop:pointcut要写在aop:advisor上面,否则会报错 -->
 </aop:config>

AOP即面向切面编程,aop:pointcut定义一个切面,expression属性中配置的意思是所有cn.it.shop.service.impl包下的所有方法,不管返回值和参数是什么,都要切入事务。该包是属于dao层的,直接操作数据库的。aop:advice将通知和切面结合起来,我们直接使用上面配置好的advice和pointcut,将其引入进来即可。这样配置好了后,意思就是说,凡是cn.it.shop.service.impl包下的方法都需要切入事务管理,具体地,以save、update、delete开头的方法使用REQUIED方式,其他方法使用SUPPORTS方式。这样就很好理解这个配置的意思了。
4.7 测试整合结果
        之前搭建Hibernate环境的时候,我们测试是直接new了一个Service来操作数据库,因为当时还没有和Spring整合。现在通过配置beans.xml后,让Spring去管理Hibernate的事务了,所以现在的测试要把Service交给Spring管理,通过Spring注入进来,并且依赖sessionFactory,如果能插入数据到数据库,则说明声明事务OK。
        首先,我们要在Spring的配置文件beans.xml中配一下这个Service:

代码如下:

<bean id="categoryService" class="cn.it.shop.service.impl.CategoryServiceImpl"> 
    <property name="sessionFactory" ref="sessionFactory" /><!-- 依赖的sessionFactory用我们之前配好的sessionFactory--> 
</bean>

其次,我们需要在CategoryService接口和它的实现类CategoryServiceImpl中增加一个方法用来测试整合后的情况:

public interface CategoryService {
 public void save(Category category); //用来测试Hibernate环境
 public void update(Category category); //用来测试Spring和Hibernate整合后
} 

public class CategoryServiceImpl implements CategoryService { 

 @Override //没有和Spring整合的情况
 public void save(Category category) {
 //通过工具类获取session
 Session session = HibernateSessionFactory.getSession();
 try {
 //手动事务
 session.getTransaction().begin();
 //执行业务逻辑
 session.save(category);
 //手动提交
 session.getTransaction().commit();
 } catch(Exception e) {
 session.getTransaction().rollback();
 throw new RuntimeException(e);
 } finally {
 HibernateSessionFactory.closeSession();
 } 

 }
 /*Spring和Hibernate整个后*/
 private SessionFactory sessionFactory; //定义一个sessionFactory 

 //当需要使用sessoinFactory的时候,Spring会将sessionFactory注入进来
 public void setSessionFactory(SessionFactory sessionFactory) {
 this.sessionFactory = sessionFactory;
 }
 protected Session getSession() {
 //从当前线程获取session,如果没有则创建一个新的session
 return sessionFactory.getCurrentSession();
 } 

 @Override //Spring和Hibernate整合后的情况
 public void update(Category category) {
 getSession().update(category);
 }
}

现在我们可以去测试类中增添测试方法,来测试Spring和Hibernate整合后的结果了:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:beans.xml")
public class SSHTest { 

 @Resource
 private Date date; 

 @Resource
 private CategoryService categoryService; 

 @Test //测试Spring IOC的开发环境
 public void springIoc() {
 System.out.println(date);
 } 

 @Test //测试Hibernate的开发环境,因为没有整合,可以直接new
 public void hihernate() {
 CategoryService categoryService = new CategoryServiceImpl();
 Category category = new Category("男士休闲", true);
 categoryService.save(category);
 } 

 @Test //测试Hibernate和Spring整合后
 public void hibernateAndSpring() {
 categoryService.update(new Category(1, "休闲女式", true)); //categoryService通过Spring从上面注入进来的
 }
}

然后我们查看数据库,发现id=1的category被修改成了休闲女式了,说明更新成功。至此,Spring和Hibernate整合成功。

5. 搭建Struts2环境
5.1 添加相应的配置和jar包
        struts2运行所需的jar包我放在struts2.3.41的Library中了,直接引入即可,不再赘述。另外,还要对web.xml文件进行配置,配置如下:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
 <display-name>E_shop</display-name>
 <welcome-file-list>
 <welcome-file>index.jsp</welcome-file>
 </welcome-file-list> 

 <filter>
 <filter-name>struts2</filter-name>
 <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
 </filter> 

 <filter-mapping>
 <filter-name>struts2</filter-name>
 <url-pattern>*.action</url-pattern>
 </filter-mapping> 

</web-app>

如上,我们配置了一个StrutsPrepareAndExecuteFilter过滤器,并将过滤器的url-pattern设置为*.action,即所有.action后缀的都会首先经过这个过滤器,这也是struts2的入口处。
5.2 创建Action并且配置到struts.xml文件中
        我们创建一个Action如下:

public class CategoryAction extends ActionSupport {
 private CategoryService categoryService; //设置categoryService是为了很直观的看出与Spring整合前后的不同 

 public void setCategoryService(CategoryService categoryService) {
 this.categoryService = categoryService;
 } 

 public String update() {
 System.out.println("----update----");
 System.out.println(categoryService); //整合前后输出不同
 return "index";
 } 

 public String save() {
 System.out.println("----save----");
 System.out.println(categoryService);//整合前后输出不同
 return "index";
 }
}

然后我们配置struts.xml文件,该文件放在src目录下:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
 "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
 "http://struts.apache.org/dtds/struts-2.3.dtd"> 

<struts>
 <package name="shop" extends="struts-default">
 <!-- category_update.actiocan: 访问update方法 -->
 <action name="category_*" class="cn.it.shop.action.CategoryAction" method="{1}">
 <result name="index">/index.jsp</result>
 </action>
 </package> 

</struts>

5.3 测试Struts2环境
       测试方法是:写一个jsp访问Action,如果Action可以创建,则表示struts2环境OK。即struts2的一连串流程可以正常走完:jsp-->struts.xml-->Action-->struts.xml-->jsp,这样struts2的环境就算搭好了。我们写一个简单的index.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> 

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
 <head>
 <title>My JSP 'index.jsp' starting page</title>
 </head> 

 <body>
 <!-- 下面两种写法都可以访问 --></span>
 <a href="${pageContext.request.contextPath }/category_update.action">访问update</a>
 <a href="category_save.action">访问save</a>
 </body>
</html>

然后我们部署以下工程,打开tomcat服务器,在浏览器中输入:http://localhost:8080/E_shop/index.jsp后,能出现正常jsp页面,然后点击两个按钮,仍然跳转到index.jsp,然后我们看一下控制台的输出信息:
----update---- 
null 
----save---- 
null

说明struts2的一条线走完了,环境没有问题,至此,struts2开发环境搭建完毕。
        我们看控制台输出了null,也就是说categoryService是空,也就是说根本没拿到categoryService,因为我们没有和Spring进行整合,没有被注入进来,所以null是正常的。我们沿着控制台输出的信息往上翻,会发现一条信息:Choosing bean (struts) for (com.opensymphony.xwork2.ObjectFactory)。括号里是struts说明没有和Spring整合前,Action是有Struts2产生的。

6. Spring和Struts2整合
6.1 添加相应的jar包
        Spring与Struts2整合时的jar包主要在spring4.2.4-web里面,里面包括struts2-spring-plugin-2.3.24.1.jar,导包不再赘述。
6.2 把Action和它的依赖交给Spring管理
        在Spring的配置文件beans.xml中配置Action和它的依赖,我们目前只有一个Action,配置如下所示:

<bean id="date" class="java.util.Date" />
<bean id="categoryAction" class="cn.it.shop.action.CategoryAction" scope="prototype">
 <property name="categoryService" ref="categoryService" /> <!-- 依赖的categoryService用上面和Hibernate整合时配置好的categoryService -->
</bean>

6.3 修改struts.xml中的配置
        原来在struts.xml中,class属性对应的是具体Action的完全限定名,现在将class属性的值改为Spring中配置action的id值,即categoryAction,如下:

<struts>
 <package name="shop" extends="struts-default"> 

 <!-- class对应的是Spring中配置该Action的id值,因为要交给Spring管理 -->
 <action name="category_*" class="categoryAction" method="{1}">
 <result name="index">/index.jsp</result>
 </action>
 </package> 

</struts>

6.4 配置监听器
        在web.xml中配置监听器ContextLoaderListener,这样在服务器启动的时候就可以加载Spring的配置文件了。如下:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
 <display-name>E_shop</display-name>
 <welcome-file-list>
 <welcome-file>index.jsp</welcome-file>
 </welcome-file-list> 

 <filter>
 <filter-name>struts2</filter-name>
 <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
 </filter> 

 <filter-mapping>
 <filter-name>struts2</filter-name>
 <url-pattern>*.action</url-pattern>
 </filter-mapping> 

 <!-- web.xml中监听器的启动优先级要高于过滤器,所以配在下面无所谓的 -->
 <listener>
 <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 </listener> 

 <context-param>
 <param-name>contextConfigLocation</param-name>
 <param-value>classpath:beans.xml</param-value>
 </context-param> 

</web-app>

6.5 测试整合结果
        我们在Action中新加一句更新数据库的语句,如下:

public class CategoryAction extends ActionSupport { 

 private Category category;//设置一个私有成员变量接收url带过来的参数,注意下面要写好get和set方法 

 private CategoryService categoryService; 

 public void setCategoryService(CategoryService categoryService) {
 this.categoryService = categoryService;
 } 

 public String update() {
 System.out.println("----update----");
 System.out.println(categoryService);//由于已经和Spring整合,所以可以拿到这个categoryService了,打印出来就不是null了
 categoryService.update(category); //新加一条语句,来更新数据库
 return "index";
 } 

 public String save() {
 System.out.println("----save----");
 System.out.println(categoryService);
 return "index";
 } 

 public Category getCategory() {
 return category;
 } 

 public void setCategory(Category category) {
 this.category = category;
 }
}

然后我们修改一下index.jsp文件,如下:

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> 

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
 <head>
 <title>My JSP 'index.jsp' starting page</title>
 </head> 

 <body>
 <a href="${pageContext.request.contextPath }/category_update.action?category.id=2&category.type=gga&category.hot=false">访问update</a>
 <a href="category_save.action">访问save</a>
 </body>
</html>

然后我们部署以下工程,打开tomcat服务器,在浏览器中输入:http://localhost:8080/E_shop/index.jsp后,能出现正常jsp页面,然后点击“访问update”按钮,仍然跳转到index.jsp,然后我们看一下控制台的输出信息:

----update----
cn.it.shop.service.impl.CategoryServiceImpl@7c5ecf80
Hibernate: update category set hot=?, type=? where id=?

我们看到可以输出categoryService这个对象的信息了,也可以输出执行update语句时的SQL语句,然后我们查询一下数据库,发现id=2的数据的type被更新为gga,hot更新为false。我们沿着控制台输出的信息往上翻,会发现一条信息:Choosing bean (spring) for (com.opensymphony.xwork2.ObjectFactory),括号里为spring,与上面的情况对比可知,Struts2在与Spring整合后,Action交给了Spring去管理了。
        至此,Struts2、Hibernate4和Spring4整合工作已经全部完成,接下来就可以在SSH环境下进行开发了!

本文介绍的SSH整合中所需要的完整jar包:免费下载

整个项目的源码下载地址:http://www.jb51.net/article/86099.htm

原文地址:http://blog.csdn.net/eson_15/article/details/51277324

(注:到最后提供整个项目的源码下载!欢迎大家收藏或关注)

以上就是本文的全部内容,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • Hibernate+Spring+Struts扩展Struts

    简介: 我看到很多项目中,开发者实现了自己的MVC框架,并不是因为他们想做同Struts根本不同的东西,而是因为他们并没有意识到如何扩展Struts.开发自己的MVC框架可以获得全部的控制权,但是这也意味着需要很多资源来实现它(人力物力),在紧张的日程安排下,有时候这是不可能的. Struts不仅仅是一个强大的框架,同时它也是可扩展的.你可以以三种方式来扩展Struts. 1.PlugIn:如果你想在application startup或shutdown的时候做一些业务逻辑的话,那就创建你自己

  • struts2+spring+hibernate分页代码[比较多]第1/7页

    dao层接口: Java代码 复制代码 代码如下: package com.last999.im.news.dao; import java.util.*; import com.last999.im.news.entity.KindEntity; import com.last999.im.news.web.PageTool; public interface KindEntityDao{ public KindEntity get(String uuid); public void save

  • struts2.3.24+spring4.1.6+hibernate4.3.11+mysql5.5.25开发环境搭建图文教程

    struts2.3.24 + spring4.1.6 + hibernate4.3.11+ mysql5.5.25开发环境搭建及相关说明. 一.目标 1.搭建传统的ssh开发环境,并成功运行(插入.查询) 2.了解c3p0连接池相关配置 3.了解验证hibernate的二级缓存,并验证 4.了解spring事物配置,并验证 5.了解spring的IOC(依赖注入),将struts2的action对象(bean)交给spring管理,自定义bean等...并验证 6.了解spring aop(面向

  • 详解JAVAEE——SSH三大框架整合(spring+struts2+hibernate)

    一.整合原理 二.导包(41个) 1.hibernate (1)hibernate/lib/required (2)hibernate/lib/jpa | java persist api java的持久化规范(接口) (3)数据库驱动 2.struts2 (1)struts-blank.war/WEB-INF/lib/* 注意:javassist-3.18.1-GA.jar包与hibernate中的重复(只保留高版本即可) (2)struts整合spring插件包 注意:这个包一旦导入,那么s

  • Spring集成Struts与Hibernate入门详解

    前言 最近将Spring,Struts,Hiberbate基础已经学习完成.想自己把这三个框架集成一下,然后再写一个后台管理网站练练手.Spring的作用是依赖注入,而Struts是显示层的东西,这两个框架集成后是什么样子.一边学习,一边记录.上车. Spring集成所需jar包 首先,Spring集成Struts,那么applicationContext.xml和struts.xml,web.xml肯定是不能少的.前面两个是Spring和Struts的配置文件,后面一个是整个web的全局配置文

  • Spring,hibernate,struts经典面试笔试题(含答案)

    本文讲述了Spring,hibernate,struts经典面试笔试题及其参考答案.分享给大家供大家参考,具体如下: 1.Hibernate工作原理及为什么要用? 原理: 1.读取并解析配置文件 2.读取并解析映射信息,创建SessionFactory 3.打开Sesssion 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory 为什么要用: ① . 对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代

  • struts+spring+hibernate三个框架的整合

    准备三个框架结合的lib包 Spring3结合Struts2的步骤如下: 1:开启Struts2结合Spring3,在struts.xml中添加如下语句: java代码: <constant name="struts.objectFactory" value="spring"/> 2:在web.xml中添加listener,如下: java代码: <listener> <listener-class> org.springfram

  • SSH框架网上商城项目第1战之整合Struts2、Hibernate4.3和Spring4.2

    本文开始做一个网上商城的项目,首先从搭建环境开始,一步步整合S2SH.这篇博文主要总结一下如何整合Struts2.Hibernate4.3和Spring4.2. 整合三大框架得先从搭建各部分环境开始,也就是说首先得把Spring,Hibernate和Struts2的环境搭建好,确保它们没有问题了,再做整合.这篇博文遵从的顺序是:先搭建Spring环境-->然后搭建Hibernate环境--> 整合Spring和Hibernate --> 搭建Struts2环境 --> 整合Spri

  • SSH框架网上商城项目第7战之整合Struts2和Json

    上篇我们完成了DataGrid显示json数据,但是没有和后台联系在一起,只是单纯地显示了我们自己弄的json数据,这一节我们将json和Struts2整合,打通EasyUI和Struts2之间的交互. 1. json环境的搭建 json环境搭建很简单,导入json的jar包即可,如下: (注:json-lib-2.4的jar包下载地址:http://xiazai.jb51.net/201605/yuanma/json-lib-2.4(jb51.net).rar ) 2. 完善Action 在D

  • SSH框架网上商城项目第2战之基本增删查改、Service和Action的抽取

    上一节<SSH框架网上商城项目第1战之整合Struts2.Hibernate4.3和Spring4.2>我们搭建好了Struts2.Hibernate和Spring的开发环境,并成功将它们整合在一起.这节主要完成一些基本的增删改查以及Service.Dao和Action的抽取. 1. Service层的抽取         上一节中,我们在service层简单写了save和update方法,这里我们开始完善该部分的代码,然后对service层的代码进行抽取. 1.1 完善CategorySer

  • SSH框架网上商城项目第27战之申请域名空间和项目部署及发布

    前面陆陆续续的完成了网上商城的一些基本功能,虽然还有很多地方有待完善,但是不影响项目的部署和发布,我们可以先来玩一把,这一节主要介绍下域名空间的申请以及项目的部署和发布流程. 1. 域名空间的申请 作为一个伟大的屌丝,肯定没钱买域名空间,很自然的想到去申请个免费的,现在免费的域名空间也很多,我在福佳jsp技术网上申请了一个试用期是15天的,大家也可以去申请个玩玩,反正作为学习,这已经足够了,当然,如果要长期的肯定要付费的.注册过程我截几个图,如下: 然后下一步,最后开通如下: 建议把上面这些信息

  • SSH框架网上商城项目第16战之Hibernate二级缓存处理首页热门显示

    网上商城首页都有热门商品,那么这些商品的点击率是很高的,当用户点击某个热门商品后需要进入商品的详细信息页面,就像淘宝里面那样.那么每次点击都要去后台查询一下该商品的详细信息,就会发送相应的sql语句,每次刷新一下详细页面也会发sql语句,这样的话,性能肯定会受到很大的影响.那么使用Hibernate的二级缓存就可以解决这个问题. 有些人可能会想,我们可以使用重定向,这样的话,在用户第一次访问的时候把信息查出来放到session中,以后每次用户刷新就可以去session中拿了,这样就不用去数据库中

  • SSH框架网上商城项目第21战之详解易宝支付的流程

    这一节我们先写一个简单点的Demo来测试易宝支付的流程,熟悉这个流程后,再做实际的开发,因为是一个Demo,所以我没有考虑一些设计模式的东西,就是直接实现支付功能.实现支付功能需要易宝给我们提供的API.那么问题来了,使用第三方支付平台最主要的一件事就是获取该平台的API,我们首先得获取他们的API以及开发文档,然后才可以做进一步的开发. 1. 获取易宝的API 获取API的第一步,要在易宝上注册一个账号,这个账号是商家的账号,后面买家付款后,会将钱款存入该账号中,然后商家自己提取到银行卡,易宝

  • SSH框架网上商城项目第30战之项目总结(附源码下载地址)

    0. 写在前面 友情提示:下载地址在下面哦. 项目基本完成了,加上这个总结,与这个项目相关的博客也写了30篇了,积少成多,写博客的过程是固化思路的一个过程,对自己很有用,同时也能帮助别人.顺便说个题外话,在学习的过程中肯定会遇到很多异常出现,我们要做的首先是定位这个异常,一般异常的后面都会跟一个或多个Caused by:xxx,这些都是引起异常的原因,一般我们找最下面的一个Caused by,那里往往才是问题的根源.如果自己解决不了,可以去谷歌.百度搜索(搜索的时候别一大堆异常往上一贴,注意搜关

  • SSH框架网上商城项目第15战之线程、定时器同步首页数据

    上一节我们做完了首页UI界面,但是有个问题:如果我在后台添加了一个商品,那么我必须重启一下服务器才能重新同步后台数据,然后刷新首页才能同步数据.这明显不是我们想要的效果,一般这种网上商城首页肯定不是人为手动同步数据的,那么如何解决呢?我们需要用到线程和定时器来定时自动同步首页数据. 1. Timer和TimerTask 我们需要用到Timer和TimerTask两个类.先来介绍下这两个类. Timer是一种工具类,在java.util包中,线程用其安排以后在后台线程中执行的任务.可安排任务执行一

  • SSH框架网上商城项目第25战之使用java email给用户发送邮件

    当用户购买完商品后,我们应该向用户发送一封邮件,告诉他订单已生成之类的信息,邮箱地址是从用户的基本信息中获取,好了,首先我们来看一下java中发送邮件的方法. 1. java中发送email的方法 在完善这个项目之前,先来回顾一下java中是如何发送邮件的,首先肯定需要发送邮件的jar包:mail.jar,导入到lib目录下,好了,下面我们先写一个普通的java程序来回顾一下java email的知识点: public class SendEmailDemo { public static vo

  • SSH框架网上商城项目第20战之在线支付平台

    之前已经完成了首页的显示,用户添加购物车,确认订单等功能,下面就是支付功能的开发了.用户确认了订单后会直接跳转到支付页面进行在线支付,在线支付需要第三方的接口,这一节主要介绍一些关于第三方支付的内容,从下一节开始,我们真正开发在线支付模块. 1. 在线支付介绍 在线支付是指卖方与买方通过因特网上的电子商务网站进行交易时,银行为其提供网上资金结算服务的一种业务.它为企业和个人提供了一个安全.快捷.方便的电子商务应用环境和网上资金结算工具.在线支付不仅帮助企业实现了销售款项的快速归集,缩短收款周期,

随机推荐