ssh，

下面给大家说一下关于java中ssh整合的详细步骤

关于我自己的理解，

1.我第一步先将hibernate先配置好，然后测试 看是否能够连接好数据库

 2.然后再整合hibernate和spring，再进行测试

 3.最后就是整合struts有关页面的数据提交，这样测试通过就代表ssh整合也就完成，框架也就搭好了，自然而然可以开始写你的项目了。下面说一下详细步骤

1.首先第一步肯定是创建spring项目（如果你的eclipse没有下载这种spring插件你得先下载，可以通过本地下载也可以通过网络下载，具体的先不说了），然后就要往你的pom.xml里面引入依赖，首先是引入servlet的依赖，在这里我引入的是4.0.0-b07的版本，然后再引入hibernate的依赖，在这里我引入的是5.2.10版本的，之后就是引用你数据库的依赖，这里我引用的是mysql（5.1.43）版本的，之后创建一个hibernate.cfg.xml文件，注意创建这个需要导入（hibernate插件）不过你手敲一些代码也是可以，创建好之后在<session-factory>里面写上 driver_class，url,password,username等属性，不过也可以勾选！这四个属性是必须的，还有我个人是喜欢将这两个属性写上：

 <property name="show_sql">true</property>
<property name = "format_sql">true</property>  方便找错，之后再<mapping resource="com/entity/User.hbm.xml"/>，读取的你的映射文件，这样去测试一下，测试成功代表的你的hibernate整合成功，第一步也就完成

2.第二步也是至关重要的一步：

首页得引入spring（spring-context）依赖，在这里我引用的是4.3.10.RELEASE版本
创建一个db.properties文件，也就是写连接数据库的一些东西，写上

driver_Class =com.mysql.jdbc.Driver
url = jdbc:mysql://localhost:3306/test
uname = root（最好不要写uers）
upass = root（最好不要谢password，会和后面起冲突）

这些东西，
initPoolSize = 3 （初始连接数）
maxPoolSize = 20（最大连接数），然后在创建一个applicationContext-public.xml文件，核心配置都在这里了，在这里又分为6个小步骤

步骤一：引入db.properties:<context:property-placeholder location="classpath:db.properties" />  将上面创建的文件引入到其中，对于<context>这个节点你可能打不出来，须在开头处配置一下：    xmlns:context="http://www.springframework.org/schema/context" 

xsi:schemaLocation=" http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"，也可以在创建spirng文件的时候勾选（下面的aop，tx节点也一样，只需将关键词改了就ok）

步骤二：配置数据源， 要引用C3PO中的ComboPooledDataSource类，也就是又要引入一个c3p0的依赖，在这里我引用的是 0.9.5.2版本

然后 就在里面读取db.properties的属性

  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
         <!-- 读取db.properties中的值 -->
         <property name="user" value="${uname}"></property>
         <property name="password" value="${upass}"></property>
   <property name="jdbcUrl" value="${url}"></property>
   <property name="driverClass" value="${driver_Class}"></property>
   <property name="initialPoolSize" value="${initPoolSize}"></property>
   <property name="maxPoolSize" value="${maxPoolSize}"></property>
     </bean>

步骤三：配置sessionfactory，这里要引入一个关于整合 spring和hibernate的依赖

<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-orm</artifactId>
   <version>4.3.10.RELEASE</version>
</dependency>   然后要引用LocalSessionFactoryBean这个类：

<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
   <!-- 3.1 引入数据源 -->
   <property name="dataSource" ref="dataSource"></property>


   <!-- 3.2 加载hibernate核心配置文件 （hibernate核心文件交给spring来加载）-->
   <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>


   <!-- 3.3 加载hibernate映射文件 -->
   <property name="mappingLocations" value="classpath:com/entity/*.hbm.xml"></property>
  
</bean>
  第三步结束，hibernate.cfg.xml这个文件基本可以删，关于  show_sql和format_sql也可以在第三步骤配置，就不多说了。

步骤四：配置事物：要引用 HibernateTransactionManager这个类

<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
   <property name="sessionFactory" ref="sessionFactory"></property>
</bean>
      

 步骤五： 

 <!-- 5. 配置事务的属性 -->  也就是你项目里面的dao方法，只要是有关增删改的方法都会帮你自定提交事物，但前提是其方法名必须是 以add，update，del（这些名字随意）这些开头，然后就会自动帮你提交事物。
    <tx:advice id="myAdvice"  transaction-manager="transactionManager">
   <tx:attributes>
<tx:method name="add*" propagation="REQUIRED"/>
<tx:method name="update*" propagation="REQUIRED"/>
<tx:method name="del*" propagation="REQUIRED"/>
<tx:method name="*"/>
   </tx:attributes>
</tx:advice>

步骤六： 

