SSH框架的基本结构整合

SSH是 struts+spring+hibernate的一个集成框架，是目前比较流行的一种Web应用程序开源框架。
SSH的整合时

第一：先Struts和Spring整合

第二：在Hibernate和Spring整合

我的项目结构

第一步：先导入架包
pom.xml中（架包要统一，不然运行时会提示架包冲突。架包冲突不会影响功能）

注：我这里的struts2的依赖，需要联网，不然运行时会报错，你们可以改版本

<dependency>
     <groupId>javax.servlet</groupId>
     <artifactId>javax.servlet-api</artifactId>
     <version>4.0.0-b07</version>
     <scope>provided</scope>
 </dependency>
 
    <!-- 加入hibernate核心库 -->
    <dependency>
     <groupId>org.hibernate</groupId>
     <artifactId>hibernate-core</artifactId>
     <version>5.2.10.Final</version>
 </dependency>
 
 <!-- 引入Spring核心库 -->
 <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.10.RELEASE</version>
    </dependency>
    
  <!-- MySQL  -->
    <dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>5.1.43</version>
 </dependency>
 
 <!-- 引入c3p0数据库连接池 -->
 <dependency>
     <groupId>com.mchange</groupId>
     <artifactId>c3p0</artifactId>
     <version>0.9.5.2</version>
 </dependency>
 
 <!-- Spring整合Hibernate依赖 -->
 <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-orm</artifactId>
     <version>4.3.10.RELEASE</version>
 </dependency>
 
 <!-- spring 的AspectJ依赖，解析事务切点 -->
 <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-aspects</artifactId>
     <version>4.3.10.RELEASE</version>
 </dependency>
 
 <!-- 引入struts2依赖 -->
 <dependency>
     <groupId>org.apache.struts</groupId>
     <artifactId>struts2-core</artifactId>
     <version>2.3.33</version>
 </dependency>
 
 <!-- struts2整合Spring的整合包 -->
 <dependency>
     <groupId>org.apache.struts</groupId>
     <artifactId>struts2-spring-plugin</artifactId>
     <version>2.5.12</version>
 </dependency>
 <!-- 日志的依赖-->
 <dependency>
     <groupId>org.apache.logging.log4j</groupId>
     <artifactId>log4j-core</artifactId>
     <version>2.8.2</version>
 </dependency>

第二步：导包完成后，就Struts和Spring整合
先写web.xml

<web-app>
  <display-name>Archetype Created Web Application</display-name>
  	<!-- 配置spring的环境配置文件-->
	  <context-param>
	  <!-- 这里的name名必须这样写-->
	  <param-name>contextConfigLocation</param-name>
	  <!-- 配置spring的配置文件的位置 我的就在文件夹的下面，所以直接这样写，如果在包里面就包名加名字，用/隔开-->
	  <param-value>classpath:applicationContext.xml</param-value>
	 </context-param>
	<!-- 配置Struts的拦截器-->
	<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>
	 <!-- 配置核心监听器 -->
	 <listener>
	        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
   	 </listener>
</web-app>

第三步：创建applicationContext.xml
现在里面只写产生的action层对象

<!-- spring产生action层对象 -->
<!-- 这里id名对象struts.xml中会使用的    scope：作用域，把创建，关闭都交给spring-->
 <bean id="teacherAction" class="com.ywy.action.TeacherAction" scope="prototype">
  
 </bean>

第四步：创建struts.xml
我只是做测试

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">
    <struts>
     <package name="default" namespace="/" extends="struts-default">
     <!-- 这个地方的class指向的是applicationContext.xml中产生的TeacherAction对象的id名-->
      <action name="teacherAction_*"  class="teacherAction"  method="{1}">
      </action>
     </package>
    </struts>

第五步：创建一个action的包，在包中创建一个TeacherAction的类
继承 ActionSupport然后写个方法

public String Tea() {
   System.out.println("测试成功");
   return NONE;
  }

到这里后struts和spring就整合完成，如果访问teacherAction_Tea应该是可以访问的

Hibernate和spring的整合

第一步：到applicationContext.xml配置文件中,配置hibernate的数据源
在上面导context的标签库
加xmlns:context=“http://www.springframework.org/schema/context”
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
效果如下：

<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd          http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

在创建一个hibernate.properties的配置文件
里面写关于数据库的配置

##数据库的用户
user=root 
## 数据库的密码
password=123456
## 数据库的驱动类
driveClass=com.mysql.jdbc.Driver
## 数据库的路径
url=jdbc:mysql://localhost:3306/scott
## 最大数
maxPoolSize=10
##初始数
minPoolSize=3

然后到applicationContext.xml中写

<!-- 加载数据库的配置文件  location：classpath:加配置文件路径-->
<context:property-placeholder location="classpath:hibernate.properties"/>
 <!-- 配置hibernate的配置文件 -->
 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
 <!-- 通过${配置文件的名}获取到配置文件的值-->
  <property name="jdbcUrl" value="${url}"></property>
  <property name="driverClass" value="${driveClass}"></property>
  <property name="user" value="${user}"></property>
  <property name="password" value="${password}"></property>
  <property name="initialPoolSize" value="${minPoolSize}"></property>
  <property name="maxPoolSize" value="${maxPoolSize}"></property>
 </bean>

第二步：spring中产生sessionFactory的工厂对象
applicationContext.xml中 我就没有新建hibernate的配置文件，都在spring的配置文件中配置的

