ssh三大框架整合

一.SSH三大框架整合知识点　　　　　　　　　　
1.全部知识点：
 
​
  • Spring、Struts2 以及 Hibernate的整合思想。
  • Spring、Struts2 以及 Hibernate的各个jar包。
  • Spring、Struts2 整合的具体步骤。
  • Spring、Hibernate 整合的具体步骤。
  • 测试代码
  • 总结
2.整合环境：
  • win10 64的电脑　　
  • eclipseLuna Service Release 1 (4.4.1)　　
  • Spring4.2.4　　
  • Hibernate5.0.1　　
  • Struts2.3.24
二.Spring、Struts2 以及 Hibernate的整合思想　
​
1.web应用的三层：
  • web层：Struts2,action相当于Servlet
  • service层：Spring，IOC与AOP思想，把对象的创建交给Spring经行管理
  • dao层：hibernate，对数据库的CRUD操作
2.Struts2与Spring的整合
  • 将Struts2的action的创建交个spring经行管理，要注意的是action是多实例的，即每次请求都会产生一个Action的对象（原因是Action中包含数据，如果是单实例的话，数据为多个action共享，操作结果会不一样）。
  • spring与Struts2的整合jar包
3.Hibernate与Spring的整合
  • Hibernate中的核心类是SessionFactory交给Spring进行管理
  • Hibernate的核心文件中数据库信息的配置交给Spring进行处理
  • 注意导入Spring整合DAO层的ORM包
三.Spring、Struts2 以及 Hibernate的各个jar包
1.组建版本
​
  • Spring4.2.4　　
  • Hibernate5.0.1　　
  • Struts2.3.24
2.Spring4.2.4
aopalliance.jar
commons-logging-1.2.jar:使用这个日志包来支持Log4J和JDK 1.4+的日志记录
spring-aop-4.2.4.RELEASE.jar
spring-beans-4.2.4.RELEASE.jar
spring-context-4.2.4.RELEASE.jar
spring-core-4.2.4.RELEASE.jar:spring的核心jar包
spring-expression-4.2.4.RELEASE.jar
spring-jdbc-4.2.4.RELEASE.jar
spring-orm-4.2.4.RELEASE.jar
spring-tx-4.2.4.RELEASE.jar
spring-web-4.2.4.RELEASE.jar
下载连接: https://pan.baidu.com/s/11MHuwmHeoXB-Ms1tacdazA 密码: 61li
​
3.Hibernate5.0.1
antlr-2.7.7.jar:hibernate利用它实现HQL到SQL的转换
aspectjweaver.jar:支持AOP的包
c3p0-0.9.2.1.jar:数据池
classmate-1.3.1.jar
dom4j-1.6.1.jar：对dom4j的封装，解析xml文件的
druid-1.0.13.jar
hibernate-commons-annotations-5.0.1.Final.jar:支持注解的包
hibernate-core-5.1.0.Final.jar:hibernate的核心jar包
hibernate-jpa-2.1-api-1.0.0.Final.jar:对JPA（Java持久化API）规范的支持
jboss-logging-3.3.0.Final.jar
jboss-transaction-api_1.1_spec-1.0.1.Final.jar
mchange-commons-java-0.2.3.4.jar
ojdbc6_g.jar
ojdbc6.jar
slf4j-api-1.7.21.jar
下载连接: https://pan.baidu.com/s/1fRf9QmxShQJlmeW7D57S9A 密码: 0v3l
​
4.Struts2.3.24
asm-3.3.jar
asm-commons-3.3.jar
asm-tree-3.3.jar
commons-fileupload-1.3.1.jar:文件上传的包
commons-io-2.2.jar:是处理异常的
commons-lang3-3.2.jar:commons项目中的lang包
freemarker-2.3.22.jar:支持freemarker
javassist-3.11.0.GA.jar:一个开源的分析、编辑和创建Java字节码的类库
json-lib-2.3-jdk15.jar
ognl-3.0.6.jar:支持ognl语言
struts2-config-browser-plugin-2.3.24.1.jar
struts2-convention-plugin-2.3.24.1.jar
struts2-core-2.3.24.1.jar:struts2的核心jar包
struts2-dojo-plugin-2.3.24.1.jar
struts2-json-plugin-2.3.24.1.jar
struts2-spring-plugin-2.3.24.1.jar:struts2与spring集成时使用的
tools.jar
xwork-core-2.3.24.1.jar:xwork的核心jar包,struts2在其基础上构建
下载连接: https://pan.baidu.com/s/1WO7WUiVwKOweIPV55E6zAw 密码: 4mmr
​
5.mysql驱动包
mysql-connector-java-5.1.44-bin.jar
​
6.jar包图（注意最下面是xwork-core-2.3.24.1.jar包，都放在lib下）
7.项目结构图
项目大体可以分为三层，视图层，service层，DAO层。注意我的配置文件放在config中，编译后都在class路径下，跟放在src下一样的。
四.Spring、Struts2 整合的具体步骤　　　　
​
1.主要步骤：
  • 首先导入jar包。
  • 创建相应的Action。
  • 配置struts.xml配置文件，位置在src下面（注意我的放在config下）。
  • 在web.xml中配置struts2的过滤器。
  • 把Struts2的action交给Spring进行管理
  • 配置Spring的监听器 
