SSH框架搭建

合集下载

ssh详解

ssh详解

SSH框架整合步骤详解SSH框架 2009-04-09 10:47:00 阅读611 评论0 字号:大中小订阅更系统地学习Struts1.x/Struts2.x+Hibernate+Spring,请学习该开源项目Appfuse终于,终于将SSH整合成功了,弄了几个小时,可以休息了(有的朋友弄了半个月,甚至重装了系统也没弄好,哎,庆幸啊)。

碰到问题千万不要放弃,要相信没有解决不了的问题!项目结构图:jsp部分为:index.jsp;success.jsp;fail.jspUserDAO.java,User.hbm.xml自动生成,HibernateSessionFactory 是多余的。

相关的配置文件、类文件详细信息,请参看Struts+Spring+Hibernate/SSH整合开发详细二以前是整过这三个框架的,可是工作期间都不曾用过,不知不觉之中,学的东西全忘了。

这次又要开始找工作了,看着招聘启事上都写着:要求熟练掌握Struts,Hibernate或Spring框架……,没得办法,重新学呗。

Spring in Action中文版下载地址(ftp协议)ftp://222.214.218.61/book5/20080228/cf8b35cc-5bcd-497 3-b6b7-37ae3ec78391.rar如果无法下载,可以在里重新搜索首先开始搭建项目环境,步骤如下:使用平台:MyEclipse 6.0框架版本:Struts 1.2 Hibernate 3.0 Spring 2.01>添加过程:<1> 新建项目。

Package Explorer视图下,右键单击 New -> Web Project;<2> 添加Struts框架。

菜单栏MyEclipse -> Capabilities,或者右键单击新建的项目名,选择快捷菜单中的"MyEclipse"下的二级菜单;设置相关的包名后,请写一个Struts的小例子,用来测试Struts是否可用;<3> 添加Spring。

SSH三大框架整合(详细版)

SSH三大框架整合(详细版)

1:构建WEB项目2:构建数据库3:加入依赖包尽量不要依赖IDE,通过自己手动加包完成访问数据库需要的包:mysql的驱动包Hibernate的包:hibernate3.jar 核心包依赖的必须包:antlr-2.7.6.jar 用于解析成HQL语句的包commons-collections-3.1.jar apache提供的包,提供对集合框架的增强dom4j-1.6.1.jar 解析XML文件的包javassist-3.9.0.GA.jar 动态修改字节码需要用到的包jta-1.1.jar 用于JTA事务的包slf4j-api-1.5.8.jar 日志接口包---》依赖一定的实现包slf4j-log4j12-1.5.0.jar log4j.jar另外一种实现包:slf4j-simple-1.5.10.jar可选的包:c3p0-0.9.1.jar 用于创建C3P0连接池的包ehcache-1.2.3.jar :用于缓存实现的包cglib-2.2.jar 动态修改字节码的包Spring的包:spring.jar 核心包aopalliance.jar 使用Aop功能可以用到的包aspectjrt.jaraspectjweaver.jar 使用ASPECTJ表达式需要用到的包如果是使用DBCP连接池的话,需要两个jar包commons-dbcp.jar commons-pool.jar如果需要用到commons增加包的话,可以加入以下包commons-beanutils.jar commons-lang.jar commons-logging.jarStruts2的包:commons-fileupload-1.2.1.jar commons-io-1.3.2.jarfreemarker-2.3.13.jar :在Struts2 中默认使用的是FreeMarker模板引擎ognl-2.6.11.jar :Struts2中使用OGNL表达式struts2-core-2.1.6.jar 核心包xwork-2.1.2.jar 核心包struts2-spring-plugin-2.1.6.jar Struts2跟Spring整合需要的插件包4:构建项目分包结构5:放置配置文件6:创建POJO和相对应的hbm.xml7:修改空白的Hibernate.cfg..xml并创建表结构8:创建DAO,SERVICE,ACTION9:修改配置文件并且按照模块的分布进行applicationContext文件的配置Struts.xml。

SSH框架说明文档

SSH框架说明文档

一、SSH整体介绍1. 简介本Demo程序采用的是SSH(Struts+Spring+Hibernate)三层架构。

(1)Struts用于表现层,负责页面数据提取,页面动作响应。

(2)Spring是一种轻量级的框架模型,主要负责业务逻辑层的对象创建,表现层的Action 的创建,以及持久层的DAO的创建。

(3)Hibernate负责把内存中的数据对象保存到数据库中。

2. 框架集成说明在SSH三层架构中,主要用Struts来实现对页面的响应及页面跳转。

当用户向服务器发送某一个请求,这个请求会被服务器(Tomcat)接收到,服务器会根据请求的内容,将这个请求发送给相应的Servlet实例进行处理。

Servlet会根据其内容,去生成相应的Action实例。

本程序中,Struts将Action的创建工作交给了Spring的代理类来完成,创建这个实例后,将这个实例注入,由Struts调用Action中的相应方法。

Action中可以配置一个或多个Service对象,Action调用Service中的方法进行业务处理。

Service中通常会有一个或多个DAO的对象,DAO 继承了Hibernate的接口,用来处理数据库的操作。

而Action,Service,DAO的创建与注入,都是由Spring的Bean工厂来实现的。

