SSH整合入门详解

合集下载

SSH2整合实例详细教程

本次教程是SSH2的环境搭建，主要用到的技术是struts2.0+hibernate3.2+spring2.0，这种架构在现在很流行的，也是很多高校学生做毕业设计的架构，今天我们就用这种架构做一个简单的实例，详细的步骤，在于抛砖引玉，给大家一点启发。

一、创建数据库的时候会创建出联合主键<Composite-id>。

二、项目创建1、打开MyEclipse，点击File，指向New，点击Web Project。

2、输入工程名SSH，J2EE Specification Level为Java EE 5.0，点Finish即可创建完项目。

三、添加hibernate环境1、右击刚建立的SSH项目，指向MyEclipse，点击Add Hibernate Capabilities。

2、出现如下对话框之后，选择要用到的Hibernate3.2，以及所用到的包，选择Copy checked Library Jars to project folder and add to build-path，点击Next。

3、到了这一步，按默认设置，点击Next。

4、取消Specify database connection details的选择，再点击Next。

5、取消Create SessionFactory class选择，最后点击Finish。

这样一些有关hibernate的jar包点导进来了，以及建了一个hibernate.cfg.xml文件。

导入前：导入后：四、添加spring环境1、和添加hibernate环境的方法大致相同，右击SSH项目，指向MyEclipse，点击Add spring Capabilities。

2、选择要用到的Spring 2.0，勾选用到的库，注意还要勾选Spring 2.0 Web Libraries的库，一共是勾选了5个库的。

再选择Copy checked Library contents to project folder(TLDs always copied)，点击Next。

SSH2框架整合学习指南word资料11页