<!-- 6. 配置事务的切点 -->
<aop:config>
   <aop:pointcut expression="execution(* com.dao.*.*(..))" id="myCut"/>     这个表达是表示你整改项目里com.dao下面的所有类所有方法，里面两个..所代表参数

   <!--注意：需要再次引入一个依赖：spring-aspects，用于解析上面这个表达式-->         

   <aop:advisor advice-ref="myAdvice" pointcut-ref="myCut"/>
</aop:config>

 <!-- spring 的AspectJ依赖，解析事务切点 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>4.3.10.RELEASE</version>
</dependency>

之后，再配置好你的dao（applicationContext-dao.xml）和biz(applicationContext-biz.xml)，再进行测试，通过则代表你的第二步成功！

3.就是关于全部的整合了：先导入struts的核心包，最好把log4j日志依赖导进去，不然可能会报错。

首先创建页面表带的提交（我这里用一个添加做测试），一个action（applicationContext-action.xml）的数据接收，这时候往action里面配置一个 biz的接口，实现往数据库里添加数据。

再创建struts.xml文件，记住，class里面的写的action不再是action类的全限名，而是你配置action的名字。我这里就是 useraction

 <action name="user*" class="userAction" method="{1}">
                   <result name="success">/success.jsp</result>  
                <result name="false">/login.jsp</result>  
             </action>

之后在你的web.xm里面 加载struts配置文件，首先得引入spring和struts整合的依赖：

 <!-- struts2整合Spring的整合包 -->
<dependency>
   <groupId>org.apache.struts</groupId>
   <artifactId>struts2-spring-plugin</artifactId>
   <version>2.5.12</version>
</dependency>

然后再加载spring，再添加监听，请注意顺序，先加载spring，然后再是struts，再是监听：

  <!--加载Spring-->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext-*.xml</param-value>
</context-param>


<!-- 加载struts配置文件 -->
    <filter>
       <filter-name>struts21</filter-name>
       <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
   </filter>
    
   <filter-mapping>
       <filter-name>struts21</filter-name>
       <url-pattern>*.action</url-pattern>
   </filter-mapping>
   
  
   <!--添加监听-->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

再之后运行你的项目，成功添加即可。

关于ssh的用法，

SSH框架优势

1.    典型的三层构架体现MVC（模型Model,视图View和控制）思想，可以让开发人员减轻重新建立解决复杂问题方案的负担和精力。便于敏捷开发出新的需求，降低开发时间成本。

2.    良好的可扩展性，ssh主流技术有强大的用户社区支持它，所以该框架扩展性非常强，针对特殊应用时具有良好的可插拔性，避免大部分因技术问题不能实现的功能。

3.    良好的可维护性，业务系统经常会有新需求，三层构架因为逻辑层和展现层的合理分离，可使需求修改的风险降低到最低。随着新技术的流行或系统的老化，系统可能需要重构，ssh构架重构成功率要比其他构架高很多。

4.    优秀的解耦性，很少有软件产品的需求从一开始就完全是固定的。客户对软件需求，是随着软件开发过程的深入，不断明晰起来的。因此，常常遇到软件开发到一定程度时，由于客户对软件需求发生了变化，使得软件的实现不得不随之改变。ssh三层构架，控制层依赖于业务逻辑层，但绝不与任何具体的业务逻辑组件耦合，只与接口耦合；同样，业务逻辑层依赖于DAO层，也不会与任何具体的DAO组件耦合，而是面向接口编程。采用这种方式的软件实现，即使软件的部分发生改变，其他部分也不会改变。

5.    Struts2优势

a)      Struts2 Action对象为每一个请求产生一个实例，因此没有线程安全问题。

b)      Struts2强大的标签库提高开发效率。

c)      页面脉络清晰，通过查看配置文件把握整个系统的关系，方便开发人员岗位流动时的维护。

6.    hibernate优势

a)      hibernate是JDBC轻量级的封装，占用内存较少，性能比较高。与JDBC相比，如果开发JDBC的人员技术能力非常强，hibernate执行效率会比JDBC弱一些，但是大部分情况是程序员在使用JDBC时是不可能做到最高效率，hibernate可以帮大部分开发人员提高运行效率。

b)      可以引入第三方二级缓存，提高系统查询效率，减少系统里存在大量单例类（singleton），大量的单例类,会降低系统的可测试性和面向对象程度。

c)      优秀的orm框架，理论上节省开发人员95%的开发工作量。

d)      Hibernate兼容JDBC。理论上可以应用在任何使用JDBC的场景。

7.    spring优势

a)      spring提高了一种对象管理方法，有效的组织系统中间层对象。是框架的完美“粘合剂”。

b)      有利于面向接口编程习惯的养成，使代码结构清晰。

希望我的理解可以帮助一些小白白