(1)Struts与Spring的集成✧在Web.xml中配置Struts的配置文件✧在Web.xml中配置Spring的配置文件,Bean工厂及过滤器✧在Struts配置文件中集成Spring的代理类✧在Spring配置文件中配置Action(2)Spring与Hibernate的集成✧在Web.xml中配置Hibernate延迟过滤器配置✧在Web.xml中配置Spring的配置文件,Bean工厂及过滤器✧在Spring配置文件中配置DAO✧在Hibernate配置文件中配置数据库信息✧在DAO的实现类中继承HibernateDaoSupport类3. 程序的包结构(1)表现层的类包,分别用来存放表现层的Form与Action。

搭建SSH框架(Struts1,Spring2.5,Hibernate3)

搭建SSH框架(Struts1,Spring2.5,Hibernate3)

搭建SSH框架:Struts1.* + Spring2.5 + Hibernate3.0 一,项目结构:图(1)Jsp页面省略,主要是一些添删改查的页面;二,开始搭建项目环境,步骤如下:使用平台:MyEclipse6.0/6.5框架版本:Struts1.* + Spring2.5 + Hibernate3.0;1,添加过程:1>,新建项目: 打开MyEclipse,在Package Explorer视图下,右键单击New-> Web Project;注意:在新建项目时,JDK的版本最好要选择Java EE 5.0;因为版本过低,可能有些JSP方面的功能不支持;新建玩项目之后,把该导的包导入到下面,下图为SS H 框架所需要的Jar包,注意,该项目用的是ORACLE数据库;其中,activation与mail这两个包为Java发邮件的包;classes12为Oracle数据库的驱动包,如果不是Oracle数据库,可更换该Jar包;dwe为Ajax dwr 框架中的包;2>,接着就开始用MyEclipse辅助开发Struts,Spring,Hibernate了;3>,首先MyEclipse辅助开发Struts,方法:右键单击你所建的项目,出现一级菜单,选择Myeclipse,选择Myeclipse之后会出现二级菜单,接着选择Add Struts Capabilities;;接着具体操作如下面图示:点击Finish按钮完成;完成之后,可将包删除;在上图中,如果那个勾没有去掉的话,就会自动生产如下标签:当然,如果你觉得标签对你没什么用的话,可以删除;如果该勾去掉的话,就只生成标签,这是Struts的核心标签;4>,MyEclipse辅助开发Spring,方法跟上面的一样,选择Add Spring apabilities;;接着具体操作如下面图示:然后点击Next,具体操作如下图:接着点击 Finish按钮,完成此项操作;5>,,最后MyEclipse辅助开发Hibernate,在执行和上面类似方法之前,Hibernate 需要先做另外一件事情,那就是和数据建立连接,具体操作如下图:点击上图位置的或者右边的>> ,然后再选择MyEclipse Database Explorer切换到如下图页面:,然后右键单击,新建一个Database Driver;如下图:下面这个截图是该项目的数据库链接图:如图所示,测试数据库链接成功;然后可直接点击Finish完成;接着切换到窗口,按照上面第三小步的方法,选择Add Hibernate apabilities;;接着具体操作如下面图示:点击下一步:点击下一步:点击下一步:点击下一步:点击 Finish 完成;6>,最后一步,就是运用Hibernate的映射机制,把数据库的表与JAVA的对形成一个关系映射;在此之前,首先应该在项目SRC的目录下面新建一个包,如该项目所示,用来存放映射生成的POJO对象以及映射文件;如下图:有一点说一下,你生成的*.hbm.xml文件可能不止一个,对,你可以把它们整合到一个文件中;然后新建按第五小步的方法,把窗口切换到MyEclipse Database Explorer界面,然后打开右键刚才所建立的链接,选择属于你自己的用户;然后选择Tble;右键选择如上图的属性:接下来的操作如下图:点击 Next,进入下一步:点击 Next,进入下一步:至此,项目环境己经搭建完成;三,项目搭建完成,SSH各个部分配置文件的说明,以及它们之间存在的关系:1,首先是Struts的核心配置文件,即struts-config.xml:<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN""/dtds/struts-config_1_2.dtd"><struts-config><data-sources /><form-beans><!—建立Form表单,在此处进行登记 -→<form-bean name="userForm"type="erForm" /> </form-beans><global-exceptions /><global-forwards /><!—各个Action对应与之相对应的表单 -→<action-mappings><!-- 用户管理 --><action parameter="opers" attribute="userForm" name="userForm"path="/doUser" scope="request"><forward name="login_ok" path="/welcome.jsp"></forward><forward name="login_no" path="/index.jsp"></forward> </action></action-mappings><controllerprocessorClass="org.springframework.web.struts.DelegatingRequestProc essor"></controller><message-resourcesparameter="ermanagerview.struts.ApplicationResources"> </message-resources><!—Spring辅助Struts管理Struts-→<plug-inclassName="org.springframework.web.struts.ContextLoaderPlugIn"><set-property property="contextConfigLocation"value="/WEB-INF/action-servlet.xml" /></plug-in></struts-config>2,其次就是Springd的applicationContext.xml文件和action-servlet.xml文件:applicationContext.xml文件:<?xml version="1.0" encoding="UTF-8"?><beansxmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-2.5.xsd"><!-- Session 工厂 --><bean id="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation"value="classpath:hibernate.cfg.xml"><!-- 可以不要配置文件(hibernate.cfg.xml),直接写在这个Spring的配置文件中 --></property></bean><!-- 模板 --><bean id="hibernateTemplate"class="org.springframework.orm.hibernate3.HibernateTemplate"><property name="sessionFactory" ref="sessionFactory" /> </bean><!-- 事务器 --><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManage r"><property name="sessionFactory" ref="sessionFactory" /> </bean><!-- 对外代理 --><!-- 1,用户管理 --><bean id="userDaoImp"class="erDaoImp"><property name="hibernateTemplate" ref="hibernateTemplate" /> </bean><bean id="userServiceTarget"class="erServiceImp"> <property name="userdao"><ref local="userDaoImp" /></property></bean><bean id="userService"class="org.springframework.transaction.interceptor.TransactionProxyF actoryBean"><property name="transactionManager"><ref local="transactionManager" /></property><property name="target"><ref local="userServiceTarget" /></property><property name="transactionAttributes"><props><prop key="*">PROPAGATION_REQUIRED</prop></props></property></bean></beans>action-servlet.xml文件:<!—Spring辅助Struts管理Struts-<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-2.0.xsd"> <bean name="/doUser"class="erAction"scope="prototype"></bean></beans>3,最后就是Hibernate的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"><!-- Generated by MyEclipse Hibernate Tools. --><hibernate-configuration><session-factory><property name="ername">wangxiaodong</property><property name="connection.url">jdbc:oracle:thin:@192.168.0.2:1521:ALIZEEDB</property><property name="dialect">org.hibernate.dialect.Oracle9Dialect</property><propertyname="myeclipse.connection.profile">Test</property><property name="connection.password">donny</property><property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property><mappingresource="com/ygkq/usermanager/model/entity/User.hbm.xml" /></session-factory></hibernate-configuration>该文件基本上不用动,都是自动生成的代码;当然,你也可以根据自己的需要添加代码,例如,你想在执行HQL语句的时候让它显示SQL语句,可将<property name="hibernate.show_sql">true</property>插入代码中;另外在图(1)中还有两个配置文件没有提到,那就是log4j.properties 与mytag.tld;其中log4j.properties是配置日志信息的;而mytag.tld主一个自定义标签;四,SSH框架搭建完成:SSH框架基本搭建完成,如果有不对或者不妥之处,请随时指教!~E-mail:jerry8059@。

