06.Spring+Struts2+Hibernate整合(SSH)

最新推荐文章于 2024-07-25 11:59:12 发布
最新推荐文章于 2024-07-25 11:59:12 发布
阅读量65 收藏
点赞数
分类专栏： Spring学习 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ycjcson/article/details/112152779
版权

06.Spring+Struts2+Hibernate整合(SSH)

一、Spring+Struts2整合

1.使用maven创建工程，引入相关依赖(pom文件中)
<!--设置统一版本号-->
<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
        <springVersion>5.1.1.RELEASE</springVersion>
    </properties>
<!--引入相关依赖-->
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <!--Struts2核心-->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>2.5.26</version>
        </dependency>
        <!--Struts2对Spring的支持-->
        <!-- https://mvnrepository.com/artifact/org.apache.struts/struts2-spring-plugin -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-spring-plugin</artifactId>
            <version>2.5.26</version>
        </dependency>

        <!-- Spring核心容器 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${springVersion}</version>
            <scope>compile</scope>
        </dependency>
        <!-- Spring核心 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${springVersion}</version>
        </dependency>
        <!-- Spring核心对象管理 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${springVersion}</version>
        </dependency>
        <!-- Spring核心表达式 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${springVersion}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${springVersion}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${springVersion}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${springVersion}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${springVersion}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-oxm</artifactId>
            <version>${springVersion}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jms</artifactId>
            <version>${springVersion}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${springVersion}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${springVersion}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${springVersion}</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/javax.servlet.jsp-api -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.3</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
2. 创建信息输入页面

在webapp目录下创建index.jsp页面

<html>
<body>
<h2>Hello World!</h2>
</body>
</html>
3. 创建Controller
package com.zb.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class UserController {

    @Autowired
    private UserService userService;

    public String login(){

        System.out.println("请求被Struts捕捉到了");

        System.out.println(userService);

        return "success";
    }

}
4.创建Service
package com.zb.controller;

import org.springframework.stereotype.Service;

@Service
public class UserService {
	//相关代码
}
5.在resources目录下创建相关配置文件
<?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"
       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">

    <!--开启扫描-->
    <context:component-scan base-package="com.zb"/>
</beans>
6.配置struts配置文件
<?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>
    <!--根命名空间 namespace="/"-->
    <!--package：类似于java中的包-->
    <!--extends：类似于java中的继承特征，extends="struts-default"就是继承struts-default.xml，它里面定义了许多跳转类型、拦截器等一些常用的东西-->
    <package name="userPackage" extends="struts-default" namespace="/user">
        <action name="login" class="userController" method="login">
            <result>index.jsp</result>
        </action>
    </package>
