struts2,spring,hibernate三大框架整合

本文利用mvc三层架构来讲述S2SH三大框架整合的步骤:

1.建立好包结构,建立好的包结构如下:

2.导入相应的jar包

(1)struts2用到的jar包

(2)spring用到的jar包

(3)hibernate用到的jar包

(4)mysql驱动包,junit和struts2插件

(5)公共包,例如日志

commons-logging-1.1.3.jar

log4j-1.2.17.jar

slf4j-log4j12-1.5.0.jar

最后经过整理的jar包清单如下:

antlr-2.7.6.jar

aopalliance.jar

asm-3.3.jar

asm-commons-3.3.jar

asm-tree-3.3.jar

aspectjrt.jar

aspectjweaver.jar

commons-collections-3.1.jar

commons-fileupload-1.3.1.jar

commons-io-2.2.jar

commons-lang3-3.1.jar

commons-logging-1.1.3.jar

dom4j-1.6.1.jar

freemarker-2.3.19.jar

hibernate3.jar

javassist-3.11.0.GA.jar

jta-1.1.jar

junit.jar

log4j-1.2.17.jar

mysql-connector-java-5.1.10-bin.jar

ognl-3.0.6.jar

slf4j-api-1.5.8.jar

slf4j-log4j12-1.5.0.jar

spring-aop-3.2.2.RELEASE.jar

spring-aspects-3.2.2.RELEASE.jar

spring-beans-3.2.2.RELEASE.jar

spring-context-3.2.2.RELEASE.jar

spring-core-3.2.2.RELEASE.jar

spring-expression-3.2.2.RELEASE.jar

spring-jdbc-3.2.2.RELEASE.jar

spring-orm-3.2.2.RELEASE.jar

spring-tx-3.2.2.RELEASE.jar

spring-web-3.2.2.RELEASE.jar

struts2-core-2.3.16.1.jar

struts2-spring-plugin-2.3.16.1.jar

xwork-core-2.3.16.1.jar

3.相应的jar包导入完成后,就可以配置配置文件了

首先在config目录下建立如下的结构

hibernate目录专门用来存放hibernate的配置文件,spring目录用来存放spring配置文件,struts用来存放struts配置文件

(1)首先配置好hibernate的配置文件

文件路径:${项目路径}/config/hibernate/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>
		<property name="connection.driver_class">
			com.mysql.jdbc.Driver
		</property>
		<property name="connection.url">jdbc:mysql:///s2sh</property>
		<property name="connection.username">root</property>
		<property name="connection.password">123456</property>
		<!-- 方言 -->
		<property name="dialect">
			org.hibernate.dialect.MySQLDialect
		</property>

		<!-- 每次都检查表结构,如果表不存在则创建 -->
		<property name="hbm2ddl.auto">update</property>
		<!-- 显示sql语句,开发时启用 -->
		<property name="show_sql">true</property>
	</session-factory>
</hibernate-configuration>

(2)配置spring

为了便于管理,将spring的配置文件作为不同的文件存放,最后在applicationContext.xml文件中引入

      首先是配置spring事务管理:

      文件路径:${项目路径}/config/spring/applicationContext-db.xml

 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:aop="http://www.springframework.org/schema/aop"
     xmlns:tx="http://www.springframework.org/schema/tx"
     xsi:schemaLocation="
	     http://www.springframework.org/schema/beans
	     http://www.springframework.org/schema/beans/spring-beans.xsd
	     http://www.springframework.org/schema/tx
	     http://www.springframework.org/schema/tx/spring-tx.xsd
	     http://www.springframework.org/schema/aop
	     http://www.springframework.org/schema/aop/spring-aop.xsd">
	<!-- 配置sessionFactory -->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="configLocation">
			<value>classpath:hibernate/hibernate.cfg.xml</value>
		</property>
	</bean>

	<!-- 配置事务管理器 -->
	<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory">
			<ref bean="sessionFactory"/>
		</property>
	</bean>

	<!-- 配置通知 -->
	<tx:advice id="tx" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="save*"/>
			<tx:method name="update*"/>
			<tx:method name="delete*"/>
			<tx:method name="*" read-only="true"/>
		</tx:attributes>
	</tx:advice>
	<!-- aop配置 -->
	<aop:config>
		<!-- 切入点表达式 -->
		<aop:pointcut expression="execution(* cn.zq.service.impl.*.*(..))" id="perform"/>
		<aop:advisor advice-ref="tx" pointcut-ref="perform"/>
	</aop:config>