SSH2框架整合详细步骤内部资料2019年7月目的：通过一个简单的注册登录来学ssh框架的整合1 准备工作1.1工具准备Mysql5.5 , JDK 1.6, Myeclipse 6.5，tomcat6.0等辅助工具1.2整合类库集Struts-2.3.1.2, Hibernate 3.2,Spring 2.5(后两类库可以在myelcipse中有自带)2开始搭建平台1．启动myeclipse，建一个Web工程，如图所示：图中的需要输入项目名称即可，其余可以没必要选择，除非有需2．导入Struts2开发的必备类库说明：（此版本的myeclipse没有需要的struts2类库，所以选择手工导入）需要导入的类库常见8个：导入之后，还别忘了导入一个和spring整合需要的类文件这些工作之后还需配置web.xml文件，为它配置过滤器，配置文件详细如下：<?xml version="1.0" encoding="UTF-8"?><web-app id="WebApp_9" version="2.4"xmlns="http://java.sun/xml/ns/j2ee"xmlns:xsi="/2019/XMLSchema-instance"xsi:schemaLocation="http://java.sun/xml/ns/j2eehttp://java.sun/xml/ns/j2ee/web-app_2_4.xsd"><filter><filter-name>struts2</filter-name><filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecute Filter</filter-class></filter><filter-mapping><filter-name>struts2</filter-name><url-pattern>/*</url-pattern></filter-mapping></web-app>配置好该处后，还需要在src下面建立一个struts.xml文件，关于该配置文件可以到你下载的struts2文件中，找个项目中，有这样的模版可以拷贝过来一个，这样配置strust2暂时解决了3.导入Hibernate类库文件，选择myeclipse进行导入单击你选择的项目，点击右键，按如图所示选择hibernate的支持选中点击之后得到如下界面，只需改JAR Library Installation如图所示点击next，得到如下，不需改动，继续点击next即可之后到该界面，因为后续来配置，此处就不选，不勾上，点击next接下来也是把勾去掉，不选择，点击finish即可就这样hibernate的支持也完成了3。

SSH整合

参考资料SSH整合主要内容✓SSH整合概述✓应用IoC进行整合✓应用AOP进行整合✓Open Session In View模式1.框架与架构终于，我们学完了Struts、Spring、Hibernate（所谓“SSH”）三大框架，在实际开发中，合理的应用三大框架，才能发挥出各个框架的长处。

我们知道Struts作用于表现层，使表现层符合MVC结构，而Hibernate作用于数据访问层，使DAO能够通过ORM的方式操作数据库。

各个层之间的交互示意图如下：图1 未整合时框架的交互在未使用Spring整合时，这种架构固然能体现出Struts与Hibernate的优点，但也存在以下不足：1.层与层之间耦合性较大。

层之间的耦合主要体现在表现层依赖于业务层，业务层依赖于数据访问层。

在《软件设计与最佳实践》一书中曾介绍过依赖倒转原则，应针对接口编程，而不是实现类，遵照这一原则，我们应该为业务层的建立业务接口，具体的业务类实现接口，同样数据访问层应有数据访问接口。

但即使存在这些接口，在实例化时依然需要指定具体类，当具体类发生变化时会影响到其它层。

2.不能很好的处理事务。

事务的边界应该在业务层确定，但业务层中不应存在实现事务的具体代码，否则会与数据访问层的实现技术紧密耦合在一起（如业务层使用Session.beginTransaction则数据访问层必须用Hiberante技术实现，如果改用JDBC技术实现，则需要改动业务层的代码，违反了分层架构中一层发生变化不影响另一层的初衷），在未使用Spring技术的架构中，事务处理一直是比较头疼的问题。

2.Spring整合概述使用Spring对各个层进行整合可以避免上述不足，使用IoC特性可以有效解除层与层之间的依赖性，每一层不需要选择具体的实现类，而是通过Spring容器注入（图2）。

这样每一层的类可以真正做到只依赖于接口，而不是实现类。

当需要切换实现类时，修改Spring 的配置文件即可以实现，无需改动代码，重新编译。

ssh基础知识整合

ssh基础知识整合Struts，Hibernate，Spring经典面试题收藏第一章Spring概述1、轻量级框架1）框架：Hibernate、Struts、Spring1. Struts：web层的框架2. Hibernate：持久层的框架3. Spring：综合框架；2）SSH：Struts + Spring + Hibernate 三个框架的集成2、EJB1）使用EJB的好处：1. 分布式处理2. 对象的生命周期都是由EJB容器来管理的3. 可以通过声明的方式使用容器提供的服务(比如事务服务)Spring可以提供声明型事务，引用了EJB的事务特性。

2）EJB3.0的思想：1. IOC：依赖注入2. AOP：拦截器、FilterSpring也具有这两大思想。

3、Sping的主要内容：1）IOC(Inversion of Control，控制反转)：提供依赖注入。

2）AOP(Aspect-Oriented Programming，面向方面编程)：解决非业务逻辑功能的实现。

3）事务和数据访问4）SSH4、Sping提供了一个轻量级容器：IOC容器1）管理javabean对象的生命周期2）维护对象跟对象之间的依赖关系===> 依赖注入重量级容器与轻量级容器的比较：1. 重量级容器通常可以独立运行；轻量级容器通常不能独立运行，必须依赖其他容器。

2. 重量级容器包含的服务大而全，所有应用的服务都必须购买；轻量级容器包含的服务可以由开发人员自己选择。

3. 重量级容器直接管理线程调度；轻量级容器不关注线程调度问题。

5、为什么使用Sping？1）提供依赖注入(通过依赖注入的方式组装对象)，使得开发的系统中的组件之间的耦合性降低(松耦合)；2）不使用J2EE中的技术，也可以通过声明的方式来获得一些服务；3）spring是一个扩展性非常强的框架，很容易跟其他的框架进行集成，而且可以简化被集成的框架的使用。

ssh整合框架原理及流程

ssh整合框架原理及流程SSH（Spring、Struts和Hibernate）框架整合的原理和流程如下：原理：1. 控制反转（IoC）：IoC是一种设计原则，通过这种原则，对象之间的依赖关系由容器来控制，而非传统的直接操控。

这使得程序代码更加灵活，易于复用。

2. 依赖注入（DI）：DI是IoC的一种实现方式。

通过DI，组件之间的依赖关系由容器在运行时决定，并动态地将这种关系注入到组件中。

流程：1. 建立web工程，并将其编码设置为UTF-8。

2. 将整个JSP页面也设置为UTF-8编码格式。

3. 建立三个source folder文件：src（存放源代码）、config（存放所有的配置文件，如Struts、Hibernate和Spring配置文件）、test（存放测试类）。

4. 在WebRoot\WEB-INF\lib中导入相应的jar包。

5. 配置文件。

在这个文件中，Spring容器以监听器的形式与Tomcat整合。

6. Struts负责控制Service（业务逻辑处理类），从而控制Service的生命周期。

这样层与层之间的依赖很强，属于耦合。

7. 使用Spring框架来控制Action对象（Struts中的）和Service类。

这使得两者之间的关系变得松散。

Spring的IoC机制（控制反转和依赖注入）正是用在此处。

8. Spring的AOP应用：事务的处理。

在以往的JDBCTemplate中，事务提交成功、异常处理都是通过Try/Catch来完成。

整合SSH框架的目的是提高软件开发的效率和灵活性，减少代码的冗余和复杂性，使代码更易于维护和扩展。

ssh整合

1. 加入Spring
1). 加入jar 包
2). 配置web.xml 文件
3). 加入Spring 的配置文件.
2. 加入Hibernate
1). 同时建立持久化类, 和其对应的.hbm.xml 文件, 生成对应的数据表
2). Spring 整合Hibernate
3). 步骤:
①. 加入jar 包
②. 在类路径下加入hibernate.cfg.xml 文件, 在其中配置hibernate 的基本属性
③. 建立持久化类, 和其对应的.hbm.xml 文件
④. 和Spring 进行整合
i. 加入c3p0 和MySQL 的驱动
ii. 在Spring 的配置文件中配置: 数据源, SessionFactory, 声明式事务
⑤. 启动项目, 会看到生成对应的数据表
3. 加入Struts2
1). 加入jar 包: 若有重复的jar 包, 则需要删除版本较低的. javassist-3.11.0.GA.jar
2). 在web.xml 文件中配置Struts2 的Filter
3). 加入Struts2 的配置文件
4). 整合Spring
①. 加入Struts2 的Spring 插件的jar 包
②. 在Spring 的配置文件中正常配置Action, 注意Action 的scope 为prototype
③. 在Struts2 的配置文件中配置Action 时, class 属性指向该Action 在IOC 中的id。

SSH整合

一说起传说中的SSH（Struts+Spring+Hibernate）架构,许多人的心里面就没有底。

依照本人来看，所谓的整合没有什么神秘的，只不过就是让三个框架在一起协同的工作，我们做的主要工作就是让其知道彼此的存在，打成“统一战线联盟”以后，再各自为战，互不干扰。

下面就本人知道的一些整合方法一一叙述。

1 Struts+Spring主要就是让Struts知道Spring的存在，我们可以采用两种办法。

（1）运用Struts的插件方法，添加struts-congif.xml的<plug-in>节点。

示例代码如下：xml 代码<plug-in className="org.springframework.web.struts.ContextL oaderPlugIn"><set-property property="contextConfigLocation" valu e="/WEB-INF/applicationContext.xml" /></plug-in>上段代码意图很简单:把Struts的配置文件和Spring的配置文件联系起来，这样Struts就知道了Spring的存在。

另外，在web.xml里面需要配置一个Spring的监听器，示例代码如下：xml 代码<listener><listener-class>org.springframework.web.context.C ontextLoaderListener</listener-class></listener>第一种方法完毕。

（2）直接在web.xml里面进行加载。

这种方法与上种方法的不同之处在于Spring的配置文件加载的位置不同，上种方法是在struts-cong.xml中声明，而这种方法是在web.xml里面进行声明，示例代码如下：xml 代码<context-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/applicationContext-module1.xml, /WEB-INF/applicationContext-module2.xml </param-value></context-param>这样我们就实现了第二种方法的SS整合。

ssh整合(Struts+Spring+Hibernate)

19：spring3.0,struts1.2,Hibernate3.3整合19.1 SSH整合概述SSH整合如下图所示，整合包括两部分：整合经常发生的问题是jar包冲突1：spring整合hibernate2：spring整合struts1SSH整合时，要解决的问题记住：SSH整合要把所有的对象都交给spring容器管理整合后不再使用Hibernate提供的类操作对象，而是使用spring提供的类操作对象1.连接数据库连接数据库是由DataSource来完成的，DataSource使用spring框架中的mons.dbcp.BasicDataSource类。

2.创建SessionFactory创建SessionFactory使用spring框架中的org.springframework.orm.hibernate3.LocalSessionFactoryBean类。

3.操作对象（执行SQL语句）操作对象使用spring框架中的org.springframework.orm.hibernate3.HibernateTemplate类。

4.由spring框架提供的HibernateTemplate类代替DBManager类。

5.将hibernate主配置文件信息移植到spring配置文件中数据库连接字符串在spring配置文件中加载，ORM中的映射文件在spring配置文件中加载，因此Hibernate的主配置文件可以删掉了。

6.dao调用HibernateTemplate类操作对象。

7.声明式事务在service中使用声明式事务，事务管理器使用spring框架中的org.springframework.orm.hibernate3.HibernateTransactionManager类8.创建ActionStruts1中的Action应该由spring容器创建，这样Action才能放到spring容器中，被sping操作。

SSH 框架整合步骤详细讲解-8页精选文档

基于myeclipse 8.6M1 的三大框架整合(spring3.0+strut 2.1+hibernate 3.3+mysql)Xiangyun2019-4-9目录1、编写目的 (2)2、搭建环境 (2)3、配置数据源 (2)4、开始创建工程 (3)5、增加Spring框架： (3)6、增加Hibernate框架： (4)7、增加strut2 框架 (5)8、配置Web.xml (5)9、映射实体类 (5)10、编写service和action (6)11、在applicationContext.xml 配置service、action和配置 (7)12、创建index.jsp 和welcome.jsp (7)13、测试(此测试版本如下图) (7)14、总结 (7)1、编写目的最近在学习spring3.0+strut 2.1+hibernate 3.3整合，这期间出现了很多问题，在网上找了若干的实例均有不同程度的问题，为了让想要学习这个整合的人少走弯路，特写下这篇文章，希望对大家有所帮助，如果有很么问题可以与我联系，Email:237567685@qq测试版本代码地址：/detail/goumin1818/5241012(建议先按照此文档自己动手搭建以下，有需要再下载完整的例子)2、搭建环境Myeclipse 8.6M1Tomcat 6.0Mysql 5.2JDK 1.6数据库脚本程序CREATE TABLE `user` (`id` int(20) unsigned NOT NULL AUTO_INCREMENT,`username` varchar(50) DEFAULT NULL,`password` varchar(50) DEFAULT NULL,PRIMARY KEY (`id`)insert into `user`(`id`,`username`,`password`) values(1,'admin','admin'),(2,'zhangsan','zhangsan');3、配置数据源在myeclipse 右上角打开Myeclipse Database Explorer 数据库管理视图右键鼠标，弹出框，选择New 新建Database Driver如下图：在Driver Template 中选择：在Driver name :写上名字可以随便写(这里测试写的是：mysql )在Connection URL 填写好链接地址：jdbc:mysql://localhost:3306/text填好自己数据库用户名和密码增加mysql驱动jar包在Driver JARs 点击Add JARs 找到mysql驱动jar 包(此测试使用的驱动jar 包是：mysql-connector-java-5.1.5-bin.jar)需要填写的东西都填写好后，最后进行测试下，是否可以链接成功。

SSH的整合及工作原理

三、这时请求以经到达业务逻辑类，而在业务逻辑类里面我们又会调用dao类，还是那句话，spring是通过接口来松散藕合的，所以我们会定义一个dao类的接口，并设置为业务逻辑类里面的一个属性,生成对应的set方法，主要是为了等会spring的ioc注入，同时我们要在spring配置文件中配置DAO类，并为业务逻辑类里面的dao接口属性设置值，值就是上面在spring中配置的dao类实例，调用方法。
</list>
</property>
</bean>
SSH的工作原理：
一、客户端发送一个请求到服务器，服务器将请求路径转交给spring代理，这时spring容器就解析请求路径，找到对应的action，并实例化。
二、这时请求到达action，而在action里面我们会调用业务逻辑类（biz），同时spring是通过接口来松散藕合的，所以我们会定义一个业务逻辑类的接口定义，并设置为action里面的一个属性，生成对应的set方法，主要是为了等会spring的ioc注入，同时，我们要在spring的配置文件中配置业务逻辑类，并为action类里面的业务逻辑类接口属性设置值，值就是上面在spring中配置的业务逻辑类实例。调用方法。到此，spring与struts合作工作结束。
</props>
</property>
</bean>

<bean id="autoProxy" class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">

SSH框架整合详解(精典)

已经经过本人测试第一步：准备工作MyEclipse 6.0------T omcat6.0所需jar文件:（所有jar文件已整理ssh_jars文件夹）注意：ssh_test项目中采用的是MySql 数据库。

而本文档中配置的是Oracle数据库，注意其中配置的不同之处哦(在相应的地方有注明)第二步：(建立项目，包结构，导入所需jar文件)新建一个web project:建立包结构如下：各包功能说明：com.ssh.config : 配置文件（*.properties）,如数据库配置信息com.ssh.resource : 资源文件m : 公共工具(util)包com.ssh.util.orm.hibernate : hibernate DAO 模板com.ssh.model : 各实体类文件com.ssh.service : 业务逻辑包相当于bizcom.ssh..test : 测试包com.ssh.action : struts Action包结构可以根据自己需要自行划分导入jar文件：新建一个User Library: sshJars添加jar文件:将新建的User Library: sshJars加入到项目中：第三步：撰写资源文件jdbc.properties在jdbc.properties 里写上连接数据库的配置信息,此文件的配置信息用于在spring的配置文件中使用，数据库的配置信息也可以写到Spring 的配置文件中，这在一个jdbc.properties文件中是为了方便更改.在com.ssh.resource包中新建下列文件：各文件详细内容及说明如下：----------------------------------------------------------------------------------------------------------------------------------------- applicationContext.xml:<?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:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/tx/schema/tx/spring-tx-2.5.xsd/schema/jee/schema/jee/spring-jee-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd"default-lazy-init="true"><description>Spring公共配置文件</description><bean id="propertyConfigurer"class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations"><list><value>classpath*:com/ssh/config/jdbc.properties</value></list></property><bean id="dataSource"class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="${jdbc.driverClassName}" /><property name="url" value="${jdbc.url}" /><property name="username" value="${ername}" /><property name="password" value="${jdbc.password}" /></bean><bean id="sessionFactory"class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBea n"><!—此处hibernate 的映射采用的是.xml 配置则应设置为：class=”org.springframework.orm.hibernate3.LocalSessionFactoryBean”--> <property name="dataSource" ref="dataSource" /><property name="hibernateProperties"><props><propkey="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</prop><prop key="hibernate.show_sql">true</prop><prop key="e_query_cache">true</prop><propkey="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop> <propkey="hibernate.cache.provider_configuration_file_resource_path">/ehcache-hiberna te.xml</prop></props></property><property name="annotatedClasses"> <!—此处hibernate 的映射采用的是.xml 配置同则应设置name=”mappingResource”--><list><value>er</value><!—此处hibernate 的映射采用的是.xml 配置同则应设置<value>具体配置文件名(*.hbm.xml)</value>--></list></property></bean><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory" /><tx:annotation-driven transaction-manager="transactionManager" /><beanclass="org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostPr ocessor" /></beans>----------------------------------------------------------------------------------------------------------------------------------------- applicationContext-security.xml:<?xml version="1.0" encoding="UTF-8"?><beans:beans xmlns="/schema/security"xmlns:beans="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/security/schema/security/spring-security-2.0.xsd"default-autowire="byType" default-lazy-init="true"></beans:beans>此文件用于AOP的安全验证,也可不添加----------------------------------------------------------------------------------------------------------------------------------------- applicationContext-service.xml<?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.5.xsd"default-autowire="byType" default-lazy-init="true"><bean name="userService" class="erService"></bean><bean name="/hello" class="com.ssh.action.HelloAction"></bean></beans>Service（业务逻辑类）的注入----------------------------------------------------------------------------------------------------------------------------------------- ehcache-hibernate.xml:<ehcache><diskStore path="d:\cache" /><cache name="er" maxElementsInMemory="4" eternal="false" overflowToDisk="true"timeToIdleSeconds="600" /><defaultCache maxElementsInMemory="100000" eternal="true"overflowToDisk="true" /></ehcache>Hibernate 缓存的配置（可以不做配置，如果需要才使用缓存才做配置，建议配置上）----------------------------------------------------------------------------------------------------------------------------------------- 第四步：在m 包下添加下列文件此包为hibernate DAO模板中用到的各种工具类，各文件可以在打包的ssh_test项目中找到.第五步：添加hibernate DAO 模板此包为hibernate DAO模板，SimpleHibernateTemplate.java 中包含了对各实体（增，删，改，查，分页查等）的泛形方法。

01、SSH框架整合

1. ssh框架整合通常说的ssh框架，是指Struts，Spring，Hibernate三个Java EE框架，我们在企业级应用开发的时候，通常是将这3个框架结合在一起，来完成企业应用的开发。

那我们就学习一下，怎么将这3个框架整合在一起工作：1.1. 整合步骤1.1.1. 第一步：新建maven工程，要是war类型1.1.2. 第二步：引入3个框架的jar包1.<dependencies>2.3.<dependency>4.<groupId>org.apache.struts</groupId>5.<artifactId>struts2-core</artifactId>6.<version>2.3.15.3</version>7.</dependency>8.<dependency>9.<groupId>org.apache.struts</groupId>10.<artifactId>struts2-convention-plugin</artifactId>11.<version>2.3.15.1</version>12.</dependency>13.14.<dependency>15.<groupId>org.apache.struts</groupId>16.<artifactId>struts2-spring-plugin</artifactId>17.<version>2.3.15.3</version>18.</dependency>19.20.21.22.<dependency>23.<groupId>javax.servlet</groupId>24.<artifactId>javax.servlet-api</artifactId>25.<version>3.1.0</version>26.</dependency>27.28.<dependency>29.<groupId>junit</groupId>30.<artifactId>junit</artifactId>31.<version>4.8.1</version>32.<scope>test</scope>33.</dependency>34.<dependency>35.<groupId>javax.servlet.jsp</groupId>36.<artifactId>jsp-api</artifactId>37.<version>2.2</version>38.</dependency>39.40.41.<dependency>42.<groupId>org.springframework</groupId>43.<artifactId>spring-core</artifactId>44.<version>4.1.6.RELEASE</version>45.</dependency>46.<dependency>47.<groupId>org.springframework</groupId>48.<artifactId>spring-beans</artifactId>49.<version>4.1.6.RELEASE</version>50.</dependency>51.<dependency>52.<groupId>org.springframework</groupId>53.<artifactId>spring-context</artifactId>54.<version>4.1.6.RELEASE</version>55.</dependency>56.<dependency>57.<groupId>org.springframework</groupId>58.<artifactId>spring-tx</artifactId>59.<version>4.1.6.RELEASE</version>60.</dependency>61.<dependency>62.<groupId>org.springframework</groupId>63.<artifactId>spring-jdbc</artifactId>64.<version>4.1.6.RELEASE</version>65.</dependency>66.<dependency>67.<groupId>org.springframework</groupId>68.<artifactId>spring-web</artifactId>69.<version>4.1.6.RELEASE</version>70.</dependency>71.72.<dependency>73.<groupId>org.aspectj</groupId>74.<artifactId>aspectjrt</artifactId>75.<version>1.8.6</version>76.</dependency>77.<dependency>78.<groupId>org.aspectj</groupId>79.<artifactId>aspectjweaver</artifactId>80.<version>1.8.6</version>81.</dependency>82.83.84.<dependency>85.<groupId>org.hibernate</groupId>86.<artifactId>hibernate-core</artifactId>87.<version>4.3.11.Final</version>88.</dependency>89.<dependency>90.<groupId>org.hibernate</groupId>91.<artifactId>hibernate-ehcache</artifactId>92.<version>4.3.11.Final</version>93.</dependency>94.<dependency>95.<groupId>org.springframework</groupId>96.<artifactId>spring-orm</artifactId>97.<version>4.1.6.RELEASE</version>98.</dependency>99.100.<dependency>101.<groupId>commons-dbcp</groupId>102.<artifactId>commons-dbcp</artifactId>103.<version>1.4</version>104.</dependency>105.106.<dependency>107.<groupId>mysql</groupId>108.<artifactId>mysql-connector-java</artifactId> 109.<version>5.1.30</version>110.</dependency>111.112.<dependency>113.<groupId>org.slf4j</groupId>114.<artifactId>slf4j-log4j12</artifactId>115.<version>1.6.1</version>116.</dependency>117.</dependencies>1.1.3. 第三步：配置web.xml1.<?xml version="1.0" encoding="UTF-8"?>2.<web-app version="2.5"3. xmlns="/xml/ns/javaee"4. xmlns:xsi="/2001/XMLSchema-instance"5. xsi:schemaLocation="/xml/ns/javaee6. /xml/ns/javaee/web-app_2_5.xsd">7.8.9.<context-param>10.<param-name>contextConfigLocation</param-name>11.<param-value>classpath:applicationContext.xml</param-value>12.</context-param>13.14.15.<listener>16.<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>17.</listener>18.19.20.<filter>21.<filter-name>struts2</filter-name>22.<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>23.</filter>24.<filter-mapping>25.<filter-name>struts2</filter-name>26.<url-pattern>/*</url-pattern>27. </filter-mapping>28. <welcome-file-list>29. <welcome-file>index.jsp</welcome-file>30. </welcome-file-list>31.</web-app>1.1.4. 第四步：增加struts配置文件：struts.xml1.<?xml version="1.0" encoding="UTF-8"?>2.<!DOCTYPE struts PUBLIC3. "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"4. "/dtds/struts-2.3.dtd">5.6.<struts>7.8.<constant name="struts.objectFactory" value="spring"/>9.<constant name="struts.devMode" value="true" />10.<constant name="struts.ui.theme" value="simple" />11.12.</struts>1.1.5. 第五步：增加hibernate配置文件：hibernate.cfg.xml（也可以不要，详见配置）1.<?xml version='1.0' encoding='utf-8'?>2.<!DOCTYPE hibernate-configuration PUBLIC3. "-//Hibernate/Hibernate Configuration DTD 3.0//EN"4. "/hibernate-configuration-3.0.dtd">5.<hibernate-configuration>6.7.<session-factory>8.9.15.<property name="hbm2ddl.auto">update</property>16.<property name="show_sql">true</property>17.<property name="format_sql">false</property>18.19.</session-factory>20.</hibernate-configuration>1.1.6. 第六步：增加log4j配置文件log4j.properties1.log4j.rootLogger=INFO, Console, R2.3.#Console4.log4j.appender.Console=org.apache.log4j.ConsoleAppenderyout=org.apache.log4j.PatternLayoutyout.ConversionPattern =%d %p [%c]-%m%n7.8.log4j.appender.R=org.apache.log4j.DailyRollingFileAppender9.log4j.appender.R.File=d:/server.logyout=org.apache.log4j.PatternLayoutyout.ConversionPattern =%d %p [%c]-%m%n1.1.7. 第七步：增加数据库配置文件dbcpconfig.properties1.driverClassName=com.mysql.jdbc.Driver2.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8ername=root4.password=root1.1.8. 第八步：增加spring配置文件applicationContext.xml1.<?xml version="1.0" encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3. xmlns:aop="/schema/aop"4. xmlns:tx="/schema/tx"5. xmlns:xsi="/2001/XMLSchema-instance"6. xsi:schemaLocation="/schema/beans7. /schema/beans/spring-beans-2.5.xsd8. /schema/aop9. /schema/aop/spring-aop-2.5.xsd10. /schema/tx11. /schema/tx/spring-tx-2.5.xsd">12.13.16.<bean17.class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">18.<property name="locations">19.<value>classpath:dbcpconfig.properties</value>20.</property>21.</bean>22.23.<bean id="dataSource" destroy-method="close"24.class="mons.dbcp.BasicDataSource">25.<property name="driverClassName" value="${driverClassName}" />26.<property name="url" value="${url}" />27.<property name="username" value="${username}" />28.<property name="password" value="${password}" />29.</bean>30.31.32.<bean id="sessionFactory"33.class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">34.<property name="dataSource">35.<ref bean="dataSource" />36.</property>37.38.<property name="configLocation" value="classpath:hibernate.cfg.xml"/>39.40.41.55.</bean>56.57.<bean id="transactionManager"class="org.springframework.orm.hibernate4.HibernateTransactionManager">58.<property name="sessionFactory" ref="sessionFactory" />59.</bean>60.61.62.<tx:advice id="txAdvice" transaction-manager="transactionManager">63.64.<tx:attributes>65.73.<tx:method name="*" propagation="REQUIRED" />74.</tx:attributes>75.</tx:advice>76.77.78.<aop:config>79.80.<aop:pointcut expression="execution(* cn.reachedu.ssh.service..*.*(..))"id="mypointcut"/>81.82.<aop:advisor advice-ref="txAdvice" pointcut-ref="mypointcut"/>83.</aop:config>84.85.</beans>我们已经将3个框架集成在一起，但是目前什么也干不了，因为我们这个框架下没有任何功能，那么现在我们在框架里面增加一个查询用户的功能，进行简单的测试。

请阐述ssh框架整合的原理。

SSH框架是一种常用的Java Web开发框架，它整合了Struts、Spring和Hibernate三个开源框架的优点，能够提高开发效率和代码质量。

本文将从原理角度介绍SSH框架的整合过程。

1. StrutsStruts是一个基于MVC设计模式的Web应用程序框架，它将请求、处理和响应分离，提供了一种结构化的开发方法。

在SSH框架中，Struts负责接收用户请求并将请求参数封装为ActionForm对象。

Struts的核心组件是Action和ActionForm，Action负责处理用户请求，而ActionForm负责封装请求参数。

Struts通过配置文件将URL与Action关联起来，当用户发起请求时，Struts根据配置文件找到对应的Action，并执行相应的方法。

2. SpringSpring是一个轻量级的Java开发框架，提供了依赖注入和面向切面编程等功能。

在SSH框架中，Spring主要负责管理Bean的生命周期和依赖关系，通过IoC容器将各个组件进行解耦和管理。

Spring的核心是ApplicationContext容器，它负责创建和管理Bean，并提供了一系列的配置选项，如注解、XML配置等。

在SSH框架中，Spring的依赖注入功能可以方便地将Struts的Action与Hibernate的DAO进行整合，实现数据的传递和处理。

3. HibernateHibernate是一个Java持久化框架，它提供了对象关系映射（ORM）的支持，将数据库表和Java对象之间建立起了映射关系。

在SSH框架中，Hibernate负责将Java对象持久化到数据库中，并提供了一系列的查询和操作API。

Hibernate的核心组件是Session和SessionFactory，SessionFactory负责创建Session，而Session负责与数据库进行交互。

在SSH框架中，通过配置文件和注解将Hibernate的Session和事务管理与Spring进行整合，可以方便地进行数据库操作。

经典ssh实例整合

经典ssh实例整合教程1、编写目的最近学习了struts1和hibernate、spring框架的整合，在整合过程中遇到了很多的问题，现在将多次整合研究的结果做一总结，整理出一个小例子，整理出一份文档，让初学者少走弯路，特写下此文档，希望对大家有所帮助。

2、准备环境MyEclipse8.5Tomcat6.0Oracle10gJdk1.6特别说明的是，因为以上环境是我实验的环境，可能大家的环境可能有所不同，所以会因为版本的问题导致一些错误。

出现不能正常运行的状况，但是在上面的环境下是可以正常运行的。

还有就是MyEclipse8.5 里面已经具备了我们要的文件库，所以我们不需要额外的导入文件库，但是如果个人需要，可以额外加一些文件库。

3、数据库操作在数据库中创建test数据库，并创建表添加相应的数据记录。

4、创建web工程打开MyEclipse8.5 工具new一个Web Project（工程），并输入工程名，我输入的是myssh，这个名字随便起，将Context root URL修改为/myssh，这个URL是在MyEclipse8.5中部署的时候浏览器访问站点的根本路径。

J2EE specification level一般选择Java EE 5.0,然后Finish。

新建的Web Project 目录结构如下：5、添加struts支持在刚刚创建的myssh工程上点击右键，在弹出的菜单上选择MyEclipse->Add Struts Capabilities....添加struts具体操作如下：在弹出的对话框中选择struts1.2，然后修改Base Package for new classes成所需要的包名，其余的默认，点击Finish即可。

此时已经完成struts的配置，相关文件的目录结构如下：6、添加spring支持在刚刚创建的myssh工程上点击右键，在弹出的菜单上选择MyEclipse->Add Spring Capabilities....添加spring具体操作如下：在弹出的对话框中选择spring2.0，选择MyEclipse Libraries,按照图示，选择相关的文库。

SSH整合流程小结

SSH整合流程小结SSH（Secure Shell）是一种用于安全远程登录和文件传输的协议。

它使用加密技术来保护用户信息和传输的数据，防止被非法访问和攻击。

在实际应用中，SSH可以用于远程登录服务器进行配置、管理和维护，以及进行文件传输、备份和同步等操作。

本文将对SSH整合流程进行小结。

首先，在进行SSH整合之前，需要确认目标服务器是否支持并开启SSH服务。

SSH服务端通常安装在服务器上，而SSH客户端可以用于连接远程服务器。

为了保证安全，建议使用SSH版本2，因为SSHv1存在安全漏洞。

接下来，我们需要生成SSH密钥对。

SSH使用密钥对来进行加密和认证。

密钥对包括私钥和公钥，私钥储存在本地客户端，而公钥储存在远程服务器上。

私钥是保密的，而公钥可以自由分发给其他人。

当客户端使用私钥进行连接时，服务器会将公钥与之进行匹配来进行认证。

生成SSH密钥对的常用命令是ssh-keygen。

在终端中执行该命令后，会提示选择保存私钥的位置和设置私钥密码（可选）。

生成的密钥文件的默认存储位置是用户主目录下的.ssh目录。

生成密钥时，可以选择使用不同的算法和密钥长度，建议选用较强的算法和密钥长度以提高安全性。

生成密钥后，需要将公钥复制到远程服务器上。

在完成密钥配置后，就可以使用SSH客户端连接到远程服务器了。

在终端中输入ssh命令，后面跟上远程服务器的IP地址或域名即可。

如果使用默认的密钥文件名和服务器端口号，则不需要添加任何参数。

否则，需要额外指定私钥文件的路径和服务器端口号。

成功连接到远程服务器后，就可以执行各种操作了。

可以使用ssh命令来执行简单的命令，也可以使用sftp命令来进行文件传输。

另外，还可以通过SSH隧道来实现端口转发、远程桌面和虚拟专网等功能。

除了基本的SSH配置之外，还可以使用其他工具和技术来进一步优化和增强SSH的功能。

例如，可以使用SSH代理来简化多服务器管理，使用SSH配置文件来管理多个连接配置，使用SSH随机端口来增加安全性，以及使用SSH任务自动化脚本来批量执行操作等。

ssh框架整合原理

ssh框架整合原理SSH框架整合原理引言：SSH（Struts+Spring+Hibernate）是一种常用的Java开发框架组合，它将Struts、Spring和Hibernate三个框架整合在一起，提供了全面的Web应用开发解决方案。

本文将介绍SSH框架的整合原理，以帮助读者深入理解该框架的工作机制。

一、Struts框架Struts是一个基于MVC（Model-View-Controller）模式的Web 应用程序开发框架。

它将应用程序划分为模型（Model）、视图（View）和控制器（Controller）三个部分，以实现业务逻辑和界面展示的分离。

在Struts框架中，用户请求首先由控制器接收，并根据配置文件中的映射规则将其转发给相应的Action处理。

Action负责处理用户请求，并将处理结果封装成一个ActionForm对象，然后将结果返回给控制器。

控制器再将结果转发给指定的视图进行展示。

二、Spring框架Spring是一个轻量级的Java开发框架，它提供了全面的企业级应用程序开发解决方案。

Spring框架主要由IoC（Inversion of Control）和AOP（Aspect-Oriented Programming）两个核心模块组成。

在Spring框架中，IoC容器负责管理应用程序中的对象，并通过依赖注入的方式将对象之间的依赖关系设置好。

通过IoC容器，我们可以通过配置文件或注解的方式将各个模块中的对象整合在一起，实现解耦和灵活性。

AOP模块则通过横切关注点的方式，将应用程序的功能进行模块化，提高了代码的可重用性和可维护性。

在Spring框架中，我们可以通过配置文件或注解的方式定义切面和通知，然后将其与应用程序中的对象进行织入，实现特定功能的增强。

三、Hibernate框架Hibernate是一个优秀的Java持久化框架，它提供了一种对象关系映射（ORM）的方式，将Java对象和数据库表之间进行映射。

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

Struts+Spring+Hibernate整合入门详解
基本概念和典型实用例子。

一、基本概念
Struts：作为基于MVC 模式的Web 应用最经典框架，两个项目Struts 和webwork已经集成，成为现在的Struts2。

目前的最新版本是2.0.9（2007-7）。

Spring：是一个轻型的容器，利用它可以使用一个外部XML 配置文件方便地将对象连接在一起。

每个对象都可以通过显示一个JavaBean 属性收到一个到依赖对象的引用，留给您的简单任务就只是在一个XML 配置文件中把它们连接好。

Hibernate 是一个纯Java 的对象关系映射和持久性框架，它允许您用XML 配置文件把普通Java 对象映射到关系数据库表。

使用Hibernate 能够节约大量项目开发时间，因为整个JDBC 层都由这个框架管理。

这意味着您的应用程序的数据访问层位于Hibernate 之上，完全是从底层数据模型中抽象出来的。

三种技术到目前已经比较成熟，而且他们都是免费的！让我们对三者集成进行一个初览（简单而不专业）：
我们用Struts实现从Web（网页，MVC中的View）到后台系统的映射（Web Action），然后由Spring管理这些Action，把它们作为Bean和其他对象一起处理。

这些Bean之间处理业务逻辑、数据、系统状态等，且它们被Spring统一管理，为了区分，就算大概包括MVC的MC部分吧。

然后需要持久化的数据由Spring和Hibernate之间的接口交由Hibernate处理（这个属于持久层）。

必须基础：只要Java基础，一点HTML知识、XML基础就可以了。

本文的目的就是从零开始建立第一个Struts+Spring+Hibernate应用。

即使它是最简单的，我们也希望初学者能够从中理解一些思想，其中也包括系统架构的设计思想。

二、环境搭建
我们坚持免费才是硬道理，开源才是好事情，所以我们全部使用开源免费的工具和软件。

如果使用MyEclipse，其中的工具将有助于简化下面演示的工程开发，但本文不用。

所需软件包如下表：
其中我们要写的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.jar
cglib-nodep-2.1_3.jar
commons-beanutils-1.6.jar
commons-chain-1.1.jar
commons-collections-2.1.1.jar
commons-dbcp.jar
commons-digester.jar
commons-logging-1.0.4.jar
commons-logging-api-1.1.jar
commons-pool.jar
commons-validator-1.3.0.jar
dom4j-1.6.1.jar
el-api.jar
el-ri.jar
freemarker-2.3.8.jar
hibernate3.jar
jsf-api.jar
jta.jar
mysql-connector-java-3.0.14-production-bin.jar ognl-2.6.11.jar
oro-2.0.8.jar
spring-hibernate3.jar
spring.jar
struts-config.xml
struts-core-1.3.5.jar
struts2-codebehind-plugin-2.0.9.jar
struts2-config-browser-plugin-2.0.9.jar
struts2-core-2.0.9.jar
struts2-jasperreports-plugin-2.0.9.jar
struts2-jfreechart-plugin-2.0.9.jar
struts2-jsf-plugin-2.0.9.jar
struts2-pell-multipart-plugin-2.0.9.jar
struts2-plexus-plugin-2.0.9.jar
struts2-sitegraph-plugin-2.0.9.jar
struts2-sitemesh-plugin-2.0.9.jar
struts2-spring-plugin-2.0.9.jar
struts2-struts1-plugin-2.0.9.jar
struts2-tiles-plugin-2.0.9.jar
tiles-api-2.0.4.jar
tiles-core-2.0.4.jar
tiles-jsp-2.0.4.jar
xwork-2.0.4.jar
三、开始工作
在WebContent下建立index.jsp，建立方式如图。

到输入数据（用户名和密码），这些数据会传给我们将要建立的Action处理。

的网页，就是success.html。

所以……，你已经看到了，struts和spring已经联系起来了。

OK！
下面我们需要把hibernate整合进来了，本来考虑到例子的简单性，打算用更简单的类，但既然用三者整合，就是要有良好的设计。

我们需要以下几个层次的设计：表现层，业务层，持久层。

表现层就是网页；表现层和业务层之间的接口就是网页和action的接口，由struts处理了；业务层包括业务逻辑和事务管理等，由Spring管理，我们只是建立具体处理对象；业务层和持久层之间由数据访问对象DAO处理，持久层交给hibernate处理。

贯穿这些层的是领域对象(domain object)，即表示现实世界的对象（base object），如订单对象，人物信息对象等等。

现在看看我们需要的剩余设计结构。

业务层：放进包service
数据访问对象: 放进包dao
持久层：hibernate
领域对象：放进包bo
既然领域对象是最基本的对象，我们就得首先建立，本例中，可以借助HibernateSynchronizer生成：
首先在mysql中创建表
CREATE TABLE `userinfo` (
`id` int(11) primary key auto_increment,
`username` varchar(20) default NULL,
`Password` varchar(20) default NULL
)
在Eclipse中，建立hibernate的map文件：右键点击WEB-INF（或其他目录都可，后面会提到如何使用该文件），选择new→other，在弹出窗口中选择Hibernate Mapping File。

在弹出窗口输入url，用户名和密码后点击Refresh，可以看到你选择的数据库的表，选中userinfo表。

输入包bo，用来保存从数据库提取的领域对象。

在Properties中将Id generator改为native。

HibernateSynchronizer将在WEB-INF下生成Uerinfo.hbm.xml文件。

右键点击该文件，选择Hibernate Synchronizer→Synchronize Files。

将自动生成bo.base.BaseUserinfo和erinfo类。

这两个就是领域对象。

工具正好啊！
现在bo包里面的对象自动生成了。