Struts2+Spring+Hibernate框架搭建步骤

合集下载

Java Web编程实战宝典(JSP+Servlet+Struts 2+Hibernate+Spri

20.2 掌握HQL和SQL技术
20.4 实战练习
21.1 什么是事务
21.3 应用查询缓存（Query Cache）
21.5 学习过滤器
第3篇 Hibernate篇
21 Hibernate的高级技术
21.2 学习锁（Locking） 21.4 学习拦截器和事件
21.6 小结
第3篇 Hibernate 篇
3.4 其他客户端技术
3.6 学习AJAX技术
第1篇 Web开发基础篇
3.7 小结
3.8 实战练习
3 Web开发必会的客户端技术
4.1 编写Servlet的 Helloworld程序 4.3 掌握
HttpServletResponse类
4.5 处理Cookie
第1篇 Web开发基础篇
4 Java Web的核心技术——Servlet
6.7 实战练习
第2篇 Struts 2篇
02
第2篇 Struts 2篇
7 编写Struts 2第一个程序
10 Struts 2的类型转换
8 Struts 2进阶
11 Struts 2的输入校验
9 Struts 2的拦截器
12 文件的上传和下载
第2篇 Struts 2篇
14 Struts 2的标签库
1.12 实战练习
1.11 小结
第1篇 Web开发基础篇
1 搭建开发环境
1.8 在Eclipse IDE for Java EE Developers中配置 Tomcat
1.9 下载与安装MySQL 5数据库
1.10 下载与安装数据库客户端软件SQLyog
2.1 Web技术的发展

Struct2、Hibernate3、Spring3框架搭建实战

Struct2、Hibernate3、Spring3框架搭建实战采⽤⽬前最新的struts-2.3.1.2、hibernate3.6.10.Final、spring-framework-3.1.1.RELEASE开发包，以及eclipse-jee-indigo-SR2-win32、apache-tomcat-7.0.27服务器、JDK6和mysql5做开发环境，参考了前辈的⼀篇相关⽂章，改正了其中的错误和疏漏，克服了公司分配的“新”机器每⼩时⾃动重启三次的困难，终于把环境给搭好了。

整个过程中遵循的⼀个原则是，避免引⼊⽤不到的jar包，以求搭建⼀个最⼩的SSH 运⾏环境。

⾸先创建⼀个Dynamic web project 输⼊任意名字如SSHBase。

第⼀步：加载Spring环境我们需要引⼊的包有：org.springframework.asm-3.1.1.RELEASE.jarorg.springframework.beans-3.1.1.RELEASE.jarorg.springframework.context-3.1.1.RELEASE.jarorg.springframework.core-3.1.1.RELEASE.jarorg.springframework.expression-3.1.1.RELEASE.jarorg.springframework.jdbc-3.1.1.RELEASE.jarorg.springframework.web-3.1.1.RELEASE.jarorg.springframework.orm-3.1.1.RELEASE.jar由于spring默认开启了⽇志，还需要加⼊commons-logging的jar包，否则会报错。

建议不要⼀次性加⼊应该先加最核⼼的运⾏代码看缺少什么加什么，这样就不会加多余的包进来了，spring3已经把包按功能分开，不像以前⼀个包，这样更灵活，只要运⾏我们需要的功能，⽽没⽤到的就不⽤在硬性的添加进来。

三大框架整合及其原理

一搭建三大框架步骤1 搭建s2sh步骤分析:1.1在MyEclipse 里面新建一个 java web project1.2新建三个 Source Folder :src : 源文件config : 存放配置文件 : hibernate , spring , struts2test: 测试类1.3 导入环境需要的jar 包 : WebRoot/WEB-INF/lib (一共64个)2 搭建Hibernate 和Spring 整合(*根据搭建需求谁能先测试就先搭建谁)2.1 在 src 源文件里面建立一个 cola.s2sh.domain[并且在该包下创建一个持久类和该类的映射文件] .2.2 配置核心文件在 config 里面建立一个hibernate 文件夹里面创建hibernate.cfg.xml配置文件(里面的内容拷贝就可以)2.3 在spring 文件夹里面创建并且把sessionFactory 交给spring 来管理: [applicationContext-db.xml中引入][<bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation"><value>classpath:hibernate/hibernate.cfg.xml</value> </property></bean>]在 applicationContext.xml 中 : 导入<import resource="applicationContext-db.xml"/>2.4 测试sessionFactory[编写SpringUtils 然后继承这个][public class SpringUtils {public static ApplicationContext context;static {context = newClassPathXmlApplicationContext("spring/applicationContext.xml" );}}]2.5 编写 dao .service 的包类和接口;PersonDaoImpl 要继承HibernateDaoSupport[public class PersonDaoImpl extends HibernateDaoSupport implements PersonDao {public void savePerson(Person person) {this.getHibernateTemplate().save(person);}}]2.6 把 dao ,service 放在spring 容器中:[<bean id="personDao"class="cola.s2sh.daoImpl.PersonDaoImpl"> <property name="sessionFactory"><ref bean="sessionFactory"/></property></bean><bean id="personService"class="cola.s2sh.service.impl.PersonServiceImpl"><property name="personDao"><ref bean="personDao"/></property></bean>]2.7 完成 spring 声明式处理 :[<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*"read-only="false"/><tx:method name="update*"read-only="false"/><tx:method name="delete*"read-only="false"/><tx:method name="*"read-only="true"/></tx:attributes></tx:advice><aop:config><aop:pointcutexpression="execution(* cola.s2sh.service.impl.*.*(..))"id="perform"/><aop:advisor advice-ref="tx"pointcut-ref="perform"/> </aop:config>]2.8 整合struts 创建 action 类包 ;2.9 把action 放在spring 容器中* 注意在personAction的spring的配置中一定要写一个属性scope="prototype"[<bean id="personAction"class="cola.s2sh.action.PersonAction" scope="prototype"><property name="personService"><ref bean="personService"/></property></bean>]在这个中引入下面3.0 编写struts2中配置文件Struts –person.xml中Struts.xml3.1 编写web .xml文件[<?xml version="1.0"encoding="UTF-8"?><web-app xmlns:xsi="/2001/XMLSchema-instance"xmlns="/xml/ns/javaee"xmlns:web="/xml/ns/javaee/web-app_2_5.xsd"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_3_0.xsd"id="WebApp_ID"version="3.0"><display-name>cola.s2sh</display-name><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener><!—将srping放在SrvletContext中进行加载当servlet加载时 spring 也完成加载 --> <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>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter -class></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping>]二原理分析:一、 Struts 2框架整合Spring步骤1、复制文件。

struts2+spring3+hibernate整合教程

Struts2+Spring3+hibernate3整合（2011年7月末，最新）上次下载了一个教程，上面写着：“献给我亲爱的老婆！”（羡慕不已）。

想了想，我没老婆，难道没什么好写了！不难…献给我暗恋过的每一个女人!（嘿嘿…）如果在你遇到的女生中有一个幽默豁达的女生，不要犹豫，追上去，就娶她了！一，需要的框架包二，建立project，添加相应的.jar文件（重点）1，eclipse中建立dynamic web project，这里是ssh_integrate_0100。

2，src中创建需要的类，这里以一个域模型为user的例子说明。

(现在建立这些类，可以方便我们在搭建时候随时测试!)User.javaIUserDao.javaUserDaoImpl.javaIUserService.javaUserServiceImpl.java3，拷贝spring-framework-3.1.0\dist目录下的所有jar包，注意有一个不是jar的文件，当然拷过去也没事。

4，拷贝spring运行中需要的其他jar文件，主要是mons-logging，可以从spring-framework-3.0.2.RELEASE-dependencies中找到。

ii.Aspectjrt.jar和aspect-waver.jar，可以从spring-framework-2.5.6-with-dependencies/lib/aspectj下面找到（不知道为什么，spring-framework-3.0.2.RELEASE-dependencies中没有aspectjrt的jar包）iii.aopalliance.Jar，apache-dbcp.jar，apache-pool.jar，可以从spring-framework-3.0.2.RELEASE-dependencies中找到。

5，建立beans.xml，这里使用的是annotation和component-scan，这样配置可以大大简化配置，所以是best-practice，其他配置请参考spring文档。

SpringMVC框架搭建流程（完整详细版）

SpringMVC框架搭建流程（完整详细版）SpringMVC框架搭建流程开发过程1）配置DispatcherServlet前端控制器2）开发处理具体业务逻辑的Handler（@Controller、 @RequestMapping）3） xml配置⽂件配置controller扫描，配置springmvc三⼤件4）将xml⽂件路径告诉springmvc（DispatcherServlet）详细流程：创建⽬录新建maven项⽬，注意选择webapp⾻架。

创建成功之后会发现没有src等⽬录，这些需要我们⼿动创建：在src下⾯新建main，main下⾯新建java⽬录，选择java⽬录，右键，在main下⾯继续新建resource⽬录，选择resource⽬录，右键，pom.xmlpom.xml<?xml version="1.0" encoding="UTF-8"?><project xmlns="/POM/4.0.0"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion><groupId></groupId><artifactId>springmvc-demo</artifactId><version>1.0-SNAPSHOT</version><packaging>war</packaging><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><piler.source>11</piler.source><piler.target>11</piler.target></properties><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.1.12.RELEASE</version></dependency></dependencies><build><plugins><plugin><groupId>org.apache.tomcat.maven</groupId><artifactId>tomcat7-maven-plugin</artifactId><version>2.2</version><configuration><port>8080</port><path>/</path></configuration></plugin></plugins></build></project>注意Tomcat7插件是⽤来运⾏项⽬的，右侧运⾏：springmvc相关配置main⽂件夹下⾯新建webapp⽂件夹，webapp下⾯新建WEB-INF，下⾯新建web.xml<!DOCTYPE web-app PUBLIC"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN""/dtd/web-app_2_3.dtd" ><web-app><display-name>Archetype Created Web Application</display-name><servlet><servlet-name>springmvc</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>classpath:springmvc.xml</param-value></init-param></servlet><servlet-mapping><servlet-name>springmvc</servlet-name><url-pattern>/</url-pattern></servlet-mapping></web-app>⾥⾯配置了springmvc相关的配置，引⼊了springmvc.xml:在resource⽬录下新建springmvc.xml:<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:mvc="/schema/mvc"xsi:schemaLocation="/schema/beanshttps:///schema/beans/spring-beans.xsd/schema/contexthttps:///schema/context/spring-context.xsd/schema/mvchttps:///schema/mvc/spring-mvc.xsd"><context:component-scan base-package=".controller"/><bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"><property name="prefix" value="/WEB-INF/jsp/"/><property name="suffix" value=".jsp"/></bean><mvc:annotation-driven/></beans>在java⽬录下新建包.controller,下⾯新建DemoController:package .controller;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.servlet.ModelAndView;import java.util.Date;/*** @author lyj* @Title: DemoController* @ProjectName springmvc-demo* @Description: TODO* @date 2020/6/9 21:21*/@Controller@RequestMapping("/demo")public class DemoController {/*** http://localhost:8080/demo/handle01*/@RequestMapping("/handle01")public ModelAndView handle01(){Date date=new Date();ModelAndView modelAndView=new ModelAndView();modelAndView.addObject("date",date);modelAndView.setViewName("success");return modelAndView;}}在WEB-INF下⾯新建jsp⽂件夹，下⾯新建success.jsp:<%@ page language="java" isELIgnored="false" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%> <html lang="en"><head><meta charset="UTF-8"><title>Title</title></head><body>当前时间 ${date}</body></html>完毕后整个项⽬结构如下：测试：浏览器访问：。

Maven搭建MyEclipse10+Struts2.1+Spring3.3+Hibernate3.3全注解框架

一、新建项目1.新建maven项目New ->project选择Maven projectnext在filter输入webapp选择maven-archetype-webappGroup id输入inscribe，artifact id输入farsighted二、添加struts2框架1.添加struts2支持项目上点右键->myeclipse->add struts capabilities点选struts2.1和/*只勾选struts2 core lib启动tomcat，在地址栏输入localhost:8088/farsighted出现如下界面2.添加action类New ->source folder输入src/main/javaNew ->classPackage输入org.inscribe.farsighted.action，name输入LoginActionLoginAction.javapackage org.inscribe.farsighted.action;import org.apache.struts2.convention.annotation.Action;import org.apache.struts2.convention.annotation.ParentPackage; import org.apache.struts2.convention.annotation.Result;import com.opensymphony.xwork2.ActionSupport;/*** @author steve frank**/@ParentPackage("struts-default")public class LoginAction extends ActionSupport {private String name;private String password;public String getName() {return name;}public void setName(String name) { = name;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}@Action(value = "login", results = {@Result(name = INPUT, location = "/WEB-INF/content/fail.jsp"),@Result(name = SUCCESS, location = "/WEB-INF/content/success.jsp") }) public String execute() {if (name.equals("steve") && password.equals("123"))return SUCCESS;elsereturn INPUT;}}Index.jsp<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%><%@ taglib prefix="s" uri="/struts-tags"%><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html><head><title>My JSP 'index.jsp' starting page</title></head><body><s:form action="login"><s:textfield name="name" value="steve"></s:textfield><s:textfield name="password" value="123"></s:textfield><s:submit></s:submit></s:form></body></html>success.jsp<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <%@ taglib prefix="s" uri="/struts-tags"%><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html><head><title>My JSP 'success.jsp' starting page</title></head><body><s:text name="password" /><hr /><s:property value="password" /></body></html>fail.jsp<body>登录失败,用户名或密码错误.</body>三、添加hibernate框架1.添加hibernate支持右键->myeclipse->add hibernate capabilities点选hibernate 3.3 勾选enable hibernate annotations support勾选hibernate 3.3 annotations&entity manager,hibernate 3.3 core lib,hibernate 3.3 advanced support lib点选copy checked library jars to folder and add to build-path点选newFolder :src/main/resources勾选open configuration file选择db driver:mysql去掉勾，不创建hibernatesessionfactory四、添加spring框架1.添加spring支持项目右键->myeclipse->add spring capabilities点选spring3.0勾选spring 3.0 core;spring 3.0 aop;spring3.0 persistence core; spring3.0 persistence jdbc; 勾选copy checked library contents to project folder采取默认，enable aop,new applicationcontext.xml不创建sessionfactory2.applicationContext.xml文件配置<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd/schema/aop/schema/aop/spring-aop.xsd/schema/tx/schema/tx/spring-tx.xsd"> <bean id="sessionFactory"class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBea n"><property name="configLocation" value="classpath:hibernate.cfg.xml"></property><property name="packagesToScan" value="org.inscribe.farsighted.model" /> </bean><context:component-scan base-package="org.inscribe.farsighted" /><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory" /></bean><tx:annotation-driven transaction-manager="transactionManager"proxy-target-class="true" /></beans>3.hibernate.cfg.xml修改<?xml version='1.0' encoding='UTF-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><property name="dialect">org.hibernate.dialect.MySQLDialect</property><property name="connection.url">jdbc:mysql://localhost:3306/test</property><property name="ername">root</property><property name="connection.password">admin</property><property name="connection.driver_class">com.mysql.jdbc.Driver</property><property name="myeclipse.connection.profile">MYSQL</property><property name="initialSize">5</property><property name="maxActive">100</property><property name="maxIdle">30</property><property name="maxWait">500</property><property name="defaultAutoCommit">false</property></session-factory></hibernate-configuration>4.web.xml文件配置<?xml version="1.0" encoding="UTF-8"?><web-app version="3.0" xmlns="/xml/ns/javaee"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_3_0.xsd"><display-name></display-name><welcome-file-list><welcome-file>index.jsp</welcome-file></welcome-file-list><context-param><param-name>contextConfigLocation</param-name><param-value>classpath*:applicationContext*.xml</param-value></context-param><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class ></listener><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>/*</url-pattern></filter-mapping><filter><filter-name>Set Character Encoding</filter-name><filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param><init-param><param-name>forceEncoding</param-name><param-value>true</param-value></init-param></filter><filter-mapping><filter-name>Set Character Encoding</filter-name><url-pattern>/*</url-pattern></filter-mapping></web-app>五、类的添加1.hibernate反向生成students表右键->hibernate reverse engineering选择package : com.inscribe.farsighted.model勾选create pojo<>db->点选add hibernate mapping annotations to pojo;勾选update hibernate configuration with mapping resource location勾选java data access object(dao)->勾选generate precise findby methods;点选sping daoId generation :native2.添加service接口package org.inscribe.farsighted.service;import org.inscribe.farsighted.model.Student;public interface StudentService {public Student findById(Integer id);}3.添加service实现类package org.inscribe.farsighted.service.impl;import javax.annotation.Resource;import org.inscribe.farsighted.model.Student;import org.inscribe.farsighted.model.StudentDAO;import org.inscribe.farsighted.service.StudentService;import org.springframework.stereotype.Service;@Servicepublic class StudentServiceImpl implements StudentService {@Resourceprivate StudentDAO studentDAO;@Overridepublic Student findById(Integer id) {// TODO Auto-generated method stubreturn studentDAO.findById(id);}}4.添加测试类package org.inscribe.farsighted;import org.inscribe.farsighted.model.Student;import org.inscribe.farsighted.service.StudentService;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class Test {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");StudentService service = (StudentService) context.getBean("studentServiceImpl");Student s=service.findById(1);System.out.println(s.getName());}}5.WEB-INF下新建Folder包结构如下6.修改输出目录Build path->configure build pathOut folder统一改default：Webapp/src/main/webapp/WEB-INF/classes更改如果无效,在pom.xml中<build>……</build>添加<sourceDirectory>src/main/java</sourceDirectory><resources><resource><directory>src/main/resources</directory></resource></resources><outputDirectory>src/main/webapp/WEB-INF/classes</outputDirectory>7.添加struts-spring支持(action注解配置支持)Build path->add librariesMyeclipse libraries勾选struts 2 spring libraries8.修改struts.xml<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration2.1//EN" "/dtds/struts-2.1.dtd"><struts><constant name="struts.devMode" value="true" /><constant name="struts.objectFactory" value="spring" /><constant name="struts.i18n.encoding" value="UTF-8" /><constant name="struts.i18n.reload" value="true" /><constant name="struts.configuration.xml.reload" value="false" /><constant name="struts.custom.i18n.resources" value="content/Language" /><constant name="struts.serve.static.browserCache" value="false" /><constant name="struts.action.extension" value="do,action,jhtml,," /><constant name="actionPackages" value="com.frank.action" /> </struts>9.在LoginAction.java中添加调用StudentService@Resourceprivate StudentService studentService;测试Student s = studentService.findById(1);System.out.println(s.getName());10.success.jsp中添加<hr /> ${password}11.启动tomcat,地址栏输入http://localhost:8088/farsighted/点击submit效果如下包结构如下12.测试完成.。

struts2入门教程一(环境搭建,基本案例实现)CSDN

Struts2入门初步需掌握1.struts2概述2.struts2环境搭建(第一个struts2的应用程序)3.struts.xml文件配置详解4.struts2请求的URL的搜索路径的顺序概述5.struts2工作原理概述6.struts2指定多个配置文件7.struts2动态方法调用8.使用通配符定义action一：简介Struts 2是Struts的下一代产品，是在 struts 1和WebWork的技术基础上进行了合并的全新的Struts 2框架。

其全新的Struts 2的体系结构与Struts 1的体系结构差别巨大。

Struts 2以WebWork为核心，采用拦截器的机制来处理用户的请求，这样的设计也使得业务逻辑控制器能够与Servlet API完全脱离开，所以Struts 2可以理解为WebWork的更新产品。

虽然从Struts 1到Struts 2有着太大的变化，但是相对于WebWork，Struts 2的变化很小。

二：环境搭建搭建Struts2环境时，我们一般需要做以下几个步骤的工作：1.找到开发Struts2应用需要使用到的jar文件.下载官网：/download.cgi#struts221解压后：开始学习使用依赖的最基本的jar 包2：编写Struts2的配置文件解压其中一个案例在此目录下找到struts.xml 文件先拷贝到项目的src 下。

再对起进行修改。

删除剩余如下代码：[html]01.<?xml version ="1.0"encoding ="UTF-8" ?> 02.<!DOCTYPE struts PUBLIC 03."-//Apache Software Foundation//DTD StrutsConfiguration 2.3//EN" 04."/dtds/struts-2.3.dtd"> 05.06.<struts> 07.08. </struts>无法加载插件。

Struts2详细实例教程

Struts2（上）一、经典的MVC模式二、Struts1.x对MVC的实现三、Struts1.x的主要组件和作用组件作用ActionServlet 中央控制器Action 分控制器，调用JavaBean实现业务逻辑，Action可以分为Action、DispatchAction等不同类型ActionForm 封装参数，实现服务器验证，文件上传等Forward 转发到目的地，可以是JSP，也可以是另一个ActionStruts-config.xml 配置文件，配置有ActionForm,Action,Forward等，通过XML解析，然后使用反射技术使用该文件Struts标签库和JSTL类似，和Struts-config.xml、ActionForm、Action等对象可以紧密集成四、Struts1.x 开发实例-登录程序见案例。

五、Struts2（WebWork）的MVCStruts2的MVC架构六、Struts2的主要组件组件作用FilterDispatcher 起中央控制器作用的过滤器Action 处于Model层的Action，调用JavaBean实现业务逻辑struts.xml 核心配置文件，配置有Action、Result等result 和forward类似，转发的目的地，支持多种视图技术。

七、Struts2的实例-登录在MyEclipse环境中建立一个新的web工程，名称“Struts2Login”，存放路径“f:\Struts2Login”。

在Struts2.0.11版本中找到war包struts2-blank-2.0.11.war，解开该war包，在WEB-INF/lib 目录下复制出所有的jar包，这些jar包就是一个Struts2程序所需要的基础jar包，把它们复制到新建的web工程的WEB-INF/lib目录中。

在src目录下建立一个类，包名mypack，类名UserAction，其代码如下：package mypack;import com.opensymphony.xwork2.ActionSupport;public class UserAction extends ActionSupport {private String username;private String userpass;public String getUsername() {return username;}public void setUsername(String username) {ername = username;}public String getUserpass() {return userpass;}public void setUserpass(String userpass) {erpass = userpass;}@Overridepublic String execute() throws Exception {if ("Mike".equals(username) && "123".equals(userpass)|| "张三".equals(username) && "abc".equals(userpass))return "success";elsereturn "error";}}在src目录下建立Struts2的配置文件struts.xml，内容如下：<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE struts PUBLIC"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN""/dtds/struts-2.0.dtd"><struts><package name="actions" extends="struts-default"><action name="login" class="erAction"><result name="success">/Success.jsp</result><result name="error">/Error.jsp</result></action></package></struts>修改web.xml，在其中加入一个过滤器，过滤/*路径。

第一章Struts2系统架构

第一章Struts2系统架构本章主要介绍的Struts2的系统架构，让学员对Struts2框架在结构上有一个整体概念为我们以后更加详细的学习Struts2打下一个良好的基础。

第一节Struts2的系统架构及处理的主要流程1．Struts1简介Struts1的历史比较久远，Struts1是世界上第一个发布的MVC框架，目前市场率最高的框架。

下面将简单讲解Struts1的基本架构。

图1-1显示了Struts1的数据流图。

图1-1 Struts1数据流图Struts1框架以ActionServlet为核心控制器，ActionServlet获得客户端请求。

然后ActionServlet根据请求信息调用匹配的业务逻辑控制器（Action）处理用户请求。

请求处理完成后，业务逻辑处理器调用相应的JSP显示处理结果。

Struts1框架实现了MVC模式，下面我们了解一下Struts1是怎样实现MVC模式的。

Struts1框架中并没有提供Model层的实现。

在实际的企业应用中，通过一个JavaBean 实现一个业务逻辑，在功能比较复杂的应用中也采用EJB或WebService服务实现业务逻辑。

Struts1框架的View层采用JSP实现。

Struts1提供了大量丰富的标签库。

这些标签库与Struts的组件兼容的特别好，可以很容易的输出控制器的处理结果。

Struts1框架中，控制器是它的核心，Struts1的控制器由两部分组成：核心控制器（ActionServlet）和业务逻辑控制器（Action），核心控制器由Struts1框架提供。

业务逻辑控制器需要由用户自己继承Struts1框架提供的Action类实现。

在Struts1框架中，JSP/Servlet耦合非常紧密。

这种紧密关系促使Struts1存在各种缺陷。

下面我们分析一下Struts1中存在的缺陷。

●支持的表现层技术单一●耦合性强，不便于单元测试●代码依赖于Struts1 API，侵入性强2．WebWork简介WebWork出自于开源组织opensymphony，实际的创始人是Java领域的名人Rickard Oberg(JBoss和XDoclet的作者)。

Struts+Spring+Hibernate整合入门详解

3、运行eclipse，选择一个空目录作为工作区（工程结构如下：其中我们要写的Java代码在Java Resource: src（以后直接称src）下，网站根目录内容在WebContent下，类所在根目录是WEB-INF/classes，Eclipse 会自动将build/classes里面已经编译的类同步过去。

向WEB-INF下的lib目录添加如下所列的jar包。

（1）这些包在下载解压后Spring，Struts，Hibernate的lib目录或者dist/module目录下面（如果不在，可以到网上google一把。

列表中mysql-*.jar包是MySQL数据库的JDBC Driver）。

也可以把所有lib和dist 下的jar包拷贝过来（可以在系统复制这些jar包，然后到Eclipse里面选中WEB-INF里面的lib包，然后粘帖就可以了）。

但要注意全拷贝可能会存在冲突，如struts*plugin.jar等包不能引入，否则不能运行。

（2）这些Jar包是：antlr-2.7.2.jarcglib-nodep-2.1_3.jarcommons-beanutils-1.6.jarcommons-chain-1.1.jarcommons-collections-2.1.1.jarcommons-dbcp.jarcommons-digester.jarcommons-logging-1.0.4.jarcommons-logging-api-1.1.jarcommons-pool.jarcommons-validator-1.3.0.jardom4j-1.6.1.jarel-api.jarel-ri.jarfreemarker-2.3.8.jarhibernate3.jarjsf-api.jarjta.jarmysql-connector-java-3.0.14-production-bin.jarognl-2.6.11.jaroro-2.0.8.jarspring-hibernate3.jarspring.jarstruts-config.xmlstruts-core-1.3.5.jarstruts2-codebehind-plugin-2.0.9.jarstruts2-config-browser-plugin-2.0.9.jarstruts2-core-2.0.9.jarstruts2-jasperreports-plugin-2.0.9.jarstruts2-jfreechart-plugin-2.0.9.jarstruts2-jsf-plugin-2.0.9.jarstruts2-pell-multipart-plugin-2.0.9.jarstruts2-plexus-plugin-2.0.9.jarstruts2-sitegraph-plugin-2.0.9.jarstruts2-sitemesh-plugin-2.0.9.jarstruts2-spring-plugin-2.0.9.jarstruts2-struts1-plugin-2.0.9.jarstruts2-tiles-plugin-2.0.9.jartiles-api-2.0.4.jartiles-core-2.0.4.jartiles-jsp-2.0.4.jarindex.jsp的内容如表，我们暂时不分析。

struts2+spring+hibernate整合步骤

引用struts2、hibernate、spring所需jar包struts-core-2.x.x.jar ----struts核心包xwork-core-2.x.x.jar -----身体ruts在其撒很难过构建ognl-2.6.x.jar ----对象导航语言freemarker-2.3.x.jar ------struts2的ui标签的模板使用commons-fileupload-1.2.x.jar ----文件上传组件 2.1.6版本后需加入此文件struts-spring-plugin-2.x.x.jar ---用于struts2继承spring的插件hibernate核心安装包下的（下载路径：/ ，点击Hibernate Core 右边的download）hibernate2.jarlib\bytecode\hibernate-cglib-repack-2.1_3.jarlib\required\*.jarhibernate安装包下的（下载路径：/;点击Hibernate Annotations 右边的下载）hibernate-annotations.jarlib\ejb3-persistence.jar、hibernate-commons-annotations.jar hibernate针对JPA的实现包（下载路径：/ ，点击Hibernate Entitymanager右边下载）hibernate-entitymanager.jarlib\test\log4j.jar、 slf4j-log4j12.jarspring安装包下的dist\spring.jarlib\c3p0\c3p0-0.9.1.2.jarlib\aspecti\aspectjweaver.jaraspectjrt.jarlib\colib\cglib-nodep-2.1_3.jarlib\j2ee\common-annotations.jarvlib\log4j\log4j-1.2.15.jarlib\jakarta-commons\commons_loggin.jar数据库驱动包引用创建mysql数据库ssh 设置编码为utf-8 语句：create database ssh character set 'utf8' collate 'utf8_general_ci'引用1.先整合spring和hibernate*将spring和hibernate的jar包放入lib下；*创建spring的beans.xml配置文件Java代码1.<?xml version="1.0" encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3. xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"4. xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"5. xsi:schemaLocation="/schema/beans6./schema/beans/spring-beans-2.5.xsd7. /schema/context8./schema/context/spring-context-2.5.xsd 9. /schema/aop/schema/aop/spring-aop-2.5.xsd10. /schema/tx/schema/tx/spring-tx-2.5.xsd">11.12. 13. 16. <context:component-scanbase-package="com.yss"></context:component-scan>17.18.19. 20. 21. <bean id="dataSource"class="boPooledDataSource"22. destroy-method="close">23. <property name="driverClass"value="org.gjt.mm.mysql.Driver" />24. <property name="jdbcUrl"25.value="jdbc:mysql://localhost:3306/ssh?useUnicode=true&characterE ncoding=UTF-8" />26. <property name="user" value="root" />27. <property name="password" value="root" />28. <!--初始化时获取的连接数，取值应在minPoolSize与maxPoolSize 之间。

ssh三大框架整合

ssh三⼤框架整合Hibernate框架 1 hibernate核⼼配置⽂件（0）orm思想 - 对象关系映射（1）数据库信息（2）hibernate信息（3）映射配置（4）hibernate核⼼配置⽂件 - 如果单纯使⽤hibernate框架，核⼼配置⽂件名称 hibernate.cfg.xml和位置 src下⾯固定的 - hibernate和spring整合时候，hibernate核⼼配置⽂件名称和位置没有固定要求的 2 hibernate映射配置⽂件（1）实体类和数据库表映射关系—使⽤orm思想 3 hibernate操作的步骤（1）在spring框架对hibernate框架进⾏封装，使⽤hibernateTemplateStruts2框架 1 Action操作（1）action创建三种⽅式 - 继承类 ActionSupport （2）配置action访问路径 - 创建struts.xml配置⽂件，这个⽂件名称和位置固定 src下⾯的（3）配置访问action的多个⽅法 - 使⽤通配符⽅式配置（4）在action获取表单提交数据 - 获取request对象 ** 使⽤ServletActionContext类获取 - 属性封装 - 模型驱动（重点） - 表达式封装（5）在action操作域对象 - 使⽤ServletActionContext获取域对象（6）配置struts2的过滤器 2 值栈（1）向值栈放数据 - set⽅法 - push⽅法 - 定义变量，⽣成get⽅法（2）从值栈获取数据 - 在jsp中使⽤struts2标签+ognl获取 - <s:property> - <s:iterator> 3 拦截器（1）aop和责任链模式（2）⾃定义拦截器 - 继承MethodFilterInterceptor - 重写类⾥⾯的⽅法 - 配置拦截器和action关联Spring框架 1 spring核⼼配置⽂件（1）名称和位置没有固定要求（2）在spring核⼼配置⽂件中引⼊schema约束 2 创建对象（1）xml配置⽅式：<bean id=”” class=”” scope=””/> （2）注解⽅式：四个注解 3 注⼊属性(对象类型属性) （1）xml配置⽅式：（2）注解⽅式：两个注解 - autowired - resource 3 使⽤ServletContext对象和监听器实现（1）在服务器启动时候，加载spring配置⽂件，创建对象（2）配置spring的监听器（3）指定spring配置⽂件位置 4 jdbcTemplate 5 spring事务配置（1）xml⽅式（2）注解⽅式SSH框架整合思想 1 三⼤框架应⽤在javaee三层结构 2 struts2框架和spring整合（1）struts2的action在spring配置 3 spring框架和hibernate框架整合（1）hibernate的sessionFactory交给spring配置（2）把hibernate数据库配置交给spring配置整合struts2和spring框架 1 把struts2的action交给spring管理 2 实现过程第⼀步导⼊struts2的jar包（1）导⼊⽤于整合的jar包（log4j.properties为log4j的⽇志输出格式，放⼊src下⾯）（2）Spring为了整合Struts还需要额外再导⼊⼀个jar包：（该包在struts的lib⽬录下）（3）导⼊Struts2的jar包（struts2版本为2.3.24）：（4）创建Actionpublic class UserAction extends ActionSupport {public String execute() throws Exception {System.out.println("Success....");return NONE;}} （5）创建Strut2的核⼼配置⽂件<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts PUBLIC"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN""/dtds/struts-2.3.dtd"><struts><package name="demo" extends="struts-default" namespace="/"><action name="userAction" class="erAction"></action></package></struts> （6）在web.xml中配置struts2的过滤器<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>/*</url-pattern></filter-mapping> （7）导⼊Spring整合Web项⽬的jar包，也就是监控项⽬启动的监听器所在的jar包（8）创建Spring的核⼼配置⽂件并在其中引⼊约束<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd/schema/aop/schema/aop/spring-aop.xsd/schema/tx/schema/tx/spring-tx.xsd"></beans> （9）把action交给Spring进⾏配置1 2 3 <bean id="userAction" class="erAction" scope="prototype"></bean> ①在spring配置action对象，在struts.xml中也配置action对象 ②解决：只需要在spring⾥⾯配置action对象，不要在struts.xml中配置<struts><package name="demo1" extends="struts-default" namespace="/"><action name="userAction" class="userAction"></action></package></struts> 可以这样写的原因是我们导⼊了⼀个Spring整合Struts2的jar包：struts2-spring-plugin-2.3.24.jar （10）web.xml中Spring监听器的配置<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:bean.xml</param-value></context-param> （11）测试准备 ①所需的为Struts2的核⼼配置⽂件：struts.xml ②Spring的配置⽂件：bean.xml ③项⽬的配置⽂件：web.xml ④Struts2的UserAction类 ⑤在UserAction中对UserService的调⽤ ⑥UserService中对UserDao的调⽤ ⑦UserDao类的编写struts.xml<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts PUBLIC"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN""/dtds/struts-2.3.dtd"><struts><package name="demo1" extends="struts-default" namespace="/"><action name="userAction" class="userAction"></action></package></struts>bean.xml<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd/schema/aop/schema/aop/spring-aop.xsd/schema/tx/schema/tx/spring-tx.xsd"><bean id="userAction" class="erAction"><property name="userService" ref="userService"></property></bean><bean id="userService" class="erService"><property name="userDao" ref="userDaoImp"></property></bean><bean id="userDaoImp" class="erDaoImp"></bean></beans>web.xml<?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="/2001/XMLSchema-instance" xmlns="/xml/ns/javaee" xsi:schemaLocation="/xml/ns/javaee /xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" <display-name>spring-day4-ssh</display-name><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:bean.xml</param-value></context-param><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>/*</url-pattern></filter-mapping><welcome-file-list><welcome-file>index.html</welcome-file><welcome-file>index.htm</welcome-file><welcome-file>index.jsp</welcome-file><welcome-file>default.html</welcome-file><welcome-file>default.htm</welcome-file><welcome-file>default.jsp</welcome-file></welcome-file-list></web-app>UserAction.javaimport com.opensymphony.xwork2.ActionSupport;import erService;public class UserAction extends ActionSupport {private UserService userService;public void setUserService(UserService userService) {erService = userService;}public String execute() throws Exception {userService.add();return NONE;}}UserService.javapublic class UserService {private UserDao userDao;public void setUserDao(UserDao userDao) {erDao = userDao;}public void add() {userDao.add();}}UserDao.java 其实现类public class UserDaoImp implements UserDao {public void add() {System.out.println("UserDaoImp....");}} （12）测试结果：可以在后台观察到如下测试结果：image ⾄此，Spring和Struts2的整合已经完毕，然后是Spring对Hibernate的整合了。

struts2+hibernate+spring经典整合实例教程

Struts2与Spring、Hibernate三者整合的过程示例：示例工具：MyEclipse 7.0、Tomcat 6.0、MySql步骤：1.创建一个WEB工程，命名为BookShop（名字自己取，此处为示例工程名）；2.导入struts2的核心jar包，也就是在WEB-INF下的lib文件夹中放入jar包文件，如下图（图中jar包为示例版本）：3.加载spring，选中工程名，右击并选择【MyEclipse】选项下的【Add Spring Capabilities...】（或者在工具栏中选择【MyEclipse】下的【Add Spring Capabilities...】），在弹出的对话框中进行如下图所示操作：点击【Next】，点击Folder文本框后的【Browse】，在弹出对话框中选择spring配置文件存储位置为WEB-INF 文件夹，如下图所示：点击【OK】后，再点击【Finish】完成。

至此，已经完成加载spring，在WEB-INF文件夹下已经生成了配置文件applicationContext.xml。

4.加载Hibernate，选择【MyEclipse】下的【Add Hibernate Capabilities...】，在弹出对话框中进行如下图所示操作：点击【Next】后，选择Existing Spring configuration file单选框，在SessionFactory Id文本框中填入"sessionFactory"，如下图所示：点击【Next】，进行如下图所示操作：该操作中，只需在Bean Id文本框中输入一个Id名，作为数据库源的代用名，意义不大。

然后在DB Driver 下拉列表中，选择MyEclipse中创建好的数据库源xiaoqi，其他信息将自动填写。

点击【Next】，在弹出对话框中去掉Create SessionFactory class?复选框，不创建该类，点击【Finish】完成（创建过程中，加载的jar包文件可能有重复，所以这个时候如果提示有某些jar包重复，问全部保存【Keep Exiting】，还是替换掉【Replace】，可以选择替换掉【Replace】）。

struts2+spring+hibernate三大框架环境搭建小小总结

struts2+spring+hibernate三大框架环境搭建小小总结：一、环境搭建导入各种jar包什么的就不多说了。

二、整个包结构及模式：1、src文件下，由panyname组成一个大的包结构和各项配置文件组成2、companyname下，分成两部分：A、model层B、功能层3、model层下，包含整个项目所要的数据库表名，按照功能来命名包的名称，A、功能包下包含对应的数据库表的java类，里面包含对应数据库表中所有的字段以及get，set方法B、功能包下包含对应的数据库表的hbm.xml类，里面包含对应数据库表中所有字段的定义4、功能层下，可以只有一个功能模块的一个结构，也可以有多个功能模块的包结构，再在包结构下细分到功能模块的结构A、一个完整的功能模块包下包含：action，dao，service层，1>、对应的action层包含对应功能实现的Action类；2>、对应的dao层包含对应功能实现的数据库操作类；3>、对应的service层包含对应功能实现的各service接口；5、各项配置文件：A、首先包含三个大的配置文件：applicationContext.xml，struts.xml，jdbc.propertiesB、applicationContext.xml实现依赖注入，struts.xml实现各响应功能的配置，jdbc.properties配置数据库相关属性三、页面1、所有的页面，js包都放到WebRoot目录下，2、要配置web.xml文件3、所有的jar包放到WebRoot-WEB-INF-lib包下四、功能操作1、定义好model层，配置好对应的model.hbm.xml映射文件2、将对应的model.hbm.xml映射文件映射到applicationContext.xml文件中3、页面中对应的跳转，实现action，到struts-function.xml去增加对应的Action类和方法4、将struts-function.xml映射文件映射到struts.xml映射文件中5、在功能层下建立对应的功能包，包下包含action，dao，service三个层6、根据struts-function.xml映射文件，建立对应的Action类，在类中创建对应的方法7、在service层和dao层下分别建立对应的接口层和实现接口类8、在对应的applicationContext-function.xml映射文件中将dao层方法映射到对应的service 层中9、service层中，包含iservice层和实现iservice层的service10、在service类中实现对应的iservice定义的方法，并return这个dao对象的方法，11、根据这个方法，在idao接口中创建对应的方法，在dao层的实现类中来具体实现方法的业务12、dao层实现之后，将在Action中调用对应的dao层实现的方法，然后保存结果返回到对应的界面去13、至此，简单的一个业务就实现了。

Struts+Spring+Hibernate框架的开发

ＳＦＷＲＥＥ０ＭＮＮＥＩ０ｒＡＥＶＬＰＥＴＤＤＳＮＤＡＧ
软件开发与设计
ＳｕｓＳｒｇＨｂｒａ框架的开发ｔｔｐｉ＋ｉｅｎｔｒ＋ｎｅ
嵇可可
（江苏食品职业技术学院计算机应用技术系，淮安２３０）２０３摘要：ＳｕｓＳｒｇＨｂｒａｅｔｔｐｉ＋ｉｅｎｔ组成了一个功能强大的应用开发平台，在此介绍了它们的组成、特点及功能。ｒ＋ｎ
关键词：框架；ａａ；ｔｔＳｒｇ；ｉｅａｅＪｖＳｒｓ；ｐｉｕｎＨｂｒｔｎ
ＴｅＤｅｅｏｍｅｔｆＳｒｔＳｒｇ＋ＨｉｅａｅＦｈｖｌｐｎｔｕｓ＋ｐｉｏｎｂｒｔ￣ｍｅｒｎｗｏｋ
ＪＩＸｄ∞
构建的Ｗｅ统架构如图１示。ｂ系所
图２ｔｔ处理流程图Ｓｕｒｓ
（）业务逻辑返回后，ＡｔｎＣａｓ３ｃｏｌ根据处理结果决定跳ｉｓ
转到哪个Ｊｐ页面，ＡｔｎＣａｓ只需指定Ｊｐ逻辑上的名ｓｃｏｌｓ中ｉｓ
Ｓｒｔ向开发人员提供了统一的体系结构，在此基础上开发人ｔｓｕ
员可以集中精力关注具体的业务逻辑的实现，而不必顾虑体系结构的问题，从而提高开发效率和开发质量。
２Ｓｒｇ框架ｐｉｎ
Ｓｒｇ一个基于ＪＥｐｎ是ｉ２Ｅ平台的分层的应用程序框架，为
体系。考虑到应用的特点，我们选用Ｓｒｇ作为基础架构，ｐｎｉ通过ＳｒｇＩＣ容器提供基础服务，并整合ＷｅｐｉＯｎｂ框架Ｓｒｔｔｓｕ和持久层框架Ｈｂｒａ，组成一个功能强大的应用开发平台。ｉｅｎｔｅ该开发平台具有通用性，可以广泛应用于应用系统的开发中，利于开发高质量的系统。基于Ｓｒｔ、ＳｒｇＨｉｅａｔｓｐｎ和ｂｒｔｕｉｎｅ框架

Struts2.3.1.2+Spring3.3.1+Hibernate4.1.1 配置步骤

一．搭建struts-2.3.1.21.Jar包：2.配置struts2.3的过滤器，web.xml位置3.web.xml<?xml version="1.0"encoding="UTF-8"?><web-app id="WebApp_ID"version="3.0"xmlns="/xml/ns/javaee"xmlns:xsi="/2001/XMLSchema-instance" xmlns:web="/xml/ns/javaee/web-app_2_5.xsd "xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_3_0.xsd"><filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.ng.filter.Struts PrepareAndExecuteFilter</filter-class></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping></web-app>4.配置struts.xml<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE struts PUBLIC"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN""/dtds/struts-2.3.dtd"><struts><package name="ssh"extends="struts-default,json-default,jfreechart-default,s pring-default"><action name="login"class="loginAction"><result name="ok">/loginOk.jsp</result><result name="error">/loginError.jsp</result></action></package></struts>5.测试struts二．整合Spring 3.1.1和Struts-2.3.1.21.jar包在配置好的strutsjar的基础上，添加额外Struts jar包：struts2-spring-plugin-2.3.1.2.jarcommons-logging-1.1.1.jarSpring的jar包：org.springframework.core-3.1.1.RELEASE.jarorg.springframework.context-3.1.1.RELEASE.jarorg.springframework.beans-3.1.1.RELEASE.jarorg.springframework.asm-3.1.1.RELEASE.jarorg.springframework.expression-3.1.1.RELEASE.jarorg.springframework.web-3.1.1.RELEASE.jar2.web.xml<?xml version="1.0"encoding="UTF-8"?>web-app id="WebApp_ID"version="3.0"xmlns="/xml/ns/javaee"xmlns:xsi=/2001/XMLSchema-instancexmlns:web="/xml/ns/javaee/web-app_2 _5.xsd"xsi:schemaLocation="/xml/ns/javaee /xml/ns/javaee/web-app_3_0.xsd"><filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.ng.filter.Str utsPrepareAndExecuteFilter</filter-class></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><context-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/classes/applicationContext.xml</par am-value></context-param></web-app>3.配置springapplicationContext.xml<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xmlns:tx="/schema/tx"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/tx/schema/tx/spring-tx-3.0.xsd/schema/aop/schema/aop/spring-aop-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd"> <context:annotation-config /><context:component-scan base-package="com.excel" /></beans>三．整合Hibernate4.1.11.jar包添加Hibernate jar文件Hibernate压缩包中的lib/required/antlr-2.7.7.jardom4j-1.6.1.jarhibernate-commons-annotations-4.0.1.Final.jarhibernate-core-4.1.1.Final.jarhibernate-jpa-2.0-api-1.0.1.Final.jarjavassist-3.15.0-GA.jarjboss-logging-3.1.0.GA.jarjboss-transaction-api_1.1_spec-1.0.0.Final.jar lib/jpa/hibernate-entitymanager-4.1.1.Final.jarlib/optional/c3p0/hibernate-c3p0-4.1.1.Final.jarc3p0-0.9.1.jarSpring中的jar文件org.springframework.aop-3.1.1.RELEASE.jarorg.springframework.jdbc-3.1.1.RELEASE.jarorg.springframework.orm-3.1.1.RELEASE.jarorg.springframework.transaction-3.1.1.RELEASE.jar 其他的Spring支持文件aopalliance.jar -- AOP要用到的jar包以及连接db2的jarDb2jcc.Jar以及支持el表达式的standard.jar2.配置文件<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:jee="/schema/jee"xmlns:tx="/schema/tx"xmlns:aop="/schema/aop"xmlns:p="/schema/p"xmlns:util="/schema/util"xmlns:tool="/schema/tool" xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd/schema/tx/schema/tx/spring-tx.xsd/schema/aop/schema/aop/spring-aop.xsd/schema/jee/schema/jee/spring-jee.xsd/schema/context/schema/context/spring-context.xsd /schema/util/schema/util/spring-util.xsd/schema/tool/schema/tool/spring-tool.xsd"default-lazy-init="true"default-autowire="byName"> <bean id="dataSource"class="boPooledDataSource"destroy-method="close"><property name="driverClass"value="com.ibm.db2.jcc.DB2Driver" /><property name="jdbcUrl"value="jdbc:db2://192.168.1.35:50000/ZL_DEMO"/><property name="user"value="db2admin"/><property name="password"value="Forwor888"/></bean><bean id="sessionFactory"class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"><property name="dataSource"><ref local="dataSource"/></property><property name="hibernateProperties"><props><prop key="hibernate.show_sql">true</prop><prop key="hibernate.format_sql">true</prop><propkey="hibernate.dialect">org.hibernate.dialect.DB2Dialect</prop> </props></property><property name="mappingResources"><list><value>com/forwor/ssh/entity/xml/User.hbm.xml</value></list></property></bean><bean id="userDAO"class="erDAOImpl"> <property name="sessionFactory"><ref local="sessionFactory"/></property></bean><bean id="userBiz"class="erBizImpl"> <property name="userDAO"><ref local="userDAO"/></property></bean><bean id="transactionManager"class="org.springframework.orm.hibernate4.HibernateTransactionManager "><property name="sessionFactory"><ref local="sessionFactory"/></property></bean><bean id="transactionInterceptor"class="org.springframework.transaction.interceptor.TransactionInterce ptor"><property name="transactionManager"><ref local="transactionManager"/></property><property name="transactionAttributes"><props><prop key="register">PROPAGATION_REQUIRED</prop><prop key="get*">PROPAGATION_REQUIRED,readOnly</prop><prop key="find*">PROPAGATION_REQUIRED,readOnly</prop><prop key="select*">PROPAGATION_REQUIRED,readOnly</prop><prop key="query*">PROPAGATION_REQUIRED,readOnly</prop><prop key="sync*">PROPAGATION_REQUIRED</prop><prop key="finish*">PROPAGATION_REQUIRED</prop><prop key="add*">PROPAGATION_REQUIRED</prop><prop key="insert*">PROPAGATION_REQUIRED</prop><prop key="edit*">PROPAGATION_REQUIRED</prop><prop key="update*">PROPAGATION_REQUIRED</prop><prop key="save*">PROPAGATION_REQUIRED</prop><prop key="remove*">PROPAGATION_REQUIRED</prop><prop key="delete*">PROPAGATION_REQUIRED</prop><propkey="*">PROPAGATION_REQUIRED,ng.Exception</prop></props></property></bean><bean id="ProxyCreator"class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyC reator"><property name="beanNames"><list><value>*Biz</value></list></property><property name="interceptorNames"><list><value>transactionInterceptor</value></list></property></bean><bean id="loginAction"class="com.forwor.ssh.web.LoginAction" scope="prototype"><property name="userBiz"><ref local="userBiz"/></property></bean></beans>。

Eclipse下SSH2框架搭建详细

一、Struts2和Spring整合,创建一个OA工程1、整合struts21)导入strut2的jar 包:commons-logging-1.0.4.jar,freemarker-2.3.8.jar,ognl-2.6.11.jar,struts2-core-2.0.12.jar,xwork-2.06.jar。

暂时导入这些jar包，到时候需要再倒入。

2)将struts.xml文件放置在OA工程的src目录下。

3)在web.xml里面配置struts2用到的核心过滤器。

Xml代码<filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping>2、整合spring1)导入spring的jar包:spring.jar2)将applicationContext.xml文件放置在OA工程的WEB-INF目录下。

3)在web.xml里面配置spring用到的监听器。

Xml代码<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener>4)添加struts2-spring整合的插件:struts2-spring-plugin-2.0.12.jar,如果不使用这个插件，则需要在struts.xml里面配置:Xml代码<constant name="struts.objectFactory" value="org.apache.struts2.spring.StrutsSpringObjectFactory" />3、测试struts2和spring整合对不对?写一个jsp页面login.jsp来测试:Html代码<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%><%@ taglib prefix="s" uri="/struts-tags" %><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "/TR/html4/loose.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Insert title here</title></head><body><s:form action="Login" method="post"><s:textfield name="userName" label="userName"></s:textfield><s:password name="password" label="password"></s:password><s:submit label="submit"></s:submit></s:form></body></html>写一个LoginActionJava代码package com.struts2.action;import com.opensymphony.xwork2.ActionSupport;import com.struts2.service.LoginService;public class LoginAction extends ActionSupport {private LoginService loginService;private String userName;private String password;public void setLoginService(LoginService loginService) {this.loginService = loginService;}public String getUserName() {return userName;}public void setUserName(String userName) {erName = userName;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}@Overridepublic String execute() throws Exception {if(loginService.isLogin(userName, password))return SUCCESS;elsereturn INPUT;}}写一个ServiceJava代码package com.struts2.service;public interface LoginService {boolean isLogin(String userName,String password);}写一个Service的实现Java代码package com.struts2.service.impl;import com.struts2.service.LoginService;public class LoginServiceImpl implements LoginService {public boolean isLogin(String userName, String password) { if("hello".equals(userName) && "world".equals(password)) return true;elsereturn false;}}在struts.xml里面配置:Xml代码<package name="struts2" extends="struts-default"><action name="Login" class="loginAction"><result name="success">/result.jsp</result><result name="input">/login.jsp</result></action></package>在applicationContext.xml里面配置:Xml代码<bean id="loginService" class="com.struts2.service.impl.LoginServiceImpl"></bean><bean id="loginAction" class="com.struts2.action.LoginAction" scope="prototype"> <property name="loginService" ref="loginService"></property></bean>启动tomcat，分别输入hello和world，提交,结果为hello和world。

SSH开发模式——Struts2（第一小节）

SSH开发模式——Struts2（第⼀⼩节）在制定了学习计划的学习过程中，我感觉学习还是很有效率的。

很短的时间内，我便学习完了JavaWeb的连接池、DbUtils框架及其⼀些⼯具类的使⽤。

学⽆⽌境，学习这些知识还远远不够，所以，在接下来的时间⾥，我将对JavaWeb中的SSH开发模式进⾏⼀个简单的学习，并⽤博客记录学习进度。

开发模式相信⼤家都有接触或听说，但⼜觉得这个东西很神秘，的确，这看不见摸不着的东西确实很让⼈好奇，所以，从今天开始，我将带着⼤家去揭开它神秘的⾯纱。

我会把整个开发模式分为三部分，第⼀部分：Struts2，第⼆部分：Hibernate，第三部分：Spring。

但是即使分为了三部分，每个部分的框架仍然略显复杂。

所以，我将在每部分的框架中继续细分。

那么，今天便开始第⼀部分的内容，Struts2。

⾸先了解⼀下Struts2的历史吧。

Struts1是全世界第⼀个发布的MVC框架在2001年发布Struts2并不是Struts1的升级版是由WebWork基础上发展起来的吸收了Struts 1和WebWork两者的优势那Struts2到底是什么呢？Struts2是⼀个⽤来开发MVC应⽤程序的框架。

它提供了Web应⽤程序开发过程中的⼀些常见问题的解决⽅案：页⾯导航活动的管理⽤户输⼊数据的合法性验证统⼀的布局可扩展性国际化和本地化⽀持Ajax表单的重复提交我们假设⼀个场景，在⼀个jsp页⾯中有多个超链接，点击每个超链接都需要进⾏对应的处理，每个超链接对应⼀个Java类，类中有⼀个⽅法，我们的⽬的就是要点击超链接调⽤对应的Java类的⽅法，对于这样的场景，我们有两种解决⽅案，⼀是通过Servlet去调⽤Java类，⼆是通过过滤器去调⽤Java类。

但是两种⽅法都很⿇烦，重复的代码特别多，这时候，Struts2框架就起到了⾄关重要的作⽤，它可以很⽅便地帮助我们解决这个问题。

那么，如何搭建Struts2的开发环境呢？搭建Struts2环境时，我们⼀般需要做以下⼏个步骤的⼯作：1. 创建javaweb⼯程2. 找到开发Struts2应⽤需要使⽤到的jar⽂件3. 创建jsp⽂件4. 创建action⽂件5. 编写Struts2的配置⽂件6. 在web.xml中加⼊Struts2 MVC框架启动配置我们按照步骤⼀步步⾛。

第9章 Spring与Struts2、Hibernate框架的整合

第9章Spring与Struts2、Hibernate框架的整合基础一、搭建Struts框架注：导入的jar包与前面课程介绍的不同二、搭建Spring框架1.添加的类库包括AOP、Core、Persistent Core、JDBC、Web库2.修改applicationContext.xml的存储目录为WebRoot/WEB-INF三、搭建hibernate框架1.建立数据库连接2.搭建框架，注意选择的配置文件为applicationContext.xml而不是hibernate.cfg.xml。

1）设置SessionFactory的Bean id为sessionFactory。

2）设置DataSource的Bean Id为dataSource3）取消“Create SessionFactory class”选项4）导入包commons-pool-1.3到lib文件夹。

四、修改web.xml加入Spring监听器配置，至此所有框架搭建完毕。

<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener>五、数据库建表六、在工程下创建domain、dao包，反向工程自动生成实体类、配置文件、dao类。

1）反向工程将生成的dao文件2）移动dao类到dao包，修改由于移动dao类后applicationContext.xml出现的错误，并将id名首字母改成小写。

3）为dao类提取出接口。

在工作区右键dao文件-》refactor-》extract interface七、编写service、service接口并配置1）创建service包2）创建service类，定义方法findScoreBySnumber()。