</beans>

4.创建Person类以及Dao,Service,Action

(1)创建Person

package cn.zq.bean;

public class Person {
	private Long id;
	private String name;
	private Integer age;
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}

	public String toString() {
		return "Person [id=" + id + ", name=" + name + ", age=" + age + "]";
	}

}

(2)配置Person的hibernate的映射文件

文件路径:${项目路径}/src/cn/zq/bean/Person.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
                                   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.zq.bean">
	<class name="Person" table="person" >
		<id name="id" type="long" length="10" >
			<generator class="increment"></generator>
		</id>
		<property name="name" type="string" length="36" column="name" />
		<property name="age" type="integer"/>
	</class>
</hibernate-mapping>

并在hibernate.cfg.xml配置文件中引入

<mapping resource="cn/zq/bean/Person.hbm.xml" />

(3)创建Dao

package cn.zq.dao;

import java.io.Serializable;
import java.util.List;

import cn.zq.bean.Person;

/**
 *
 * @author zq
 *
 */
public interface PersonDao {

	/**
	 * save <b>Person</b> to DB.
	 * @param p The <code>Person</code> object to be saved.
	 */
	void savePerson(Person p);

	/**
	 * Find Person by id from DB.
	 * @param pid The primary key.
	 * @return Person instance or null if not found.
	 */
	Person findPersonById(Serializable pid);

	/**
	 * Find all Person from DB.
	 * @return Person collections.
	 */
	List<Person> findAll();
}
package cn.zq.dao.impl;

import java.io.Serializable;
import java.util.List;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import cn.zq.bean.Person;
import cn.zq.dao.PersonDao;

/**
 *
 * @author zq
 *
 */
public class PersonDaoImpl extends HibernateDaoSupport
						implements PersonDao{

	public void savePerson(Person p) {
		getHibernateTemplate().save(p);
	}

	public Person findPersonById(Serializable pid) {
		return getHibernateTemplate().get(Person.class, pid);
	}

	@SuppressWarnings("unchecked")
	public List<Person> findAll() {
		return getHibernateTemplate().find("from Person");
	}

}

(4)创建service

package cn.zq.service;

import java.io.Serializable;
import java.util.List;

import cn.zq.bean.Person;

public interface PersonService {

	void savePerson(Person p);

	Person findPersonById(Serializable pid);

	List<Person> findAll();
}
package cn.zq.service.impl;

import java.io.Serializable;
import java.util.List;

import cn.zq.bean.Person;
import cn.zq.dao.PersonDao;
import cn.zq.service.PersonService;

public class PersonServiceImpl implements PersonService{

	private PersonDao personDao;

	public PersonDao getPersonDao() {
		return personDao;
	}

	public void setPersonDao(PersonDao personDao) {
		this.personDao = personDao;
	}

	public void savePerson(Person p) {
		getPersonDao().savePerson(p);
	}

	public Person findPersonById(Serializable pid) {
		return getPersonDao().findPersonById(pid);
	}

	public List<Person> findAll() {
		return getPersonDao().findAll();
	}

}

(5)创建action

package cn.zq.struts2.action;

import java.util.List;
import java.util.Random;

import cn.zq.bean.Person;
import cn.zq.service.PersonService;

import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;

public class PersonAction extends ActionSupport{

	private static final long serialVersionUID = -7979618198537224040L;

	private PersonService personService;

	public PersonService getPersonService() {
		return personService;
	}

	public void setPersonService(PersonService personService) {
		this.personService = personService;
	}

	public String save(){
		Person p = new Person();
		Random random = new Random(13);
		p.setName("RiccioZhang" + random.nextInt(100));
		p.setAge(random.nextInt(30));
		getPersonService().savePerson(p);
		return null;
	}

	public String findAll(){
		List<Person> persons = getPersonService().findAll();
		ActionContext.getContext().getValueStack().push(persons);
		return "index";
	}
}

(6)创建struts2配置

和上面一样这个配置文件只用来存放一些公共的配置,其他配置在此引入

文件路径:${项目路径}/config/struts.xml

<?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>
	<!-- <constant name="struts.objectFactory" value="spring"></constant> -->
	<constant name="struts.action.extension" value="action"></constant>
	<constant name="struts.devMode" value="true"></constant>