2.相应的代码如下：
导入包：省略
创建的Action

public class RegisterAction extends ActionSupport{
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;  
    private StudentService studentService;
    public RegisterAction() {
        super();
    }   
    public RegisterAction(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }    
    //注入Service，我们需要保留set方法
    public void setStudentService(StudentService studentService) {
        this.studentService = studentService;
    }
    //从jsp中获取属性值
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }   
    public String execute() {
        System.out.println(studentService);
        System.out.println(name);
        System.out.println(age);
        studentService.add(new Student(name,age));
        return SUCCESS;
    }
}
​
 struts.xml配置文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
     <!-- 关闭动态方法调用 -->
     <constant name="struts.enable.DynamicMethodInvocation" value="false" />
     <!-- 配置为开发模式 -->
     <constant name="struts.devMode" value="true" />
     <package name="default" namespace="/" extends="struts-default" >  
         <!--下面的全限定类名可以改为RegisterAction，当我们在Spring中注册当前Action类的bean-->
        <action name="register" class="registerAction">
            <result name="success">/welcome.jsp</result>
            <result name="error">/error.jsp</result>
        </action>        
    </package>
</struts>
​
 web.xml配置文件(注意：spring相关的配置都在下面，下文不再重复贴代码)
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
　　　　xmlns="http://xmlns.jcp.org/xml/ns/javaee" 
　　　　xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" 
　　　　id="WebApp_ID" version="3.1">
  <display-name>ssh</display-name>
    <!-- 配置Spring的监听器，用于初始化ApplicationContext对象 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!--  自定义Spring主配置文件的位置 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    <!-- 配置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>

  <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>
​
spring相关的配置文件applicationContext.xml(注意，下文中不再复制这段代码)
<?xml version="1.0" encoding="UTF-8"?>
<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"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context-2.5.xsd
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

    <!-- 注册c3p0数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <!--处理中文乱码问题-->
        <property name="jdbcUrl" value="jdbc:mysql:///test?useUnicode=true&amp;characterEncoding=utf8"/>
        <property name="user" value="root"/>
        <property name="password" value="8246"/>        
    </bean>    
    <!-- 配置SessionFactory -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <!-- 注入数据池 -->
        <property name="dataSource" ref="dataSource"></property>
        <!-- 指定hibernate核心配置文件 -->
        <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
    </bean>    
    <!-- 配置声明式的事务管理（采用基于注解的方式） -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    <tx:annotation-driven transaction-manager="transactionManager"/>    

    <!-- 注册studentDao -->
    <bean id="studentDao" class="daoImpl.StudentDaoImpl">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>    
    <!-- 注册studentService -->
    <bean id="studentService" class="serviceImpl.StudentServiceImpl">
        <property name="studentDao" ref="studentDao"/>
    </bean>    
    <!-- 将Action交由Spring来管理，设置为多例的，即设置scope，因为每个请求对应一个Action-->
    <bean id="registerAction" class="action.RegisterAction" scope="prototype">
        <property name="studentService" ref="studentService"/>
    </bean>