</struts>
7.配置webapp目录下的WEB-INF下的web.xml文件
<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
    <display-name>Archetype Created Web Application</display-name>

    <!--核心过滤器StrutsPrepareAndExecuteFilter prepare与execute前者表示准备，可以说是指filter中的init方法，即配制的导入；后者表示进行过滤，指		doFilter方法，即将request请求，转发给对应的 action去处理-->
    <filter>
        <filter-name>dispatcherFilter</filter-name>
        <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>dispatcherFilter</filter-name>
        <!--指定filter的匹配方式有两种方法：直接指定url-pattern和指定servlet，后者相当于把指定的servlet对应的url-pattern作为filter的匹配模式

			filter的路径匹配和servlet是一样的-->
        <url-pattern>/*</url-pattern>
        <servlet-name>ProductServlet</servlet-name>    
        <!--
			可以在一个<filter-mapping>元素中加入任意数目的<dispatcher>，使得filter将会作用于直接从 客户端过来的request，通过forward过来的					request，通过 include过来的request和通过<error-page>过来的request。如果没有指定任何< dispatcher >元素，默认值是REQUEST。
		-->
        <dispatcher>INCLUDE</dispatcher>
        <!--
			REQUEST ---直接从客户端传递过来的，则必须经过这个过滤器

            FORWARD---通过request dispatcher的forward方法传递过来，则必须经过这个过滤器

            INCLUDE---通过request dispatcher的include方法传递过来，则必须经过这个过滤器

            ERROR---通过<error-page>过来的，则必须经过这个过滤器
		-->
    </filter-mapping>

    
	<!-- 加载spring的配置文件 -->    
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!--
		web.xml的配置中<context-param>配置作用
        1. 启动一个WEB项目的时候,容器(如:Tomcat)会去读它的配置文件web.xml.读两个节点: <listener></listener> 和 <context-param></context-			param>
        2.紧接着,容器创建一个ServletContext(上下文),这个WEB项目所有部分都将共享这个上下文.
        3.容器将<context-param></context-param>转化为键值对,并交给ServletContext.
        4.容器创建<listener></listener>中的类实例,即创建监听.
        5.在监听中会有contextInitialized(ServletContextEvent args)初始化方法,在这个方法中获得ServletContext = 							   ServletContextEvent.getServletContext();
        context-param的值 = ServletContext.getInitParameter("context-param的键");
        6.得到这个context-param的值之后,你就可以做一些操作了.注意,这个时候你的WEB项目还没有完全启动完成.这个动作会比所有的Servlet都要早.
        换句话说,这个时候,你对<context-param>中的键值做的操作,将在你的WEB项目完全启动之前被执行.
        7.举例.你可能想在项目启动之前就打开数据库.
        那么这里就可以在<context-param>中设置数据库的连接方式,在监听类中初始化数据库的连接.
        8.这个监听是自己写的一个类,除了初始化方法,它还有销毁方法.用于关闭应用前释放资源.比如说数据库连接的关闭.
	-->
</web-app>

二、Spring+Struts2+Hibernate整合

1.引入相关依赖(pom文件中)
<!--springVersion(自定义标签)统一版本号-->
<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
        <springVersion>5.1.1.RELEASE</springVersion>
    </properties>
	
	<!--引入相关依赖-->
    <dependencies>
        <dependency>
            <!--用于测试-->
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <!--Struts2核心-->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>2.5.26</version>
        </dependency>
        <!--Struts2对Spring的支持-->
        <!-- https://mvnrepository.com/artifact/org.apache.struts/struts2-spring-plugin -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-spring-plugin</artifactId>
            <version>2.5.26</version>
        </dependency>

        <!-- Spring核心容器 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${springVersion}</version>
            <scope>compile</scope>
        </dependency>
        <!-- Spring核心 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${springVersion}</version>
        </dependency>
        <!-- Spring核心对象管理 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${springVersion}</version>
        </dependency>
        <!-- Spring核心表达式 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${springVersion}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${springVersion}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${springVersion}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${springVersion}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${springVersion}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-oxm</artifactId>
            <version>${springVersion}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jms</artifactId>
            <version>${springVersion}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${springVersion}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${springVersion}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${springVersion}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/javax.servlet.jsp-api -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.3</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.4.25.Final</version>
        </dependency>
    </dependencies>
2. 创建信息输入页面

webapp目录下创建登录页面login.jsp

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2020/12/11
  Time: 14:24
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="user/login" method="post">
        账号：<input type="text" name="userName"><br/>
        密码：<input type="text" name="userPwd"><br/>
        <input type="submit" value="登录">
    </form>
${requestScope.resMsg}
</body>
</html>

创建注册页面register.jsp

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2020/12/11
  Time: 16:42
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="user/register" method="post">
        账号：<input type="text" name="userName"><br/>
        密码：<input type="text" name="userPwd"><br/>
        <input type="submit" value="登录">
    </form>
    ${requestScope.resMsg}
</body>
</html>
3. 创建持久化类(entity)
package com.zb.entity;
/* spring数据库中user表的持久化类*/
public class UserInfo {

    private Integer userId;
    private String userName;
    private String userPwd;

    public UserInfo() {
    }

    public UserInfo(Integer userId, String userName, String userPwd) {
        this.userId = userId;
        this.userName = userName;
        this.userPwd = userPwd;
    }

    @Override
    public String toString() {
        return "UserInfo{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", userPwd='" + userPwd + '\'' +
                '}';
    }

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUserPwd() {
        return userPwd;
    }

    public void setUserPwd(String userPwd) {
        this.userPwd = userPwd;
    }
}
4. 创建 Dao 层
package com.zb.dao;

import com.zb.entity.UserInfo;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.query.Query;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

/*
* 使用Spring自动扫描并装配 （Spring将指定包中所有被@Mapper注解标注的接口自动装配为hibernate的映射接口
*/
@Repository
public class UserDao {

    @Autowired
    private SessionFactory sessionFactory;
    
    //使用JdbcTemplate的方式
    //private JdbcTemplate jdbcTemplate;