</struts>

(7)创建Person的struts2配置

文件路径:${项目路径}/config/struts/struts-Person.xml

<?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="person" namespace="/" extends="struts-default">
		<action name="personAction_*" class="personAction" method="{1}">
			<result name="index">/index.jsp</result>
		</action>
	</package>
</struts>

并在struts.xml引入

<include file="struts/struts-Person.xml"></include>

5.用spring管理Person的Dao,Service,Action的创建

文件路径:${项目路径}/config/spring/applicationContext-Person.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:aop="http://www.springframework.org/schema/aop"
     xmlns:tx="http://www.springframework.org/schema/tx"
     xsi:schemaLocation="
	     http://www.springframework.org/schema/beans
	     http://www.springframework.org/schema/beans/spring-beans.xsd
	     http://www.springframework.org/schema/tx
	     http://www.springframework.org/schema/tx/spring-tx.xsd
	     http://www.springframework.org/schema/aop
	     http://www.springframework.org/schema/aop/spring-aop.xsd">

	<bean id="personDao" class="cn.zq.dao.impl.PersonDaoImpl">
		<property name="sessionFactory">
			<ref bean="sessionFactory"/>
		</property>
	</bean>
	<bean id="personService" class="cn.zq.service.impl.PersonServiceImpl">
		<property name="personDao" ref="personDao"></property>
	</bean>
	<bean id="personAction" class="cn.zq.struts2.action.PersonAction" scope="prototype">
		<property name="personService" ref="personService"></property>
	</bean>
</beans>

并在applicationContext.xml文件中引入

<import resource="applicationContext-Person.xml"/>

在此为此三大框架的整合基本上完成了,但是不要忘记了在web.xml文件中配置

6.在web,xml文件中整入spring,struts2

