SSH三大框架的搭建

完整代码在文章最后

一、Hibernate框架

1. Hibernate的核心配置文件

    1.1 数据库信息、连接池配置
    1.2 Hibernate信息
    1.3 映射配置
    1.4 Hibernate核心配置文件

	如果单纯使用Hibernate框架，核心配置文件名称hibernate.cfg.xml并且一定要放在src下面，
	而hibernate和spring整合的时候，hibernate核心配置文件名称和位置没有固定要求的
	（因为到时候会有一个参数指定其位置）。

2. Hibernate映射配置文件
    2.1 实体类和数据库表映射关系：使用的是ORM思想

3. hibernate操作的步骤
    3.1 在Spring框架对hibernate框架进行封装，使用HibernateTemplate类

二、Struts2框架

1. Action相关的操作

    1.1 action创建三种方式:
        写一个POJO，并在其中写上 public String execute();方法
        创建一个类并实现Action接口
        使用的最多的方法是集成类ActionSupport
    1.2 配置action访问路径
        创建struts.xml配置文件，这个文件名称和位置固定src下面
    1.3 配置访问action的多个方法
        使用通配符的方式配置比较常见
    1.4 在action获取表单提交数据
        获取request对象，Struts2提供的API有ActionContext和ServletActionContext
        属性封装
        模型驱动，要实现ModelDriven接口
    1.5 在action中操作域对象
        使用ServletActionContext获取域对象
    1.6 在web.xml中配置Struts提供的过滤器

3. 值栈

    值栈在开发中用得不多，掌握两点：
    2.1 向值栈中放数据
        set方法
        push方法
        定义变量生成get方法
    2.2 从值栈中获取数据
        在jsp中使用struts2标签+ognl获取
		  1 <s:property>
		  2 
		  3 <s:iterator>
		  
4. 拦截器
    3.1 AOP和责任链
    3.2 自定义拦截器
    
        自定义拦截器可以通过继承MethodFilerInterceptor创建

三、Spring框架

1. Spring框架核心配置文件
    1.1 名称和位置没有固定要求，官方推荐使用applicationContext.xml作为配置文件名
    1.2 在Spring核心配置文件中引入Schema约束

2. 创建对象
    2.1 xml配置方式：<bean id="" class="" />
    2.2 注解方式：四个注解，Component，Service，Controller，Repository

3. 注入属性
    3.1 xml配置方式
    3.2 注解方式：两个直接，Resource，Autowired

4. 使用ServletContext对象和监听器实现
    4.1 在服务器启动的时候，加载Spring，监听器的配置在web.xml中
    4.2 配置Spring的监听器
    4.3 指定Spring配置文件的位置
    4.4 要导入一个Spring整合web项目的jar包

5. AOP的思想以及JdbcTemplate的使用

四、SSH三大框架的整合思想

1. web应用的三层为：
    1.1 web层，（struts2），Struts2框架用的最多的是action
    1.2 service层（spring），spring中用的最多的是IoC和AOP，把对象的创建交给Spring进行管理
    1.3 dao层（hibernate），hibernate则是用来操作数据库，进行CRUD