    /*
     *   输入账号密码，验证登录
     * */
    //查询
    public Long selectUserCountByUserAndPassword(UserInfo userInfo){
        //使用JdbcTemplate的方式
        //return jdbcTemplate.queryForObject(" SELECT COUNT(1) FROM user_info WHERE user_name = ? AND user_pwd = ? ",
                //Integer.class,userInfo.getUserName(),userInfo.getUserPwd());

        Query q = sessionFactory.getCurrentSession().createQuery(" SELECT COUNT(*) FROM UserInfo WHERE userName = :un AND userPwd = :up ").
                setParameter("un",userInfo.getUserName()).
                setParameter("up",userInfo.getUserPwd());

        return (Long)q.getSingleResult();

    }
	
    //添加
    public Integer insertUserInfo(UserInfo userInfo){
        Integer l = (Integer)sessionFactory.getCurrentSession().save(userInfo);
        return 0;
    }

    //修改
    public Integer updateUserInfo(UserInfo userInfo){
        System.out.println(userInfo);
        userInfo.setUserName("yuyu");
        sessionFactory.getCurrentSession().update(userInfo);
        return 0;
    }

}
5. 创建 Service 层
package com.zb.service;

import com.zb.dao.UserDao;
import com.zb.entity.UserInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;


@Service
public class UserService {

    @Autowired
    private UserDao userDao;

    /*加上注解@Transactional可以指定这个类需要受Spring的事务管理，
	注意@Transactional只能针对public属性范围内的方法添加
	查询：@Transactional只需要设置为readOnly = true
	*/
    @Transactional(readOnly = true)
    
    //登录
    public boolean checkLogin(UserInfo userInfo){
        System.out.println("我是查询方法！");
        //相关代码
        return userDao.selectUserCountByUserAndPassword(userInfo)>0;
    }

    @Transactional
    //注册
    public boolean registerUserInfo(UserInfo userInfo){
        Integer l1 = userDao.insertUserInfo(userInfo);

        userDao.updateUserInfo(userInfo);

        return l1>0;
    }
    
    /*//默认传播机制：PROPAGATION_REQUIRED  
    * Propagation setting is PROPAGATION_REQUIRED.  
    //默认隔离级别：ISOLATION_DEFAULT  
    * Isolation level is ISOLATION_DEFAULT.  
    //默认事务是read/write.到此知道查询配readOnly的作用。  
    * Transaction is read/write.  
    //事务默认超时时间取决于事务系统，也有可能没有，如果事务系统不支持。  
    * Transaction timeout defaults to the default timeout of the underlying transaction system, or to none if time outs are not supported.  
    //任何的RuntimeExcetipn将触发回滚，任何的checkedException不触发回滚。  
    * Any RuntimeException triggers rollback,and any checkedException does not. 
    在一个应用中，依据事务的隔离级别将会有三种情况发生。 
　　◆ 脏读（dirty read）：当一个事务读取另一个事务尚未提交的修改时，产生脏读。 
　　◆  不可重复读（non-repeatable read）：同一查询在同一事务中多次进行，由于其他提交事务所做的修改或删除，每次返回不同的结果集，此时发生非重复	·读。： 
　　◆  幻像读（phantom read）：同一查询在同一事务中多次进行，由于其他提交事务所做的插入操作，每次返回不同的结果集，此时发生幻像读。 

1.Read Committed: 
假设A事务对正在读取数据Data放置了共享锁，那么Data不能被其它事务改写，所以当B事务对Data进行读取时总和A读取的Data数据是一致的，所以避免了脏读。由于在A没有提交之前可以对Data进行改写，那么B读取到的某个值可能会在其读取后被A更改从而导致了该值不能被重复取得；或者当B再次用相同的where字句时得到了和前一次不一样数据的结果集，也就是幻像数据。 

2.Read Uncommitted： 
假设A事务即不发布共享锁，也不接受独占锁，那么并发的B或者其它事务可以改写A事务读取的数据，那么并发的C事务读取到的数据的状态和A的或者B的数据都可能不一致，那么。脏读、不可重复读、幻象数据都可能存在。 

3.Repeatable Read： 
（注意MSDN原文中的第一句话：在查询中使用的所有数据上放置锁，所以不存在脏读的情况）。 
假设A事务对读取的所有数据Data放置了锁，以阻止其它事务对Data的更改，在A没有提交之前，新的并发事务读取到的数据如果存在于Data中，那么该数据的状态和A事务中的数据是一致的，从而避免了不可重复的读取。但在A事务没有结束之前，B事务可以插入新记录到Data所在的表中，那么其它事务再次用相同的where字句查询时，得到的结果数可能上一次的不一致，也就是幻像数据。 

4.Serializable： 
在数据表上放置了排他锁，以防止在事务完成之前由其他用户更新行或向数据集中插入行，这是最严格的锁。它防止了脏读、不可重复读取和幻象数据。 
    */

}
6. 创建 Action层（Controller ）
package com.zb.action;