<?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" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 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">

  <listener>
  	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <context-param>
  	<param-name>contextConfigLocation</param-name>
  	<param-value>classpath:spring/applicationContext.xml</param-value>
  </context-param>

  <filter>
  	<filter-name>OpenSessionInViewFilter</filter-name>
  	<filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
  </filter>
  <filter-mapping>
  	<filter-name>OpenSessionInViewFilter</filter-name>
	<url-pattern>*.action</url-pattern>
  </filter-mapping>

  <filter>
  	<filter-name>StrutsPrepareAndExecuteFilter</filter-name>
  	<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>
  <filter-mapping>
  	<filter-name>StrutsPrepareAndExecuteFilter</filter-name>
	<url-pattern>/*</url-pattern>
  </filter-mapping>

  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

7.完成index,jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib uri="/struts-tags" prefix="s"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>Person List</title>
  </head>

  <body>
   	<table border="1">
   		<tr>
   			<td>ID</td>
   			<td>NAME</td>
   			<td>AGE</td>
   		</tr>
   		<s:iterator>
   			<tr>
   				<td>
   					<s:property value="id"/>
   				</td>
   				<td><s:property value="name"/></td>
   				<td><s:property value="age"/></td>
   			</tr>
   		</s:iterator>
   	</table>
  </body>
</html>

8.创建数据库s2sh

mysql> create database s2sh character set utf8;
Query OK, 1 row affected (0.03 sec)

9.部署并启动tomcat

为了能有日志信息输出,需要配置log4j

路径:${项目}/config/log4j.properties

# Set root logger level to WARN and append to stdout
log4j.rootLogger=INFO, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

# Pattern to output the caller's file name and line number.
log4j.appender.stdout.layout.ConversionPattern=%d %5p (%c:%L) - %m%n

# Print only messages of level ERROR or above in the package noModule.
log4j.logger.noModule=FATAL

log4j.logger.com.opensymphony.xwork2=DEBUG
log4j.logger.org.apache.struts2=DEBUG

如果在启动时没有报错说明配置成功了,一般启动不会瞬间完成,要是非常快就启动完成了,那么说明肯定是报错了。

(1)首先访问http://localhost:8080/s2sh/personAction_save.action, 多访问几次以便多插入几行数据

(2)访问http://localhost:8080/s2sh/personAction_findAll.action

到此三大框架的整合工作算是完成了,接下来就可以在此基础上继续开发

本文的源代码可以在这里下载http://download.csdn.net/detail/qq791967024/8553253

时间: 2024-10-10 09:57:34

struts2,spring,hibernate三大框架整合的相关文章

SSH(struts2+spring+hibernate)三大框架整合

SSH框架整合理论: 在SSH框架的JAVAweb项目的开发过程中,WEB层通常使用的是Struts2+jsp,service层使用的是javaBean,DAO层使用的是hibernate,而spring的使用覆盖三层. 使用了spring框架之后,我们可以把对象交给spring来管理.在WEB层中,所有action对象的创建和管理都可以交给spring来完成,这样Struts2就不用自己来new一个action,这一切都可以交给spring,直接向spring来要action对象. 在DAO层

Struts2+Spring+Hibernate 三大框架的合并集成

这次来看看Struts2+Spring+Hibernate三大框架的整合应用,主要是Spring和Hibernate框架的整合,因为前边已经将Strtus2+Spring整合过了基本一样.  首先看一下分工吧: Struts2做的MVC的流程框架,主要完成从客户端访问到选择action的过程,其中过滤器起到了Controller的作用,action属于model,而jsp则是view页面的展示. Spring主要利用Ioc的特长来管理各种对象:action,service,dao,数据访问源,H

java 的 struts2 Spring Hibernate 三大框架的整合

原理就不说了,直接上配置文件及代码,用来备用 首先,将三大框架所需要的jar包导入项目中 导入  struts2-spring-plugin-2.3.3.jar包  此包的作用是作为struts2 与spring 的桥梁 web.xml <?xml version="1.0" encoding="UTF-8"?> <web-app version="2.5" xmlns="http://java.sun.com/xml

Struts2,Spring,Hibernate三大框架的整合(SSH)

一.搭建struts2 1).导入struts2 jar包 2).编写web.xml 3).编写jsp页面 4).创建action类,action类要继承ActionSupport类 5).创建struts.xml 二.搭建spring 1).导入spring jar包,还要导入一个struts2提供的插件包 2).创建applicationContext.xml文件 修改struts.xml 3).在web.xml里面配置spring监听 三.搭建Hibernate 1).导入Hibernat

浅谈ssh(struts,spring,hibernate三大框架)整合的意义及其精髓

hibernate工作原理 原理: 1.读取并解析配置文件 2.读取并解析映射信息,创建SessionFactory 3.打开Sesssion 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory 为什么要用: 1. 对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代码. 2. Hibernate是一个基于JDBC的主流持久化框架,是一个优秀的ORM实现.他很大程度的简化DAO层的编码工作 3. hib

[转] 浅谈ssh(struts,spring,hibernate三大框架)整合的意义及其精髓

hibernate工作原理 原理: 1.读取并解析配置文件 2.读取并解析映射信息,创建SessionFactory 3.打开Sesssion 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory 为什么要用: 1. 对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代码. 2. Hibernate是一个基于JDBC的主流持久化框架,是一个优秀的ORM实现.他很大程度的简化DAO层的编码工作 3. hib

Struts,spring,hibernate三大框架的面试

Struts,spring,hibernate三大框架的面试 1.Hibernate工作原理及为什么要用? 原理: 1.读取并解析配置文件 2.读取并解析映射信息,创建SessionFactory 3.打开Session 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory  为什么要用: 1. 对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代码. 2. Hibernate是一个基于JDBC的主流持久

Struts,Spring,Hibernate三大框架 面试题

Struts,Spring,Hibernate三大框架 1.Hibernate工作原理及为什么要用? 原理: 1.读取并解析配置文件 2.读取并解析映射信息,创建SessionFactory 3.打开Session 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory 为什么要用: 1. 对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代码. 2. Hibernate是一个基于JDBC的主流持久化框架,

Eclipse搭建SSH(Struts2+Spring+Hibernate)框架教程

| 版权声明:本文为博主原创文章,未经博主允许不得转载. 前言 确实,刚创博客,对于这个陌生的东西还是有些许淡然.这是我的第一篇博文,希望能给你们有帮助,这就是我最大的乐趣! 好了下面进入正题: SSH框架简介:①SSH框架是由struts2.spring.hibernate三大框架组合起来的一套总框架,一般来说这三个东西我们不会单独使用.  ②在学习SSH框架之前建议读者先学mvc,因为SSH是在mvc基础上根据mvc的缺点而产生的一套比较成熟的框架,也比较稳定.  ③SSH框架的流程:浏览器