2. 哪么这三个框架应该是如何整合呢？

    思想是两两整合：

    2.1 struts2和Spring进行整合
        2.1.1 在struts中action的创建交给Spring进行创建，但是要注意action是多实例的。
        2.1.2 要注意导入spring整合Struts2的jar包
        
    2.2 hibernate和Spring进行整合
        2.2.1 hibernate中的核心类是SessionFactory，这里要把SessionFactory的创建交给Spring进行管理
        2.2.2 Hibernate的核心文件中进行了数据库信息的配置，这里也可以交给Spring进行处理
     ![   2.2.3 为Dao对象配置持久层的Spring提供的Template
        2.2.4 注意导入Spring整合DAO层的ORM包

五、Struts2和Spring整合的具体步骤

把Struts2的action交给Spring进行管理
导包过程
2.1 Spring单独使用需要导入的jar包（spring-framework-5.0.2.）

2.2 Spring为了整合Struts还需要额外再导入一个jar包：

2.3 导入Struts2的jar包（struts-2.5.20）：
创建Action

import com.opensymphony.xwork2.ActionSupport;
import com.ssh.service.UserService;

public class UserAction extends ActionSupport {

    private UserService userService;

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    @Override
    public String execute() throws Exception {

        System.out.println("userAction .......");
        // 调用userService中方法发
        userService.add();

        return NONE;    // 表示返回到任何页面中去
    }

}

创建Strut2的核心配置文件struts.xml

<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE struts PUBLIC
	"-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
	"http://struts.apache.org/dtds/struts-2.5.dtd">
<struts>

    <package name="demo1" extends="struts-default" namespace="/">

        <!-- class属性是从Spring IoC中获取的 -->
        <action name="userAction" class="userAction">

        </action>

    </package>

</struts>

<!-- 实现Spring管理struts的Action
struts2和spring的整合，
关键点在于struts2中的action要纳入spring容器的管理中成为一个bean。
1.可以在struts.xml中配置： 
	<struts> 
	    <constant name="struts.objectFactory" value="spring" /> 
	    <action name="a" class="beanID">
	</struts> 
	或者
	也可以复制struts2-spring-plugin-x-x-x.jar到WEB-INF/lib目录下。
	该spring插件的作用就是关联struts action和spring bean，在struts.xml中就不必再配置 
	<constant name="struts.objectFactory" value="spring" />了。 	
2.同时action的配置class='beanID'，访问该Action时，会通过class对应值去spring中寻找相同id值的bean。 
-----------------------------------------------------------------------------------------------
1，action的class值应等于spring中的bean id值，实现关联，action由spring创建。 
2，若查不到，则由该spring插件根据class的值创建action，并把该action赋给spring托管，在这种情况下
action的创建不是由struts2完成，而是由插件完成，并且插件拥有把action纳入spring容器管理的功能，
此时spring配置文件中可以不必配置action的bean了。 
 
两种方式都使得action成为了spring中的一个bean实例。 
 
所以，class既可以为beanId，也可以为类路径，当寻找到对应bean时可以直接作为bean访问，
若寻找不到，则会由插件根据class类路径负责创建action实例并送给spring成为其管理的一个bean。 -->

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

<?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>00ssh</display-name>
 
  <filter>
       		<filter-name>struts2</filter-name>
       		<filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
   </filter>

    <filter-mapping>
         	<filter-name>struts2</filter-name>
      		<url-pattern>/*</url-pattern>
    </filter-mapping>
 </web-app>

至此，上面四步已经将Struts2的环境配置好了，然后就是来配置Spring了。

导入Spring整合Web项目的jar包，也就是监控项目启动的监听器所在的jar包。
创建Spring的核心配置文件applicationContext.xml,并在其中引入约束
这个约束配置的比较多，可以直接拿过来使用的。
把action交给Spring进行配置
但是如果Struts2和Spring像这样分别配置了Action的话，这样就不起作用了，
这里的做法就是不在Struts2的配置文件struts.xml中写全路径，而是让aciton
的class属性值等于bean id值，之所以这可以这样写的原因是我们导入了一个
Spring整合Struts2的一个jar包。

<?xml version="1.0" encoding="UTF-8"?>
<!-- 引入的Spring的约束，已经很全了 -->
<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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx.xsd">

	<!-- 配置action的对象 -->
    <!-- 注意action是多实例的，因此我们这里把scope配置为prototype的 -->
    <bean id="userAction" class="com.ssh.domain.UserAction" scope="prototype">
        <property name="userService" ref="userService"></property>
    </bean>
</beans>

Spring监听器的配置

接下来还要在web.xml中配置Spring的监听器，以及加入对应的参数，如果不配置的话，
那么项目启动的时候会报错，这两个要配全，不要配错了。

 <context-param>
    <param-name>contextConfigLocation</param-name>
    <!-- 这里如果bean.xml在包cn.ssh下，那么就应该写为：cn/ssh/bean.xml -->
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>

<!-- 配置Spring的监听器 -->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

测试准备
10.1 所需的为Struts2的核心配置文件：struts.xml
10.2 Spring的配置文件：bean.xml
10.3 项目的配置文件：web.xml
10.4 Struts2的UserAction类
10.5 在UserAction中对UserService的调用
10.6 UserService中对UserDao的调用
10.7 UserDao类的编写

~~---------------------------------------------------------------------------------------------------------------------------~~
至此，Spring和Struts2的整合已经完毕。然后是Spring对Hibernate的整合了。
~~---------------------------------------------------------------------------------------------------------------------------~~
六、Spring与Hibernate的整合
要解决两个问题：

把Hibernate中的核心配置文件中数据据库的配置交给Spring来管理
把Hibernate中SessionFactory的创建也是交给Spring来管理的
下面来看看具体的步骤：
3.1.1 导入Hibernate的jar包

3.1.2mysql的JDBC驱动包

3.1.3c3p0连接池的驱动包

导完了之后会发现有一个问题，在WEB-INF/lib中出现了这样的两个jar包：

javassist-x.x.x.GA.jar这个包分别是struts2和Hiber中所带，这里用的是高版本的那个，
因为可以向下兼容，因此我们从lib中删除低版本的那个。

3.2 Spring和ORM相关jar包的导入
Spring整合Hibernate也不是简简单单的那种整合，也是需要导入jar包

3.3 搭建Hibernate环境
3.3.1 创建一个实体类：User.java
3.3.2 创建User.java的hibernate映射文件user.hbm.xml
3.3.3 创建hibernate的核心配置文件hibernate.cfg.xml

3.4SessionFactory要是交给Spring来管理

以上配置要注意使用的Hibernate的版本，可以看出这里用的是5。

至此，ssh整个基本结束了

为了简化，省略了面向接口的过程。

七、完整代码：

class User ：

package com.ssh.domain;

public class User {

    private String id;

    private String username;

    private String password;

    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }

}

user.hbm.xml(也可以使用注解代替)：

<?xml version="1.0" encoding="UTF-8"?>

<!-- 引入Hibernate映射文件约束 -->
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

    <!-- class指定POJO类和数据库表之间的对应 -->
    <class name="com.ssh.domain.User" table="t_user" >

       <!-- id指定数据库中表的主键,以及主键生成策略 -->
       <id name="id" type="java.lang.String" column="id" >
           <generator class="native" />
       </id>

       <!-- property指定表字段和POJO中的属性的对应 -->
       <property name="username" type="java.lang.String">
           <column name="username" not-null="true" />
       </property>

       <property name="password" type="java.lang.String">
           <column name="password" not-null="true" />
       </property>

    </class>

</hibernate-mapping>

class UserDao：

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import com.ssh.domain.User;

public class UserDao {

	 private SessionFactory sessionFactory;
	    
	    public void setSessionFactory(SessionFactory sessionFactory) {
	        this.sessionFactory = sessionFactory;
	    }

    public void add() {

        System.out.println("userDao ......");
        
        Configuration cfg = new Configuration().configure();
        sessionFactory = cfg.buildSessionFactory();
       //获取session
       Session session = sessionFactory.openSession();
       Transaction tx=session.beginTransaction();
        // 用户添加的功能
        User user = new User();
        user.setUsername("露西");
        user.setPassword("123224");
        
        tx.commit();
        session.close();
        sessionFactory.close();
    }

}

class UserService：

package com.ssh.service;



import com.ssh.dao.UserDao;


public class UserService {

    private UserDao userDao;

    public UserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add() {
        System.out.println("userService ......");
         userDao.add();
    }

}

class UserAction：

package com.ssh.domain;

import com.opensymphony.xwork2.ActionSupport;
import com.ssh.service.UserService;

public class UserAction extends ActionSupport {

    private UserService userService;

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    @Override
    public String execute() throws Exception {

        System.out.println("userAction .......");
        // 调用userService中方法发
        userService.add();

        return NONE;    // 表示返回到任何页面中去
    }

}

hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- DTD是约束,可以在核心包里面找 -->
<!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>
    <!-- 指定数据库所用的驱动 -->
	<property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
	<!-- 指定连接数据库的url，其中hibernate是本应用连接的数据库名 -->
	<property name="hibernate.connection.url">jdbc:mysql:///demo?serverTimezone=Asia/Shanghai&amp;useSSL=true</property>
	<!-- 指定连接数据库的用户名 -->
	<property name="hibernate.connection.username">root</property>
	<!-- 指定连接数据库的密码 -->
	<property name="hibernate.connection.password">root</property>
	

        <!-- hibernate的配置信息 -->
        <!-- 配置数据库的方言,根据底层的数据库生成不同的SQL -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL8Dialect</property>
        <!-- 配置显示SQL -->
        <property name="hibernate.show_sql">true</property>
        <!-- 配置格式化SQL -->
        <property name="hibernate.format_sql">true</property>
        <!--根据需要自动创建数据表-->
        <property name="hibernate.hbm2ddl.auto">update</property>

        <!-- 配置C3P0连接池 -->
        <!-- 注意这个类要配置进去 -->
        <property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
        <!--在连接池中可用的数据库连接的最少数目 -->
        <property name="c3p0.min_size">5</property>
        <!--在连接池中所有数据库连接的最大数目  -->
        <property name="c3p0.max_size">20</property>
        <!--设定数据库连接的过期时间,以秒为单位,如果连接池中的某个数据库连接处于空闲状态的时间超过了timeout时间,就会从连接池中清除 -->
        <property name="c3p0.timeout">120</property>
        <!--每3000秒检查所有连接池中的空闲连接 以秒为单位-->
        <property name="c3p0.idle_test_period">3000</property>

        <!-- 设置jdbc的隔离级别 -->
        <property name="hibernate.connection.isolation">4</property>

        <!-- 加载映射文件 -->
        <mapping resource="com/ssh/domain/user.hbm.xml" />

    </session-factory>
</hibernate-configuration>

struts.xml

<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE struts PUBLIC
	"-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
	"http://struts.apache.org/dtds/struts-2.5.dtd">
<struts>

    <package name="demo1" extends="struts-default" namespace="/">

        <!-- class属性是从Spring IoC中获取的 -->
        <action name="userAction" class="userAction">

        </action>

    </package>

</struts>

<!-- 实现Spring管理struts的Action
struts2和spring的整合，
关键点在于struts2中的action要纳入spring容器的管理中成为一个bean。
1.可以在struts.xml中配置： 
<struts> 
    <constant name="struts.objectFactory" value="spring" /> 
    <action name="a" class="beanID">
</struts> 
或者
也可以复制struts2-spring-plugin-x-x-x.jar到WEB-INF/lib目录下。
该spring插件的作用就是关联struts action和spring bean，在struts.xml中就不必再配置 
<constant name="struts.objectFactory" value="spring" />了。 

2.同时action的配置class='beanID'，访问该Action时，会通过class对应值去spring中寻找相同id值的bean。 

1，action的class值应等于spring中的bean id值，实现关联，action由spring创建。 
2，若查不到，则由该spring插件根据class的值创建action，并把该action赋给spring托管，在这种情况下
action的创建不是由struts2完成，而是由插件完成，并且插件拥有把action纳入spring容器管理的功能，
此时spring配置文件中可以不必配置action的bean了。 
 
两种方式都使得action成为了spring中的一个bean实例。 
 
所以，class既可以为beanId，也可以为类路径，当寻找到对应bean时可以直接作为bean访问，
若寻找不到，则会由插件根据class类路径负责创建action实例并送给spring成为其管理的一个bean。 -->

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 引入的Spring的约束，已经很全了 -->
<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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx.xsd">

	<!-- 配置action的对象 -->
    <!-- 注意action是多实例的，因此我们这里把scope配置为prototype的 -->
    <bean id="userAction" class="com.ssh.domain.UserAction" scope="prototype">
        <property name="userService" ref="userService"></property>
    </bean>

    <!-- userService -->
    <bean id="userService" class="com.ssh.service.UserService">
        <property name="userDao" ref="userDao"></property>
    </bean>
    

	<!-- userDao -->
	<bean id="userDao" class="com.ssh.dao.UserDao">
	    <!-- 注入hibernateTemplate -->
	    <property name="sessionFactory" ref="sessionFactory"></property>
	</bean>



	<!-- 配置SessionFactory创建 -->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
	        <!-- 指定数据库信息，也就是给它一个dataSource -->
	       <!-- <property name="dataSource" ref="dataSource"></property> --> 
	        <!-- 指定hibernate核心配置文件 -->
	        <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
	</bean>
	

</beans>

最后测试：

访问：http://localhost:8080/00ssh/userAction

在这里插入图片描述
八、SSH整合过程

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. 配置事务

九、总结

1. 能不new就不new出来
    整个项目配置下来发现基本上是Spring掌控一切了，你要什么从我这里来拿行了，
    别自己（这里指的是Struts2和Hibernate）折腾。小项目这样感觉没有问题，
    但是模块变多的时候，岂不是显得Spring很臃肿？还是Spring可以通过引入
    其他的bean配置文件来分担配置。

2. 配置集中化
    这里配置的集中化主要是体现在将Struts2和Hibernate中的核心配置往Spring
    中转移，比如最明显的就是Action 和SessionFactory的配置。

3. 动别人的核心配置就要加jar包
    比如Struts2中对Action的配置是要找到Action的全路径的，但是，在整合之后只
    用加入一个Spring中国配置的id就可以了，试想如果不搞事情，Strut2一读Action
    的class中的值，绝逼报找不到类，所以我们在这里加入了一个Spring整合Spring
    的jar包；另外，Hibernate中Sessionfaction的创建是要读取Hibernate的核心配
    置文件的，直接在Spring中配置SessionFactory实例也做不到，因此也导入了
    Spring整合ORM持久层的jar包，并配置了相关的参数。

4. 通过IoC解耦
    像Spring这样一整合，确实有利于解耦合。

5. 对数据库的配置思路是，先获取其连接池对象，再指定SessionFactory的时候，
	只需要给它注入连接池就可以了

奋斗的熊猫

发布了63 篇原创文章 · 获赞 17 · 访问量 4085

私信关注

SSH三大框架的搭建

完整代码在文章最后

猜你喜欢