import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ModelDriven;
import com.zb.entity.UserInfo;
import com.zb.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

import java.util.Map;

@Controller
public class UserAction implements ModelDriven<UserInfo> {

    @Autowired
    private UserService userService;

    private UserInfo userInfo;

    public String login(){
        System.out.println("请求到了");
        System.out.println(userInfo);
        Map<String,Object> requestMap = (Map<String,Object>)ActionContext.getContext().get("request");
        if(userService.checkLogin(userInfo)){
            requestMap.put("resMsg",userInfo);
            return "success";
        }
        requestMap.put("resMsg","用户名或密码错误！");
        return "login";
    }

    public String register(){
        System.out.println("请求到了");
        System.out.println(userInfo);
        if(userService.registerUserInfo(userInfo)){
            return "login";
        }
        Map<String,Object> requestMap = (Map<String,Object>)ActionContext.getContext().get("request");
        requestMap.put("resMsg","注册失败！");
        return "register";
    }

    @Override
    public UserInfo getModel() {
        userInfo = new UserInfo();
        return userInfo;
    }
}
7. 创建用户信息显示页面
<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2020/12/11
  Time: 14:24
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>欢迎！${requestScope.resMsg.userName}</h1>
</body>
</html>
8. 创建相关配置文件
1）web.xml

