SSH框架说明文档
- 格式:doc
- 大小:371.50 KB
- 文档页数:16
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 即是Struts + Spring + Hibernate 3个开源框架。
一、Struts是一个MVC框架,通过配置文件很好的实现了模型与视图的分离,Struts应用包括3个组件:控制器组件(ActionServ let和自定义Action);模型组件(普通接口和Jav aBean);视图组件(ActionForm和Struts标签);Struts 的MVC设计模式可以使我们的逻辑变得很清晰。
Struts的工作流程:在web应用启动时就会加载初始化ActionServ let,ActionServ let从struts-conf ig.xml文件中读取配置信息,把它们存放到各种配置对象当ActionServ let接收到一个客户请求时,将执行如下流程.-(1)检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径无效信息;-(2)如果ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中;-(3)根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的v alidate()方法;-(4)如果ActionForm的v alidate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象, 就表示表单验证成功;-(5)ActionServ let根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的Action实例不存在,就先创建这个实例,然后调用Action的execute()方法;-(6)Action的execute()方法返回一个ActionForward对象,ActionServ let在把客户请求转发给ActionForward对象指向的JSP组件;-(7)ActionForward对象指向JSP组件生成动态网页,返回给客户;二、Spring是一个轻量级框架,提供依赖注入容器,AOP实现,DAO/ORM支持,Web集成等功能。
搭建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框架的搭建及与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?简单说,SSH是⼀种⽹络协议,⽤于计算机之间的加密登录。
在出现SSH之前,系统管理员需要登⼊远程服务器执⾏系统管理任务时,都是⽤telnet来实现的,telnet协议采⽤明⽂密码传送,在传送过程中对数据也不加密,很容易被不怀好意的⼈在⽹络上监听到密码。
如果⼀个⽤户从本地计算机,使⽤SSH协议登录另⼀台远程计算机,我们就可以认为,这种登录是安全的,即使被中途截获,密码也不会泄露。
最早的时候,互联⽹通信都是明⽂通信,⼀旦被截获,内容就暴露⽆疑。
1995年,芬兰学者Tatu Ylonen设计了SSH协议,将登录信息全部加密,成为互联⽹安全的⼀个基本解决⽅案,迅速在全世界获得推⼴,⽬前已经成为Linux系统的标准配置。
需要指出的是,SSH只是⼀种协议,存在多种实现,既有商业实现,也有开源实现。
本⽂针对的实现是OpenSSH,它是⾃由软件,应⽤⾮常⼴泛。
⼆、⾸先了解下对称加密(也称为秘钥加密),⾮对称加密(也称公钥加密)所谓对称加密,指加密解密使⽤同⼀套秘钥。
对称加密的加密强度⾼,很难破解。
但是在实际应⽤过程中不得不⾯临⼀个棘⼿的问题:如何安全的保存密钥呢?尤其是考虑到数量庞⼤的Client端,很难保证密钥不被泄露。
⼀旦⼀个Client端的密钥被窃据,那么整个系统的安全性也就不复存在。
为了解决这个问题,⾮对称加密应运⽽⽣。
⾮对称加密有两个密钥:“公钥”和“私钥”。
公开的密钥称为公钥,不公开的密钥称为私钥,两个密钥的特性:公钥加密后的密⽂,只能通过对应的私钥进⾏解密。
⽽通过公钥推理出私钥的可能性微乎其微。
也可以通过私钥进⾏加密,在通过公钥进⾏密码,这种⽅式多⽤于数字签名。
远程Server收到Client端⽤户TopGun的登录请求,Server把⾃⼰的公钥发给⽤户。
Client使⽤这个公钥,将密码进⾏加密。
Client将加密的密码发送给Server端。
远程Server⽤⾃⼰的私钥,解密登录密码,然后验证其合法性。
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三⼤框架整合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的整合了。
三大框架ssh模式的详解SSH是Secure Shell的缩写,是一种用于安全远程登录的协议。
它可以通过加密隧道来传输数据,并提供了身份验证和数据完整性保护。
SSH模式可以分为以下三大框架:SSH-1、SSH-2和OpenSSH。
1.SSH-1:SSH-1是最早的SSH协议版本,由Tatu Ylönen在1995年开发。
SSH-1使用了基于RSA算法的身份验证机制,并使用了Diffie-Hellman 算法进行密钥交换。
然而,SSH-1存在许多安全漏洞,包括易受到中间人攻击的问题。
因此,SSH-1在1996年被SSH-2所取代,成为历史遗留的协议版本。
2.SSH-2:SSH-2是目前最广泛使用的SSH协议版本。
与SSH-1相比,SSH-2具有更好的安全性和可靠性。
SSH-2支持多种身份验证机制,包括密码、公钥和基于证书的身份验证。
它还增加了Diffie-Hellman组合机制和更强大的加密算法,如AES和3DES。
SSH-2还提供了压缩数据和端口转发等功能。
由于SSH-2的安全性和功能,它成为了企业网络中常用的远程登录协议。
3. OpenSSH:OpenSSH是SSH协议的开源实现,也是最常用的实现之一、OpenSSH 包括了SSH客户端和服务器端。
它被广泛使用于Linux和Unix系统中,提供了安全的远程登录和文件传输功能。
OpenSSH拥有良好的安全性和稳定性,并提供了许多高级功能,如X11转发、SFTP文件传输和动态端口转发。
OpenSSH还支持在非标准端口上运行,从而增加了安全性。
总结来说,SSH模式的三大框架包括SSH-1、SSH-2和OpenSSH。
SSH-1是最早的SSH协议版本,但存在安全漏洞,已被SSH-2所取代。
SSH-2具有更好的安全性和可靠性,支持多种身份验证机制和强大的加密算法。
而OpenSSH则是SSH协议的开源实现,被广泛应用于Linux和Unix系统中,提供了安全的远程登录和文件传输功能,并支持多种高级功能。
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框架的搭建详细图⽂教程转载-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框架原理及流程什么是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是指Struts、Spring和Hibernate三个开源框架的整合,其中每个框架都有自己的设计思想和特点,通过整合,可以充分发挥它们的优势,提高开发效率和系统性能。
下面将分别介绍这三个框架。
1. Struts:Struts是一个基于MVC设计模式的Web应用程序框架,它将应用程序分为三个层:模型(Model)、视图(View)和控制器(Controller)。
模型负责处理业务逻辑,视图负责展示数据,控制器负责接收用户输入和导航请求。
Struts通过配置文件定义请求的映射和处理逻辑,通过统一的控制器Servlet接收请求,根据配置文件将请求转发给相应的Action。
在Action中进行请求处理和业务逻辑的实现。
2. Spring:Spring是一个轻量级的IoC(Inverse of Control)容器和应用程序框架,它主要解决企业应用中的复杂性问题。
Spring的核心思想是面向接口编程和依赖注入。
通过Spring的IoC容器管理对象的生命周期和依赖关系,将对象的创建和销毁过程交给容器处理。
通过依赖注入,可以将对象之间的依赖关系解耦,提高代码的可维护性和可测试性。
Spring还提供了丰富的功能模块,如AOP(Aspect-Oriented Programming)框架、事务管理、远程调用等,可以在应用程序中灵活地配置和使用。
Spring的优点是具有良好的灵活性和扩展性,可以与其他框架进行无缝集成,支持多种数据库和应用服务器。
同时,Spring还提供了很强的层次化管理和面向切面编程的能力,使得开发人员可以更加精细地控制应用程序的流程和行为。
3. Hibernate:Hibernate是一个开源的对象关系映射框架,用于将Java对象映射到关系数据库中的表结构上。
Hibernate通过配置文件和注解,提供了一种方便的方式来实现数据的持久化和检索。
Hibernate根据对象的映射关系,自动生成相应的SQL语句,实现了对象与数据库之间的映射和转换。
SSH协议体系结构解读SSH(Secure Shell)是一种用于在不安全网络上进行安全远程登录和传输文件的协议。
它提供了加密的通信和身份验证方法,用于保护用户的私密信息。
SSH协议体系结构由三个主要组件组成:传输层协议(SSH-TRANS),用户认证协议(SSH-AUTH)和连接层协议(SSH-CONN)。
本文将深入解读SSH协议体系结构的工作原理和各个组件的作用。
一、传输层协议(SSH-TRANS)传输层协议是SSH协议体系结构的核心组件之一,它负责在客户端和服务器之间建立加密通信通道。
SSH-TRANS使用公钥密码学和对称密钥加密算法来保证数据的机密性和完整性。
1.1 加密算法传输层协议使用对称密钥加密算法进行数据加密和解密。
常见的对称加密算法包括AES(Advanced Encryption Standard)和3DES(Triple Data Encryption Standard)。
这些算法使用相同的密钥对数据进行加密和解密,确保数据在传输过程中的安全性。
1.2 身份验证传输层协议还负责客户端和服务器之间的身份验证。
SSH使用公钥密码学来实现身份验证,通过交换公钥进行验证,保证了通信双方的身份可信。
二、用户认证协议(SSH-AUTH)用户认证协议是SSH协议体系结构的另一个重要组件,它负责验证用户的身份和权限。
SSH-AUTH使用公钥密码学和数字签名来实现用户的身份认证。
2.1 公钥密码学用户认证协议使用公钥密码学来验证用户的身份。
在用户首次连接服务器时,服务器会生成一对公钥和私钥。
用户将自己的公钥发送给服务器,服务器使用该公钥对用户发送的数据进行加密。
用户使用私钥对服务器返回的数据进行解密,完成身份验证过程。
2.2 数字签名用户认证协议还使用数字签名技术来确保数据的完整性和真实性。
服务器使用自己的私钥对数据进行签名,客户端使用服务器的公钥对签名进行验证,确保数据没有被篡改。
三、连接层协议(SSH-CONN)连接层协议是SSH协议体系结构的最上层组件,它负责在已建立的加密通道上传输数据和执行远程命令。
SSH配置⽂件详解SSH:是⼀种安全通道协议,主要⽤来实现字符界⾯的远程登录,远程复制等功能。
在RHEL系统中SSH使⽤的是OpenSSH服务器,由opensh,openssh-server等软件包提供的。
sshd服务配置⽂件默认位置/etc/ssh/sshd_config。
⼀、常见的SSH服务器监听的选项如下:
1 Port 2
2 //监听的端⼝号为22
2 Protocol 2 //使⽤SSH V2协议
3 ListenAdderss 0.0.0.0 //监听的地址为所有的地址
4 UserDNS no //禁⽌DNS反向解析
⼆、常见⽤户登录控制选项如下:
1 PermitRootLogin no // 禁⽌root⽤户登录
2 PermitEmptyPasswords no // 禁⽌空密码⽤户登录
3 LoginGraceTime 2m // 登录验证时间为2分钟
4 MaxAuthTries 6 // 最⼤重试次数6次
5 AllowUsers steven // 只允许steven⽤户登录
6 DenyUsers steven // 不允许登录⽤户 steven
三、常见登录验证⽅式如下:
1 PasswordAuthentication yes //启⽤密码验证
2 PubkeyAuthentication yes //启⽤密匙验证
3 AuthorsizedKeysFile .ssh/authorized_keys //指定公钥数据库⽂件。
1.1系统技术实现方案1.1.1项目总体架构1.1SSH框架介绍和分析:大型企业级Web应用系统的开发通常要求有一个良好的软件架构、便于协作开发和扩展升级,而传统的开发模式不能很好地满足这些要求。
基于当前Web应用程序开发面临的问题,项目结合目前比较流行的开源框架SSH (Spring、Struts、Hibernate),具体讨论其基本相似性及有关基本概念,提出了一种开发JavaEE Web应用的轻量级解决方案,此系统架构可以在短期内搭建结构清晰、可复用性好、可扩展性好、维护方便的Web应用程序。
1.1.1框架技术框架一般具有即插即用的可重用性、成熟的稳定性以及良好的团队协作性。
JavaEE复杂的多层结构决定了大型的JavaEE项目需要运用框架和设计模式来控制软件质量。
目前,市场上出现了一些商业的、开源的基于JavaEE的应用框架,其中主流的框架技术有:基于MVC模式的Struts框架、基于IoC模式的Spring框架以及对象/关系映射框架Hibernate 等。
1.1.2框架共同点所有现代的网络开发框架几乎都遵循了模型-视图-控制(MVC)设计模式:商业逻辑和描述被分开,由一个逻辑流控制器来协调来自客户端的请求和服务器上将采取的行动。
这条途径成为了网络开发的事实上的标准。
每个框架的内在的机制当然是不同的,但是开发者们使用来设计和实现他们的Web应用软件的API是很类似的。
差别还存在于每个框架提供的扩展方面,例如标签库,JavaBean包装器等。
所有的框架使用不同的技术来协调在Web应用程序之内的导航,例如XML配制文件,java属性文件或定制属性。
所有的框架在控制器模块实现的方法方面也存在明显的不同。
例如,EJB可能实例化在每个请求中需要的类或使用Java反射动态地调用一个适当的行为(Action)类。
另外,不同框架在各自引入的概念上也有所不同。
例如,一个框架可能定义用户请求和反应场所,而另外一个框架可能仅仅定义一个完整的流:从一个请求到多个响答和随后的再请求。
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在查询数据的时候,数据并没有存在与内存中,当程序真正对数据的操作时,对象才存在与内存中,就实现了延迟加载,他节省了服务器的内存开销,从⽽提⾼了服务器的性能。
一、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框架运行流程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应用程序。
一、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。
(2)持久层的类包此文件夹下放置模型类,以及对应的Hibernate配置文件。
,(3)业务层的类包这个包用来放置相应的Service,用来处理相应的业务逻辑。
二、核心的配置文件的说明:1. Web.xml文件——工程初始化配置文件(1)Servlet配置在WebRoot文件下的Web.xml文件,是WebProject工程配置文件,Tomcat服务器在启动时,会自动加载所有工程中的Web.xml文件。
服务器会根据Web.xml中的配置信息,生成相应的Servlet的实例对象,用来处理客户端发送来的请求。
本程序的Servlet是使用的Struts中的ActionServlet,它是继承的HttpServlet类。
ActionServlet 支持多线程,目前的Struts框架只允许在应用中配置一个ActionServlet。
它是Struts中的控制器,系统的指令由其中转,它从struts-config.xml中读取配置信息,并在服务器后台自动启动一个线程。
(2)init-param设置Init-param设置ActionServlet运行参数,对Servlet的运行环境进行初始化配置。
实际上param-name的值是与ActionServlet中的属性相对应的。
ActionServlet在创建时会调用init函数,函数会用配置文件中param-value值来设置相应的属性。
A)Struts配置文件设置以相对路径的方式指明Struts应用程序的配置文件位置,在ActionServlet中默认值为/WEB-INF/struts-config.xml,所以如果是默认情况,在这里也可以不用配置。
如果有多个配置文件可以用逗号分隔符。
B)debug设置设置Servlet的debug级别,控制日志记录的详细程序。
默认为0,记录相对最少的日志信息。
C)detail设置设置Digester的debug级别,Digester是Struts框架所使用的用来解析xml配置文件的一个框架,通过该设置,可以查看不同详细等级的解析日志。
默认为0,记录相对最少的日志信息。
D)load-on-startup设置这个标记指示Web应用服务器在启动时加载这个Servlet(实例化并调用init方法),标记的内容必须使用一个整数指定Servlet的加载顺序。
如果这个整数是负值,或者这个值没有出现,那么窗口任意选择Servlet加载。
如果这个整数大于等于零以,那么窗口必须按照部署的顺序加载他们。
容器必须保证,拥有小的load-on-startup值的Servlet必须先被加载,如果Servlet有相同的load-on-startup值,那么,容器将自动选择这些Servlet的加载顺序。
(3)servlet-mapping配置这里*是通配符,表示服务器只要接收到的形如*.do的请求,就会把这个请求交由名为action 的servlet实例来处理。
请求的形式可以由开发者自己定义,Struts中通常都用do来做为后缀。
而此处的servlet-name与上面servlet定义中的servlet-name是相对应的。
(4)Spring配置文件配置context-param是application范围内的参数,存放在servletcontext中。
此所设定的参数,在JSP 内页中可以使用${initParam.param_name}来取得,若在Servlet可以使用String param_name = getServletContext().getInitParamter(“param_name”);来取得。
在此程序中,参数contextConfigLocation用来定义要装入的Spring配置文件。
如果想装入多个配置文件,可以在<param-value>标记中用逗号作为分隔符。
默认情况Spring的配置文件为applicationContext.xml。
此程序是因为改变了spring配置文件名字,所以才需要在Web.xml中配置。
如果是默认情况则不需要配置。
(5)Spring的Bean工厂配置listener元素用来定义Listerner接口,ContextLoaderListener的作用就是启动Web容器时,自动装配ApplicationContext的配置信息。
它实现了ServletContextListener这个接口,在Web.xml 配置这个监听器,启动容器时,就会默认执行它的实现的方法,加载相应的Spring类,以使当对象调用时,实现其相应的注入。
这是一个Spring的重要类,在ContextLoaderListener中关联了ContextLoader类。
所以整个加载配置过程由ContextLoader来完成,它创建的是XmlWebApplicationContext这样一个类,这个类实现了BeanFactory接口,所以Spring中的所有的bean都由这个类来创建。
(6)Filter配置filter元素用来声明filter的相关设定。
过滤器就是一个Servlet,只是比较特殊而已,可以用它来对客户端请求以及发出的响应进行部分的过滤操作。
filter-name是过滤器的名称,filter-class为对应的类。
filter-mapping元素的两个主要子元素为filter-name与url-pattern,用来定义filter所对应的url。
”/*”形如这样的url都会发送给相应的过滤器。
A)Spring中文乱码过滤器配置在web开发中常常遇到中文乱码的问题,解决的方案常常是在Web.xml中配置一个过滤器,Spring为我们的web开发提供了一个过滤器,可以解决中文乱码的问题。
B)Hibernate延迟过滤器配置Hibernate的session的生命周期横跨Servlet和Jsp,当我们的Jsp需要用到某个延迟属性的时候,发现session已经关闭了,就会发生延迟加载例外。
这段配置就是使用Spring中的类解决hibernate因session关闭导致的延迟加载例外问题。
(7)欢迎页面配置指定首先访问的页面,当客户访问Web应用时,如果仅仅给出Web应用的RootUrl,没有指定具体文件名,Web容器会自动调用Web应用的欢迎文件。
2. struts-config.xml——Struts的配置文件(1)Form的配置form-bean用来映射页面上的某个<form />之中的数据,对应的FormBean类一般是继承ActionForm类。
(2)Action的配置其中,name要与对应的form中的字段名相同。
容器在创建对应的Form的实例时,会将对应页面中同名的字段值,通过Set方法赋给Form。
所以Form中的字段一定要有对应的SetXXX 方法。
否则就无法赋值。
(3)全局异常处理类配置用来配置全局的异常处理类。
(4)全局转发配置global-forwards用于配置全局转发,struts首先会在<action-mappings>元素中找对应的<forwar d>,若找不到,则到全局转发配置中找。
它包含0个或多个<forward/>元素,格式如下所示:<forward name="唯一的名称" path="指向资源的相对路径"/>。
<forward/>元素还有一个redirect属性,其默认值为false,如果redirect设为true的时候,则用HttpServletResponse.sendRedirect()方法,否则用RequestDispatcher.forward()方法,缺省为false。
sendRedirect产生新的请求与响应,相当于在页面中重新输入一个URL,只是自动完成而已,forward是共用同一请求,浏览器中的URL不变。
(5)action配置该元素用于将Action元素定义到ActionServlet类中,它含有0到多个<action/>元素,其格式如下:<action path="Action请求的相对路径" type="该Action的对应类的全路径" name="该Action绑定的FormBean" scope=”指定ActionForm Bean的作用域” parameter=”action对应的参数名”> <forward name="指定处理相应请求所对应的地址" path="相对路径"/></action>此程序中,action的对应类,为Spring提供的一个Struts的代理类。