SSH2详细(框架搭建)

SSH2详细(框架搭建)

struts2相关配置
struts.xml常用配置
为简化配置文件编写,struts2提供通配符支持,如下: <action name=“*” class=“com.demo.{1}Action”
method=“show”> </action>
同时,struts2还支持*/*的配置模式,在配置文件中 <struts>节点下配置如下:
第十三页,编辑于星期三:六点 八分。
整合spring后struts配置
struts.xml配置 在<struts>标签下配置: <constant name="struts.objectFacring"></constant> <constant
name="struts.objectFactory.spring.autoWire" value="name"></constant>
name: 可选 , 表示表的名称 . 默认地 , 表名和实体名称 一致 , 只有在不一致的情况下才需要指定表名
catalog: 可选 , 表示 Catalog 名称 , 默认为 Catalog(""). schema: 可选 , 表示 Schema 名称 , 默认为 Schema(“”). @id 必须 @id 定义了映射到数据库表的主键的属性 , 一个实体只能有
<param-value> classpath*:applicationContext*.xml
</param-value>
</context-param>
<listener>

SSH2框架的搭建及与SSH1的差别介绍(可编辑)

SSH2框架的搭建及与SSH1的差别介绍(可编辑)

SSH2框架的搭建及与SSH1的差别介绍SSH2框架搭建版本:struts2.1.6 spring2.5.6hibernate3.3.1SSH2与SSH1之简要比较SSH框架的优势开发效率高适应客户的需求随机变化SSH1框架的劣势繁琐的配置文件编写struts1.X Action线程安全,仅允许一个实例去处理所有请求Forward过于繁琐对Servlet依赖过强SSH2与SSH1之简要比较SSH2优势大量简化配置文件编写。

更大程度解耦合Struts不再依赖Servlet通配符配置注解使用struts2使用struts2借鉴webwork的成功之处,兼容struts1,集合两者优点,更易于整合spring及hibernate框架。

所需jar包:struts2相关配置web.xml文件配置与struts1不同,struts2采用Filter进行配置filter-namestruts/filter-namefilter-class //.uts2.//.ter.StrutsPrepareAndExecuteFilter/filter-classfilter-mappingfilter-namestruts/filter-nameurl-pattern*.do/url-pattern/filter-ma ppingstruts2相关配置struts.xml文件配置在项目src目录下添加struts.xml配置文件。

其基本配置如下:?xml version"1.0" encoding"UTF-8" ?!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "////.package name"default" extends"struts-default"namespace""struts2相关配置struts.xml常用配置为简化配置文件编写,struts2提供通配符支持,如下:action name“*” class“com.demo.1Action”method“show”同时,struts2还支持*/*的配置模式,在配置文件中节点下配置如下:constantname"//.shesInActionNames"value"true"则以上配置可改写为:action name“*/*” class “com.demo.1Action”method“2”struts2相关配置struts.xml常用配置struts2默认访问后缀为.action,不符合访问习惯,且过于繁琐,可在标签下配置如下:constantname"//.ension"value"do"则可使用习惯的.do方式访问整合spring框架添加spring核心包及struts2-spring-plugin-2.1.6.jar。

SSH框架搭建

SSH框架搭建

MyEclipse开发SSH框架搭建(Struts+Spring+Hibernate)1.1. 新建工程操作:[Menu] File/New/Web Project工程名:school2. Struts 部分2.1. 添加Struts 功能支持操作:选1.3将Base package for new classes改为com.dp.school 2.2. 创建ActionForm 类操作:[Ctrl+N] MyEclipse/Web-Struts/Struts 1.3 Form 类名:LoginFormuserCase:LoginForm type: com.dp.school.actionForm.LoginForm在“Form Properties” 选项卡为loginForm 新增两个属性:userName、password;在“JSP” 选项卡钩选“Create JSP form” 选项,将新建路径改为“/user/login.jsp”(login.jsp文件将被自动创建)。

2.3. 创建Action 类操作:[Ctrl+N] MyEclipse/Web-Struts/Struts 1.3 Action类名:LoginActionuserCase loginform选项卡的name点Browse…选loginFormInput Source点Browse…选user文件夹下的login.jsp2.4. 创建index.jsp 文件如果没有,创建index.jsp 文件,并添加一个指向login.jsp 的链接:<a href=”user/login.jsp”>Login</a>。

(user/login.jsp是school下路径,/user/login.jsp是绝对路径,直接http://localhost:8080/user/login.jsp)<%@page language="java"import="java.util.*"pageEncoding="GB2312"%> <%String path = request.getContextPath();String basePath =request.getScheme()+"://"+request.getServerName()+":"+request.getServ erPort()+path+"/";%><!DOCTYPE HTML PUBLIC"-//W3C//DTD HTML 4.01 Transitional//EN"><html><head><base href="<%=basePath%>"><title>My JSP 'index.jsp' starting page</title><meta http-equiv="pragma"content="no-cache"><meta http-equiv="cache-control"content="no-cache"><meta http-equiv="expires"content="0"><meta http-equiv="keywords"content="keyword1,keyword2,keyword3"> <meta http-equiv="description"content="This is my page"><!--<link rel="stylesheet" type="text/css" href="styles.css">--></head><body><a href="user/login.jsp">登陆</a></body></html>2.5. 创建Forword类操作:[Ctrl+N] MyEclipse/Web-Struts/Struts 1.3 Forword类名:indexForwordName: indexPagePath: /index.jsp2.6. 修改LoginAction.java 文件修改LoginAction 类的execute 方法:/** Generated by MyEclipse Struts* Template path: templates/java/JavaClass.vtl */package com.dp.school.action;import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.struts.action.Action;import org.apache.struts.action.ActionForm; import org.apache.struts.action.ActionForward; import org.apache.struts.action.ActionMapping; import com.dp.school.actionForm.LoginForm;/*** MyEclipse Struts* Creation date: 11-06-2009** XDoclet definition:* @struts.action path="/login" name="loginForm" input="/user/login.jsp" scope="request" validate="true"*/public class LoginAction extends Action {/** Generated Methods*//*** Method execute* @param mapping* @param form* @param request* @param response* @return ActionForward*/public ActionForward execute(ActionMapping mapping, ActionForm form,HttpServletRequest request, HttpServletResponse response) {LoginForm loginForm = (LoginForm) form;// TODO Auto-generated method stubString userName = loginForm.getUserName();String password = loginForm.getPassword();if(userName.equals("test")||password.equals("test")){return mapping.findForward("indexPage");}else{return mapping.getInputForward();}}}2.7. 修改login.jsp 文件修改<html:form> 标签:<html:form action=”/login”>。

ssh框架原理及流程

ssh框架原理及流程

ssh框架原理及流程SSH框架原理及流程。

SSH框架是指Struts、Spring、Hibernate三大开源框架的整合,它们分别解决了Web层、业务逻辑层和数据访问层的开发问题。

SSH框架的整合,旨在充分发挥各自框架的优势,实现高效、灵活、可维护的Web应用程序开发。

在本文中,我们将深入探讨SSH框架的原理及流程。

首先,我们来了解一下SSH框架各个组成部分的原理。

Struts作为Web层框架,它采用MVC(Model-View-Controller)设计模式,将应用程序分为模型、视图和控制器三层,实现了数据、展示和控制的分离,提高了代码的复用性和可维护性。

Spring作为业务逻辑层框架,它提供了IoC(控制反转)和AOP(面向切面编程)等功能,通过IoC容器管理对象之间的依赖关系,实现了松耦合,降低了组件之间的耦合度。

Hibernate作为数据访问层框架,它提供了ORM(对象关系映射)功能,将Java对象和数据库表之间建立映射关系,实现了面向对象的数据访问,简化了数据库操作。

接下来,我们来了解SSH框架的整合流程。

首先,我们需要在项目中引入Struts、Spring、Hibernate的相关jar包,并配置它们的配置文件。

在web.xml中配置DispatcherServlet,用于拦截所有的请求,然后将请求分发给对应的Controller处理。

在Spring的配置文件中配置业务逻辑层和数据访问层的Bean,以及事务管理器等。

在Hibernate的配置文件中配置数据源、SessionFactory等。

然后,我们需要编写业务逻辑层和数据访问层的代码,并在Controller中调用业务逻辑层的方法,最终将数据返回给视图层进行展示。

在SSH框架中,我们可以充分利用Struts的表单验证、Spring的事务管理、Hibernate的持久化操作等功能,实现了Web应用程序的快速开发。

同时,SSH框架也提供了良好的扩展性,我们可以根据项目的需要,灵活地替换其中的某个框架,而不影响整体架构。

ssh三大框架整合

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 <!-- 配置action的对象 -->2 <!-- 注意action是多实例的,因此我们这⾥把scope配置为prototype的 -->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="/"><!-- class属性⾥⾯不写action全路径了,因为写,action对象创建两次写spring配置的action的bean的id值--><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="/"><!-- class属性⾥⾯不写action全路径了,因为写,action对象创建两次写spring配置的action的bean的id值--><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的整合了。

javawebssh框架实例

javawebssh框架实例

javawebssh框架实例javawebssh框架实例是一种用于实现Java与WebSSH的框架。

WebSSH是一种基于Web的SSH(Secure Shell)客户端,可以通过浏览器远程登录到服务器并执行命令。

在本文中,我们将介绍如何使用javawebssh框架来实现WebSSH 功能。

我们需要在项目中引入javawebssh框架的依赖。

可以通过Maven 或Gradle等构建工具来管理依赖。

在pom.xml文件中添加以下依赖:```xml<dependency><groupId>com.hierynomus</groupId><artifactId>sshj</artifactId><version>0.29.0</version></dependency><dependency><groupId>com.hierynomus</groupId><artifactId>sshj-gateway</artifactId><version>0.29.0</version></dependency><dependency><groupId>org.apache.sshd</groupId><artifactId>sshd-core</artifactId><version>2.7.0</version></dependency><dependency><groupId>org.eclipse.jetty.websocket</groupId><artifactId>websocket-server</artifactId><version>9.4.31.v20200723</version></dependency><dependency><groupId>org.eclipse.jetty</groupId><artifactId>jetty-server</artifactId><version>9.4.31.v20200723</version></dependency>```接下来,我们需要创建一个WebSSHController类来处理WebSSH的请求。

SSH框架的搭建详细图文教程

SSH框架的搭建详细图文教程

SSH框架的搭建详细图⽂教程转载-6.在MySQL中新建⼀个表,⽤来测试数据我在这⾥准备做⼀个注册登录功能,所以在test⾥建了⼀个user表,表⾥的字段有id、username、password、nickname四个字段。

nickname⽤来测试中⽂是否乱码。

SQL语句:CREATE TABLE `user` (`id` bigint(20) unsigned NOT NULL auto_increment COMMENT 'ID',`username` varchar(40) character set utf8 NOT NULL COMMENT '⽤户名',`password` varchar(40) collate utf8_unicode_ci NOT NULL COMMENT '密码',`nickname` varchar(40) character set utf8 NOT NULL COMMENT '昵称',PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ciCOMMENT='⽤户信息表';SSH框架搭建步骤:1. 新建⼀个项⽬。

打开MyEclipse,新建⼀个Web项⽬,起名就叫SSH,点击完成,若弹出提⽰点Yes即可。

2.添加Struts框架。

右键这个项⽬,选择MyEclipse->Add StrutsCapabilities。

在弹出的菜单中把包的路径改⼀下, Base package for new classes选项中的路径com.yourcompany.struts改成com.ssh.struts, 点击完成。

展开WebRoot中的WEB-INF⽂件夹,看到⽬录结构如下图,证明Struts框架添加完成。

详解ssh框架原理及流程

详解ssh框架原理及流程

详解ssh框架原理及流程什么是SSHSSH是 struts+spring+hibernate的⼀个集成框架,是⽬前较流⾏的⼀种web应⽤程序开源框架。

SSH不是⼀个框架,⽽是把多个框架(Struts、Spring以及Hibernate)紧密的结合在⼀起,⽤于构建灵活、易于扩展的多层Web应⽤程序。

SSH框架的系统从职责上分为四层:表⽰层、业务逻辑层、数据持久层和域模块层(实体层)。

SSH(Struts2+Spring+Hibernate)框架的项⽬,该架构主要分为三个层次:(1)Struts2:负责web层(2)Spring:业务层的管理(3)Hibernate:负责数据持久化Struts2⼯作原理:1.初始化⼀个指向servlet容器的请求。

2.请求经过web.xml中配置的过滤器过滤,FilterDispatcher(struts2控制器的核⼼)询问ActionMapper是否需要调⽤某个Action来处理这个请求。

如果ActionMapper决定需要调⽤某个Action,FilterDispatcher则把请求的处理交给ActionProxy。

3.ActionProxy通过配置⽂件Struts.xml配置⽂件找到需要调⽤的Action类。

4.ActionProxy创建⼀个ActionInvocation实例,同时ActionInvocation通过代理模式调⽤Action。

但在调⽤之前,ActionInvocation会根据配置加载Action相关的所有Interceptor(拦截器)。

5.Action执⾏完毕后,ActionInvocation负责根据struts.xml中的配置找到对应的返回结果result。

即开发⼈员通过发送http请求,这个请求经过web.xml的过滤器过滤看看是否要调⽤某个action,如果有则在Struts.xml找到该请求的实现的⽅法,然后返回运⾏的结果。

Hibernate⼯作原理:1. 读取并解析配置⽂件2.读取并解析映射信息,创建SessionFactory3. 打开Sesssion4.创建事务Transation5. 持久化操作6.提交事务7.关闭Session8. 关闭SesstionFactory即通过spring管理的Hibernate初始化时加载了xxx.hbm.xml然后读取解析映射信息,创建了SessionFactory。

SSH原理框架图整理

SSH原理框架图整理

1、Spring 架构图Spring 就是一个开源框架,就是为了解决企业应用程序开发复杂性而创建得。

框架得主要优势之一就就是其分层架构,分层架构允许您选择使用哪一个组件,同时为J2EE 应用程序开发提供集成得框架。

Spring 框架得功能可以用在任何J2EE 服务器中,大多数功能也适用于不受管理得环境。

Spring 得核心要点就是:支持不绑定到特定J2EE 服务得可重用业务与数据访问对象。

这样得对象可以在不同J2EE 环境(Web或EJB )、独立应用程序、测试环境之间重用。

组成Spring 框架得每个模块(或组件)都可以单独存在,或者与其她一个或多个模块联合实现。

每个模块得功能如下:•核心容器:核心容器提供Spring 框架得基本功能。

核心容器得主要组件就是BeanFactory ,它就是工厂模式得实现。

BeanFactory 使用控制反转(IOC ) 模式将应用程序得配置与依赖性规范与实际得应用程序代码分开。

•Spring 上下文:Spring 上下文就是一个配置文件,向Spring 框架提供上下文信息。

Spring 上下文包括企业服务,例如JNDI 、EJB 、电子邮件、国际化、校验与调度功能。

•Spring AOP : 通过配置管理特性,Spring AOP 模块直接将面向方面得编程功能集成到了Spring 框架中。

所以,可以很容易地使Spring 框架管理得任何对象支持AOP 。

Spring AOP 模块为基于Spring 得应用程序中得对象提供了事务管理服务。

通过使用Spring AOP ,不用依赖EJB 组件,就可以将声明性事务管理集成到应用程序中。

•Spring DAO :JDBC DAO 抽象层提供了有意义得异常层次结构,可用该结构来管理异常处理与不同数据库供应商抛出得错误消息。

异常层次结构简化了错误处理,并且极大地降低了需要编写得异常代码数量(例如打开与关闭连接)。

Spring DAO 得面向JDBC 得异常遵从通用得DAO 异常层次结构。

JSP,SSH框架学习日志1,SSH框架搭建

JSP,SSH框架学习日志1,SSH框架搭建

JSP,SSH框架学习⽇志1,SSH框架搭建JSP,SSH框架学习⽇志1,SSH框架搭建学习SSH框架也有两三个⽉了,之前学习都没有写博客的习惯,这是我的第⼀个记录写程序的博客,希望能坚持下去吧!学习这些之前都没⽤过struts2 spring hibernate都没⽤过,第⼀次接触,所以……⿇烦⼀⼤堆啊!好了,下⾯进⼊正题,⾸先是项⽬环境的找搭建,我⽤的开发⼯具是MyEclipse 10.5,还要再装JDK,tomcat之类的就不说了,下⾯我说⼀下我是怎么搭建⾃⼰的SSH环境的(我⽤的是在线考试系统练习)⾸先打开MyEclipse 10.5,通过右上⾓把界⾯转到Database Explorer然后在左边的DB Browser 栏的空⽩处右击,新建⼀个数据连接选择连接数据库(可不选,选的话下⾯会提⽰连接字符串的格式),填写数据名连接字符串,⽤户名,密码。

点击Add JARs添加相应的驱动(⾃⾏到⽹上下载)点击Test Driver测试连接有没有成功提⽰成功,点击finish完成配置切回Java Enterprise界⾯新建⼀个web项⽬在J2EE Specification Level 选择Java EE 6.0点击finish完成项⽬的创建,然后在项⽬名右击,MyEclipse->Add StrtusCapadbilities添加Strtus⽀持之后就会出现下⾯的界⾯Struts specification 选择Struts 2.1,URL pattern中选择的是你后⾯要做的前台页⾯要提交的action名后辍是什么,选择/*就是没有后辍,点next选择⽀持包,我这边只选了两个包点finish完成,接下来项⽬名右击,MyEclipse->Add Spring Capadbilities添加Spring⽀持,以下是Spring我勾选的包,包跟据实际需要添加JAR Library Installaction中可以选择Add checked Libraries to project build-path或Copy checked Library contents to project-folder都⾏,如果你的项⽬经常移动的话建议选择后者接来来点击next,选择Browse把applicationContext.xml的路径改到WebRoot⾥⾯。

整合SSH三大框架介绍

整合SSH三大框架介绍

一.在MyEclipse里先建立一个Web project 的工程,选最新版本的java ee。

1.引入struts2必须得几个jar包,放在WebRoot->WEB-INF->lib目录下。

2.将WEB应用部署到tomcat效劳器上:找到tomacat的安装目录Tomcat6.x\apache-tomcat-\conf,翻开其中的server.xml文件,在文件末尾</Host>上面参加例如<Context path="/ssh2" docBase="F:\javaWeb\ssh2\WebRoot" reloadable="true" />这样的句子,其中path的值为你需要访问网站的上下文,docBase的值为该web工程的WebRoot所在的目录,最后一个readloadable最好选true。

3.在WebRoot->WEB-INF->web.xml中参加struts2的过滤器将部署好的应用纳入到struts2的管辖范围类,具体代码如下<filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPre pareAndExecuteFilter</filter-class></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping>rc目录下,建一个struts.xml文件,这里是处理struts整个流程的文件。

ssh框架开发流程

ssh框架开发流程

ssh框架开发流程SSH框架开发流程。

SSH框架是指Struts2 + Spring + Hibernate的整合开发框架,是目前Java企业级应用开发中比较流行的一种开发模式。

它将Struts2的MVC设计模式、Spring的IoC(控制反转)和AOP(面向切面编程)功能、Hibernate的ORM(对象关系映射)功能有机地结合在一起,为企业级应用的开发提供了一种高效、规范的解决方案。

下面将介绍SSH框架的开发流程。

1. 环境准备。

在进行SSH框架开发之前,首先需要搭建好相应的开发环境。

通常情况下,我们会选择使用Eclipse作为开发工具,同时需要安装好Tomcat作为应用服务器,以及配置好MySQL等数据库。

另外,还需要下载好Struts2、Spring和Hibernate的相关jar包,并将它们加入到项目的构建路径中。

2. 创建项目。

在环境准备完成后,接下来需要创建一个SSH框架的项目。

可以通过Eclipse的新建项目向导来创建一个Dynamic Web Project,然后在项目中引入Struts2、Spring和Hibernate的配置文件,以及相关的jar包。

接着可以创建相应的实体类、DAO(数据访问对象)、Service和Action等各层的代码文件。

3. 配置文件。

在项目创建完成后,需要进行各个框架配置文件的编写。

在Struts2中,需要编写struts.xml配置文件,配置Action的映射关系;在Spring中,需要编写applicationContext.xml配置文件,配置Bean的定义和依赖注入;在Hibernate中,需要编写hibernate.cfg.xml配置文件,配置数据库连接信息和实体类的映射关系。

4. 编写业务逻辑。

在配置文件编写完成后,可以开始编写业务逻辑代码。

首先需要编写实体类,用于映射数据库中的表结构;然后编写DAO接口和DAO实现类,用于数据库操作;接着编写Service接口和Service实现类,用于业务逻辑处理;最后编写Action类,用于处理用户请求并调用相应的Service方法。

SSH三大框架的工作原理及流程

SSH三大框架的工作原理及流程

SSH三⼤框架的⼯作原理及流程摘要: Hibernate⼯作原理及为什么要⽤? 原理: 1.通过Configuration().configure();读取并解析hibernate.cfg.xml配置⽂件 2.由hibernate.cfg.xml中的读取并解析映射信息 3.通过config.buildSessionFactory();//创建SessionFactory 4.sessionFactoryHibernate⼯作原理及为什么要⽤?原理:1.通过Configuration().configure();读取并解析hibernate.cfg.xml配置⽂件2.由hibernate.cfg.xml中的读取并解析映射信息3.通过config.buildSessionFactory();//创建SessionFactory4.sessionFactory.openSession();//打开Sesssion5.session.beginTransaction();//创建事务Transation6.persistent operate持久化操作7.session.getTransaction().commit();//提交事务8.关闭Session9.关闭SesstionFactory为什么要⽤:1. 对JDBC访问数据库的代码做了封装,⼤⼤简化了数据访问层繁琐的重复性代码。

1. Hibernate是⼀个基于JDBC的主流持久化框架,是⼀个优秀的ORM实现。

他很⼤程度的简化DAO层的编码⼯作2. hibernate使⽤Java反射机制,⽽不是字节码增强程序来实现透明性。

3. hibernate的性能⾮常好,因为它是个轻量级框架。

映射的灵活性很出⾊。

它⽀持各种关系数据库,从⼀对⼀到多对多的各种复杂关系。

2. Hibernate是如何延迟加载?1. Hibernate2延迟加载实现:a)实体对象 b)集合(Collection)1. Hibernate3 提供了属性的延迟加载功能当Hibernate在查询数据的时候,数据并没有存在与内存中,当程序真正对数据的操作时,对象才存在与内存中,就实现了延迟加载,他节省了服务器的内存开销,从⽽提⾼了服务器的性能。

Eclipse下SSH2框架搭建 详细

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框架运行流程

SSH框架运行流程

SSH框架运行流程1.初始化阶段:在初始化阶段,SSH框架会加载配置文件、创建核心对象和建立组件之间的关联关系。

1.1加载配置文件:1.2创建核心对象:1.3建立组件关联:2.请求处理阶段:在请求处理阶段,SSH框架根据请求的URL找到相应的处理器,并将请求参数传递给处理器进行处理。

2.1客户端发送请求:客户端通过浏览器向服务器发送请求,请求的URL中包含了需要调用的方法和相应的参数。

2.2URL映射:2.3参数绑定:2.4方法调用:处理器会调用相应的方法,并将参数传递给方法进行处理。

2.5数据库操作:如果需要进行数据库操作,如增删改查等,处理器会通过Hibernate 框架进行数据库访问。

3.结果返回阶段:在结果返回阶段,SSH框架将处理结果返回给客户端,通常是通过页面展示或异步请求返回数据。

3.1视图解析:如果处理器返回的是页面,SSH框架会根据配置文件中定义的视图解析器,将逻辑视图转换为具体的物理视图。

3.2页面渲染:3.3异步请求返回数据:如果处理器返回的是异步请求的数据,SSH框架会将数据封装成JSON 或XML格式,并通过HTTP协议返回给客户端。

总结:SSH框架的运行流程可以概括为初始化、请求处理和结果返回三个阶段。

在初始化阶段,SSH框架会加载配置文件、创建核心对象和建立组件之间的关联关系;在请求处理阶段,SSH框架根据请求的URL找到相应的处理器,并将请求参数传递给处理器进行处理;在结果返回阶段,SSH框架将处理结果返回给客户端,通常是通过页面展示或异步请求返回数据。

这个流程使得开发者能够快速开发出高质量的Java Web应用程序。

JSP_SSH框架搭建(Myeclipse2014+Tomcat8.0+Mysql)

JSP_SSH框架搭建(Myeclipse2014+Tomcat8.0+Mysql)

SSH框架Struts2.1+Spring3.1.1+Hibernate4.2.0编号:SSH-S2-S3-H4版本:V1.1环境说明本文章是根据个人的搭建经验完成的轻量级SSH框架,也是实际应用中比较全面的基础框架。

其中SSH指:Struts,Spring, Hibernate,是一个将MVC思想发挥的很好的web框架。

开发平台: Windows 7 + MyEclipse 2014 + Tomcat 8.0.3+ JDK 1.8 + Mysql不同的版本大同小异。

其中SSH所需的包均直接使用MyEclipse2014内集成的jar包,这样无需手动添加,比较方便。

建立工程目录新建工程打开MyEclipse,新建一个web project:file -> new -> Web Project 如下图所示:然后next两步,到下面时,修改一点:之后直接next到finish即可,建立后目录如下:建立src目录为了使得目录结构清晰,将不同层次的源程序放到不同包内,分别建立如下4个目录:- com.ssh.action :存放Action代码- com.ssh.service :存放Service代码- com.ssh.dao :存放Dao代码- com.ssh.entity :存放数据库实体类直接右击src, 然后new -> package 如下图:然后直接finishi即可。

同样的步骤建立剩下三个目录。

这一步完成后的目录如下:导入Struts,Spring,Hibernate环境就是导入SSH环境了,这里使用的是MyEclipse集成的jar包导入Struts过程:右击项目名SSH 然后 MyEclipse ->Project Facets[capabilities]->Install Apache Struts 2.x Facet初始图如下:next到这步修改为第三项(重要):之后一直到finish即可。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

1、创建web应用
2、添加spring支持,选择需要的类库,并选择“JAR Libraries Installation”中第二个选项:Copy checked Library contents to project folder (TLDs always copied),将类库保存到项目的lib目录下。

3、添加Hibernate支持:
4、下一步:选择“Spring Configuration file(applicationContext.xml)“
5、下一步:选择“Existing Spring configuration file”在SessionFactory Id 中填入sessionFactory.
6、下一步:如图填写
7、添加Hibernate实体及其映射文件
8、对Dao类中的方法抽取接口并将接口和实现分包放置,
9、建立biz接口和bizImpl实现类,实现类中添加Dao接口的引用,并添加get/set方法,
10、在具体业务方法中调用Dao的方法实现业务逻辑。

11、在applicationContext.xml中配置bizImpl实现类
<bean id="accountDAO" class="ssh.dao.AccountDAO">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>
<bean id="accountBiz" class=".impl.AccountBizImpl">
<property name="dao">
<ref bean="accountDAO" />
</property>
<property name="allDao">
<ref bean="allAccountDAO" />
</property>
</bean>
12、添加Struts支持,在struts-config.xml中添加插件元素:
<plug-in
className="org.springframework.web.struts.Context LoaderPlugIn">
<set-property property="contextConfigLocation" value="classpath:applicationContext.xml"/>
</plug-in>
13、创建form/Action/Jsp并将struts-config.xml文件中Action的type改为:type="org.springframework.web.struts.DelegatingAc tionProxy"
14、在Action中添加Biz接口的引用,并添加get/set 方法
15、编写要执行的Action方法,调用Biz引用完成业务操作。

完成后转入到指定页面。

16、在applicationContext.xml中配置Action:将bean的id改为name=“path“
<bean name="/account"
class="com.ssh.struts.action.AccountAction"> <property name="accountBiz">
<ref bean="accountBiz"/>
</property>
</bean>
17、编写页面代码,加入方法参数
18、注意需要将库中的sam.2.2.3.jar删除,否则它和sam.jar
包冲突,会出现如下错误:
org.springframework.beans.factory.BeanCreationExc eption: Error creating bean with name 'sessionFactory' defined in class path resource [applicationContext.xml]: Invocation of init method failed; nested exception is org.hibernate.MappingException: An association from the table goods refers to an unmapped class: er
19、配置事务(参见配置模板)
20、部署项目,运行项目。

21、可能的异常:
版本引发的异常:
org.springframework.beans.factory.BeanCreationExc eption: Error creating bean with name 'transactionManager' defined in file [D:\tools\Tomcat
6.0\webapps\umgoods\WEB-INF\classes\applicationCo ntext.xml]: Cannot resolve reference to bean 'sessionFactory' while setting bean property 'sessionFactory'; nested exception is org.springframework.beans.factory.BeanCreationExc eption: Error creating bean with name 'sessionFactory' defined in file [D:\tools\Tomcat 6.0\webapps\umgoods\WEB-INF\classes\applicationCo ntext.xml]: Invocation of init method failed; nested exception is ng.UnsupportedClassVersionError: Bad version number in .class file (unable to load class er)
提示:因为MyEclipse7.0用的是5.0版本的JDK,而tomcat用
的是 6.0,二者产生冲突,将myEclipse7.0编辑的JDK改成JDK6.0即可
首先把Myeclipse JDK版本调到“1.6”然后在把TOMCAT JDK 版本也调到“1.6”一致就可以了。

在Myeclipse里最上面菜单栏里找“Window”选择“Preferences”下选择“Java”
下选择“Compiler”在这里可以调版本“1.6”。

然后在“Java”下选择“Installed JREs”在这里也要调“1.6”版本。

之后就是该TOMCAT的版本。

================================================= 这是JDK6.0版本的问题,换成JDK1.5就好了
严重: Servlet /blog threw load() exception
javax.servlet.UnavailableException: Parsing error processing resource path /WEB-INF/struts-config.xml at
org.apache.struts.action.ActionServlet.handleConf igException(ActionServlet.java:769)
at
org.apache.struts.action.ActionServlet.parseModul eConfigFile(ActionServlet.java:745)
at
org.apache.struts.action.ActionServlet.initModule Config(ActionServlet.java:687)
at
org.apache.struts.action.ActionServlet.init(Actio nServlet.java:333)
都解决不了时,只能重新安装JDK6.0——tomcat6.0其jre必须指定jre6.0,再将MyEclipse的JDK版本设定为6.0。

相关文档
最新文档