在 WEB-INF 目录下创建 web.xml 文件，并在该文件中实例化 ApplicationContext 容器、启动 Spring 容器、配置 DispatcherServlet以及配置字符编码过滤器

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    
    <!--配置核心过滤器-->
    <filter>
        <filter-name>dispatcherFilter</filter-name>
        <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>dispatcherFilter</filter-name>
        <!--过滤所有*-->
        <url-pattern>/*</url-pattern>
    </filter-mapping>
 <!-- 实例化ApplicationContext容器 -->
    <context-param>
        <!-- 加载src目录下的 applicationContext-*.xml文件-->
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
</web-app>
2）在resources目录下配置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.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
	
    <!--开启对包的扫描-->
    <context:component-scan base-package="com.zb"/>
    <!--配置数据库的相关参数-->
    <bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql:///user_db?characterEncoding=UTF-8"/>
        <property name="user" value="root"/>
        <property name="password" value="123456"/>
    </bean>

    <!--
        Hibernate的Session工厂交给Spring管理了
    -->
    <bean name="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <!--SessionFactory需要数据源才能连接数据库-->
        <property name="dataSource" ref="dataSource"/>
        <!--创建SessionFactory工厂的时候需要得知配置文件的位置，在这里进行配置-->
        <property name="configLocation" value="classpath:/hibernate.cfg.xml"/>
        <!--Hibernte需要获取映射文件的存放位置-->
        <!--映射器告诉spring到哪里去找映射文件-->
        <property name="mappingLocations" value="classpath:/mapper/*.hbm.xml"/>
    </bean>

    <!--配置Hibernate专用事务管理器-->
    <bean name="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <!--<property name="dataSource" ref="dataSource"/>-->
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

    <!--开启事务注解驱动-->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>
3）配置hibernate.cfg.xml文件
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
  <session-factory>
    <!--不需要连接相关的配置，因为连接池已经被Spring管理，我们只需使用-->
    <!--Hibernate本身的配置-->
    <property name="hibernate.show_sql">true</property>
    <property name="hibernate.format_sql">true</property>
    <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
    <property name="hibernate.hbm2ddl.auto">update</property>
    <!--Hibernate的Session绑定线程，Thread的绑定在整合框架中不能使用，如果你要通过getCurrentSession获取能够传递的Session，则必须让Session与Spring控制Hibernate的线程绑定-->
    <property name="hibernate.current_session_context_class">org.springframework.orm.hibernate5.SpringSessionContext</property>
    <!--所有映射文件的位置通过Spring配置SessionFactory的时候进行指定-->
  </session-factory>
</hibernate-configuration>
3-1创建cfg.xml的映射文件hbm.xm文件夹mapping(user.hbm)
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.zb.entity">
    <class name="UserInfo" table="user_info">
        <id name="userId" column="user_id">
            <generator class="native"></generator>
        </id>
        <property name="userName" column="user_name"/>
        <property name="userPwd" column="user_pwd"/>
    </class>
</hibernate-mapping>

4)配置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>
    <package name="userPackage" extends="struts-default" namespace="/user">
        <action name="login" class="userAction" method="login">
            <result>/index.jsp</result>
            <result name="login">/login.jsp</result>
        </action>
        <action name="register" class="userAction" method="register">
            <result>/login.jsp</result>
            <result name="register">/register.jsp</result>
        </action>
    </package>
</struts>

5). 发布并运行应用

首先将 springSSHDemo 应用发布到 Tomcat 服务器并启动 Tomcat 服务器，然后通过地址“http://localhost:8080/springSSHDemo/login.jsp”访问信息输入页面

jv_xiaobai_yu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring之SSH整合（spring+struts2+hibernate）
m0_60375943的博客
10-26 359
简介： ssh为 struts+spring+hibernate的一个集成框架，是一种Web应用程序开源框架。 前段时间的博客分别介绍了Struts、Spring、Hibernater这几大框架，今天就来把框架整合一下。 1.SSH整合的思路步骤 web+spring+struts+hibernate+杂鱼（比如缓存echache框架、日志,tomcat等等） web3.1.xml配置 <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
Spring+Struts2+hibernate整合
m0_37307255的博客
04-12 2423
SSH三大框架整合（1）struts2（2）hibernate5.x（3）spring4.x回顾SSH框架知识点Hibernate框架1、 hibernate核心配置文件（1）orm思想- 对象关系映射（1）数据库信息（2）hibernate信息（3）映射配置（4）hibernate核心配置文件- 如果单纯使用hibernate框架，核心配置文件名称 hibernate.cfg.xml和位置 sr...
SSH spring+struts2+hibernate整合步骤
Mc_chao1022的博客
11-20 389
说明：这里是使用eclipse来编写SSH，初次整理，请多关照！ 具体整合步骤如下： 1.添加相对应的jar包（36个jar包） 2.添加hibernate配置文件 hibernate.cfg.xml 3.添加spring配置文件applicationContex.xml（如不想修改配置，请将文件放置WEB-INF目录下） 4.配置applicationContex.xml：    4
SSH（Spring+Struts2+Hibernate）整合过程
qq_41934990的博客
07-06 1206
在整合框架的过程中，每一步都要测试，这样容易排查出问题，出现问题也就得从头开始第一步，导包将需要的jar包导入到项目中hibernate所需要的jar包struts2所需要的jar包spring所需要的jar包导包时，如果发现是同一个包，版本不同一定要删除一个（建议低版本）因为高版本可以兼容低版本Struts2-spring-plugin-2.3.24.jar一旦导入了该包，struts2在启动的...
Struts2+spring+hibernate整合
Jaosn.Yang的博客
11-15 2655
第四章 搭建SSH框架 本章目标 掌握Spring与Struts 2的集成重点（难点） 掌握Spring与Hibernate的集成重点（难点） SSH系统程序架构 SSH架构 Struts 2 + Spring + Hibernate 以Spring作为核心框架，数据持久化使用Hibernate完成，表现层使用Struts 2 Spring提供对象管理、面向切面编程等实用功能 通过...
spring+struts2+hibernate（SSH整合）
09-11
这是spring、struts2、hibernate三大框架的整合过程详细文档，有兴趣的可以看看，spring structs2
最新版本的Struts2+Spring4+Hibernate4框架整合
10-15
整合使用最新版本的三大框架（即Struts2、Spring4和Hibernate4），搭建项目架构原型。 项目架构原型：Struts2.3.16 + Spring4.1.1 + Hibernate4.3.6。 此外，还有：log4j、slf4j、junit4、ehcache等知识点。 项目...
Spring+Struts2+hibernate+Redis整合
12-02
在IT行业中，SSH（Spring、Struts2、Hibernate）是一个经典的Java Web开发框架组合，而Redis则是一个高性能的键值存储系统，常用于缓存和数据持久化。将SSH与Redis整合，可以提升应用程序的性能和响应速度。下面将...
详解JAVAEE——SSH三大框架整合（spring+struts2+hibernate）
08-30
详解JAVAEE——SSH三大框架整合（spring+struts2+hibernate） 知识点一：SSH三大框架整合概述 SSH三大框架整合是指将Spring、Struts2和Hibernate三个框架进行整合，以便于在JAVAEE项目中实现复杂的业务逻辑。这种...
ssh(spring+struts+hibernate) 视频 整合
10-19
需要自己下载,如果有问题,请联系我,我会尽快解决,谢谢大家的支持
Vue 3 和 SpringBoot 实现文件分片上传示例
exlink2012的专栏
07-22 457
实现分片上传，并使用Spring Boot在后端保存文件。前端将文件分片并逐个上传到后端，后端接收到所有分片后再进行合并，最终保存为一个完整文件。
SpringMVC 控制层框架-下
woai3364的博客
07-20 1104
因此，在开发过程中，合理处理异常、避免异常产生、以及对异常进行有效的调试是非常重要的。如果张三负责的模块按照 A 方案处理异常，李四负责的模块按照 B 方案处理异常...各个模块处理异常的思路、代码、命名细节都不一样，那么就会让整个项目非常混乱。在Web 应用三层架构体系中，表述层负责接收浏览器提交的数据，业务逻辑层负责数据的处理。一个网站有 5、6个资源，其中有一个为登录资源，两个无需登录即可访问，另外三个需要登录后才能访问，如果不登录就访问那三个资源，需要拦截，并且提示登录后访问。
SpringBoot添加密码安全配置以及Jwt配置
最新发布
qq_64468032的博客
07-25 710
然后修改之前的SecurityConfig配置类，里面的configure方法里面的.antMatchers里面追加的url是不需要验证就能进行使用的请求，比如登录注册等url请求的放开，需要的话可以一直追加。如果数据库中的密码没有加密，可以通过测试类将密码进行加密，然后用加密之后的字符串与数据库中的数据进行替换即可。通过以下操作可以直接从token中获取用户的信息，然后通过用户的信息进行验证并返回用户需要的信息。在没有配置的情况下，默认用户名为 user ，密码在控制台中查找（如下）。
SpringBoot启动命令过长
tiantiantbtb的博客
07-24 262
Error running 'DromaraApplication': Command line is too long. Shorten command line for DromaraApplication or also for Spring Boot default configuration?
spring-from表单
weixin_51482243的博客
07-22 879
2.Controller定义的接口指定consumes，produces对应的是客户端请求header的Content-Type，Accept；标记在方法上,对应接口的第2层地址；500是请求头Accept=text/plain,接口代码produces=MediaType.TEXT_PLAIN_VALUE,但代码响应是某类的对象;3.面试题/接口文档-要求请求参数是int类型，测试请求参数时还是字符串，但开发的代码需要类型转换，如@RequestParam(name="xx")Integer xx,
sed利用脚本处理文件
2201_75549363的博客
07-25 709
sed 命令是利用脚本来处理文本文件。它可以依照脚本的指令来处理、编辑文本文件。主要用来自动编 辑一个或多个文件、简化对文件的反复操作、编写转换程序等。
Spring通过工厂方法进行配置
学习笔记，人工智能，教程，技术分享！
07-21 469
工厂类CarStaticFactoryxml配置。
【OAuth2系列】集成微信小程序登录到 Spring Security OAuth 2.0
c18213590220的博客
07-21 1723
本文将详细介绍如何在 Spring Security OAuth 2.0 中扩展支持微信小程序登录，通过自定义授权方式实现无缝登录。
SpringBoot 测试Control接口方法
zhugedali_的博客
07-21 596
例如，如果 Controller 方法调用了服务层的某个方法来获取数据并进行处理，在单元测试中可以使用 Mockito 来模拟服务层方法的返回值，然后验证 Controller 方法基于这个模拟返回值所做出的后续处理是否正确。- 构建请求：可以设置请求的方法（如 GET 、 POST 、 PUT 、 DELETE 等），添加请求参数（通过 param() 方法）、请求头（通过 header() 方法），还可以设置请求体内容（对于 POST 、 PUT 等请求）。
SSH框架整合实战教程：Spring+Hibernate+Struts
"SSH框架整合实战教程，包括Spring、Hibernate、Struts的集成应用" SSH框架整合是Web开发中的一种经典组合，它结合了Struts、Spring和Hibernate三个强大的开源框架，构建出高效、灵活的Web应用程序。Struts作为MVC...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值