<!-- spring产生sessionFactory的对象 -->
 <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
  <!--加载 数据流 -->
  <property name="dataSource" ref="dataSource"></property>
  <!-- 加载实体类的映射文件这里就加载了所有的映射文件 -->
  <property name="mappingLocations" value="classpath:com/ywy/entity/*.hbm.xml"></property>
  <!-- 还有hibernate的默认设置  -->
  <property name="hibernateProperties">
   <props>
    <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>  
    <prop key="hibernate.show_sql">true</prop> 
    <prop key="hibernate.format_sql">true</prop>  
   </props>
  </property>
 </bean>

第三步：spring配置文件中产生事务管理器
applicationContext.xml

<!-- 配置事务管理器 -->
 <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
 <!-- name名需要引用  ref：依赖于上面产生的sessionFactory的对象-->
 <!-- 事务管理器管理的是sessionFactory工厂对象的任何范围的对象-->
  <property name="sessionFactory" ref="sessionFactory"></property>
 </bean>

写到这里后就不写配置文件了
第四步：创建一个dao的包，在包中创建TeacherDao的接口
TeacherDao接口中：

package com.ywy.dao;

import com.ywy.entity.Teacher;

public interface TeacherDao {
//新增的方法
 public void add(Teacher tea);
}

在创建一个dao包的实现包 com.ywy.dao.impl包名
类名：TeacherDaoImpl
类中的对象都在spring的配置文件中创建

package com.ywy.dao.impl;

import org.hibernate.SessionFactory;
import com.ywy.dao.TeacherDao;
import com.ywy.entity.Teacher;

public class TeacherDaoImpl implements TeacherDao{

 //需要sessionFactory的对象，给它set方法
 private SessionFactory factory;
 
 public void add(Teacher tea) {
 //获取当前的session对象，然后调新增的方法
  factory.getCurrentSession().save(tea);
 }
 
 public void setFactory(SessionFactory factory) {
  this.factory = factory;
 }
 
}

然后在回到applicationContext.xml中，然后创建dao层中sessionFactory的对象

<!-- spring产生dao层的对象 -->
<!-- id:自定义的名  class:dao层实现类的包名加类名-->
 <bean id="td"  class="com.ywy.dao.impl.TeacherDaoImpl">
 <!-- name：是TeacherDaoImpl类中定义的名称  ref:依赖上面创建的sessionFactory的对象-->
  <property name="factory" ref="sessionFactory"></property>
 </bean>

第五步：创建biz层 创建一个接口TeacherBiz
biz层是业务逻辑层，负责调用dao层的方法，action层调用biz层
事务管理器也是配置在biz层

package com.ywy.biz;
//业务逻辑层
import com.ywy.entity.Teacher;

public interface TeacherBiz {
//方法和dao层差不多
 public void add(Teacher tea);
}

也有一个它的实现类com.ywy.biz.impl
TeacherBizImpl

package com.ywy.biz.impl;

import com.ywy.biz.TeacherBiz;
import com.ywy.dao.TeacherDao;
import com.ywy.entity.Teacher;

//biz只负责调用dao层
public class TeacherBizImpl implements TeacherBiz{
 //调用dao层的方法，需要dao对象，也有set方法
 private TeacherDao td;
 
 public void add(Teacher tea) {
  td.add(tea);
 }
 public void setTd(TeacherDao td) {
  this.td = td;
 }
 
}

在到applicationContext.xml配置文件
配置spring产生dao的对象

<!-- spring产生biz层的对象 -->
<!-- 产生dao对象-->
 <bean id="tb" class="com.ywy.biz.impl.TeacherBizImpl">
 <!-- ref:上面产生的sessionFactory对象-->
  <property name="td" ref="td"></property>
 </bean>

回到TeacherAction类中

package com.ywy.action;
import com.opensymphony.xwork2.ActionSupport;
import com.ywy.biz.TeacherBiz;
import com.ywy.entity.Teacher;
public class TeacherAction extends ActionSupport{
  //需要biz层对象 set方法
  private TeacherBiz tb;
  public String Tea() {
   System.out.println("测试成功");
   tb.add(new Teacher("小零食88"));
   return NONE;
  }
  public void setTb(TeacherBiz tb) {
   this.tb = tb;
  }
}

再去applicationContext.xml把最之前创建的action对象复制到下面
在里面加一行代码

<!-- spring产生action层对象 -->
 <bean id="teacherAction" class="com.ywy.action.TeacherAction" scope="prototype">
 <!-- action里面的tb是上面产生的biz对象-->
  <property name="tb" ref="tb"></property>
 </bean>

到这里后，再配置事务管理器的切入面和切入点，事务管理器管理的是biz层
切入面

<!-- 配置事务管理器的切入面 -->
 <tx:advice id="txAdvice" transaction-manager="transactionManager">
  <tx:attributes>
  <!-- 什么方法进事务管理器 以add，update，delete开头的方法进入事务管理器-->
  <!-- propagation：事务传播的特性 REQUIRED：如果当前有事务就进当前事务，没有就产生一个新的事务 -->
   <tx:method name="add*" propagation="REQUIRED"/>
   <tx:method name="update*" propagation="REQUIRED"/>
   <tx:method name="delete*" propagation="REQUIRED"/>
   <!-- 全部  查询的    read-only：只读-->
   <tx:method name="*" read-only="true"/>
  </tx:attributes>
 </tx:advice>

切入点

<!-- 配置切入点 -->
 <aop:config>
 <!-- 从哪个类切入-->
 <!-- expression：表达式 execution(* com.ywy.biz.impl.*.*(..))impl包中所有的类中的所有的方法，包括所有有无参数和所有有无返回值的方法 -->
  <aop:pointcut expression="execution(* com.ywy.biz.impl.*.*(..))" id="poinCut"/>
  <aop:advisor advice-ref="txAdvice" pointcut-ref="poinCut"/>
 </aop:config>

到这里hibernate和spring就整合完成，ssh也整合完成
注：如果还不是很明白，可以问我