</beans>
​
其中把Struts2的action交给Spring进行管理部分为：
　　 <!-- 将Action交由Spring来管理，设置为多例，即设置scope，因为每个请求对应一个Action-->
    <bean id="registerAction" class="action.RegisterAction" scope="prototype">
        <property name="studentService" ref="studentService"/>
    </bean>
​
配置Spring的监听器，见上文web.xml配置文件中。在web.xml中我们做的事情有：
  • 我们需要在web.xml中添加Struts2的核心过滤器。
  • 设置一个监听器，监听当web容器创建的时候，即创建我们的Spring容器，这样我们不再需要自己加载Spring的主配置文件。
  • 设置web容器全局参数，自定义Spring主配置文件的位置和命名。
五.Spring、Hibernate 整合的具体步骤　　　　
​
1.主要步骤：
  • 首先导入jar包。
  • 创建相应的实体类。
  • 创建实体类的hibernate映射文件Student.hbm.xml。
  • 创建hibernate的核心配置文件hibernate.cfg.xml。
  • 把Hibernate核心配置文件中的数据库配置部分放到Spring中。
  • 配置Spring的数据池， SessionFactory，事务等。
2.相应的代码如下：
导入包：省略。
创建相应的实体类。
public class Student {
    private int id;
    private String name;
    private int age;
    public Student(String name , int age){
        this.name = name ;
        this.age = age;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
​

创建实体类的hibernate映射文件Student.hbm.xml。

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="domain.Student" table="student">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <property name="age"/>    
    </class>
</hibernate-mapping>
​
创建hibernate的核心配置文件hibernate.cfg.xml。
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
    <!-- 数据库信息（连接信息写到spring的配置文件中） -->
    <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>  
    <!-- 可以将向数据库发送的SQL语句显示出来 -->
    <property name="hibernate.show_sql">true</property>
    <!-- 格式化SQL语句 -->
    <property name="hibernate.format_sql">true</property>
    <!-- 自动创建表 -->
    <property name="hibernate.hbm2ddl.auto">update</property>
    <!-- 导入映射配置  -->
    <mapping resource="domain/Student.hbm.xml"/>
</session-factory>
</hibernate-configuration>
​

把Hibernate核心配置文件中的数据库配置部分放到Spring中，具体的全部代码见上文的applicationContext.xml，注意数据库部分在Spring中配置之后就可以了，不用再在Hibernate中配置了。

配置Spring的数据池， SessionFactory，事务等。
c3p0数据池配置：
　　<!-- 注册c3p0数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <!--处理中文乱码问题-->
        <property name="jdbcUrl" value="jdbc:mysql:///test?useUnicode=true&amp;characterEncoding=utf8"/>
        <property name="user" value="root"/>
        <property name="password" value="8246"/>        
    </bean>
​
​
SessionFactory要是交给Spring来管理如下：
 　　<!-- 配置SessionFactory -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <!-- 注入数据池 -->
        <property name="dataSource" ref="dataSource"></property>
        <!-- 指定hibernate核心配置文件 -->
        <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
    </bean>
​
事务的配置，博主采用的是基于注解的方式
　　<!-- 配置声明式的事务管理（采用基于注解的方式） -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    <tx:annotation-driven transaction-manager="transactionManager"/>
​
其次则为dao与service的bean的注册,具体见上文的applicationContext.xml
六.测试代码　　　　　　　　　　　　　　　　
​
1.准备工作：
action:代码见上文
dao类与dao实现类:
public interface StudentDao {
    void insert(Student student);
    void delete(Student student);
    void update(Student student);
    List<Student> selectAllStudents();
    boolean selectStudentByIdAndName(String name,int age);
}　
​
 
 
​

//DAO的实现类，里面注入了SessionFactory对象，利用这个我们可以获取session
@Transactional
public class StudentDaoImpl implements StudentDao{
  //这里的sessionFactory由Spring进行注入
  private SessionFactory sessionFactory;
  //所以这里需要setter方法，这里的getter方法顺带添上，如果以后需要获取sessionFactory的话可以调用
  public SessionFactory getSessionFactory() {
      return sessionFactory;
  }
  //依赖注入，需要setter方法
  public void setSessionFactory(SessionFactory sessionFactory) {
      this.sessionFactory = sessionFactory;
  }
  //CRUD操作
  @Override
  public void insert(Student student) {
      sessionFactory.getCurrentSession().save(student);
  }
  @Override
  public void delete(Student student) {
      sessionFactory.getCurrentSession().delete(student);
  }
  @Override
  public void update(Student student) {
      sessionFactory.getCurrentSession().update(student);
  }
  @Override
  public List<Student> selectAllStudents() {
      String hql = "from Student";
      return sessionFactory.getCurrentSession().createQuery(hql).list();
  }
  //通过name和age来判别学生是否存在
  @Override
  public boolean selectStudentByIdAndName(String name, int age) {
      String hql = "from Student where name=? and age=?";
      boolean flag = false;
      if(sessionFactory.getCurrentSession().createQuery(hql).setString(0, name).setInteger(1, age).uniqueResult()!=null) {
          flag = true;
      }
      return flag;
  }
}
​
domain包中的实体类与配置文件见上文。
service类与service实现类：
//service接口
public interface StudentService {
  void add(Student student);
  void remove(Student student);
  void modify(Student student);
  List<Student> findAllStudents();
  boolean findByNameAndAge(String name,int age);
}
​

//service实现类
public class StudentServiceImpl implements StudentService {
    //这里的Dao对象是由Spring注入，下面要有setter方法
    private StudentDao studentDao; 

    public StudentDao getStudentDao() {
        return studentDao;
    }
    public void setStudentDao(StudentDao studentDao) {
        this.studentDao = studentDao;
    }
    //业务实现
    @Override
    public void add(Student student) {
        studentDao.insert(student);
    }
    @Override
    public void remove(Student student) {
        studentDao.delete(student);
    }
    @Override
    public void modify(Student student) {
        studentDao.update(student);
    }
    @Override
    public List<Student> findAllStudents() {
        return studentDao.selectAllStudents();
    }
    @Override
    public boolean findByNameAndAge(String name, int age) {
        return studentDao.selectStudentByIdAndName(name, age);
    }
}
index.jsp中
<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>register</title>
</head>
<body>
   <form action="register" method="post">
            姓名<input type="text" name="name"><br>
            年龄<input type="text" name="age"><br>
            <input type="submit" value="注册">    
   </form>
</body>
</html>
​
 
 
数据库：

console：

七.总结　　　　　　　　　　　　　　　　　
​

1. 导入jar包

2. 搭建struts2环境

    2.1 创建Action，创建struts.xml配置文件

    2.2 在web.xml中配置struts2的过滤器

3. 搭建Hibernate环境

    3.1 创建实体类

    3.2 配置实体类和数据库表的映射关系

    3.3 创建hibernate核心配置文件，并引入映射配置文件

4. 搭建Spring环境

    4.1 创建Spring的核心配置文件

    4.2 让spring配置文件在服务器启动的时候加载，其中需要配置监听器和指定Spring配置文件的路径

5. struts2和spirng整合

    5.1 把action在spring配置（action多实例的）

    5.2 在struts.xml中action标签class属性里面写bean的id值

6. spring和hibernate整合

    6.1 把hibernate核心配置文件中数据库的配置放到spring里面配置

    6.2 把hibernate的sessionFactory在Spring中配置

7. 在dao中使用HibernateTemplate的对象

    7.1 在dao中注入hibernateTemplate对象

    7.2 在hibernate对象中注入sessionFactory

8. 配置事务

​
 
 
 
 
 
 
 
​
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/Swen3252/p/9452811.html