Spring(三)Spring整合Struts2、Hibernate

最新推荐文章于 2024-05-28 18:31:20 发布
最新推荐文章于 2024-05-28 18:31:20 发布
阅读量777 收藏 3
点赞数 1
分类专栏： javaweb 文章标签： spring hibernate struts2.0
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shuaicihai/article/details/54415548
版权

SSH整合

spring分别整合hibernate与struts。
spring管理hibernate中的对象以及struts中的对象。

整合原理

导包

hibernate

在lib下导入required下的包

struts2

导入apps下struts2-blank下的包
注意:删除重复的包,优先删除低版本.javassist.jar

struts2整合spring包,注意:该包的功能会在struts2启动时从application域寻找spring容器,如果找不到将会抛出异常.

spring

  • 导入4个核心包以及两个依赖包(bean、core、context、exception、apache下的log4j、logging)
  • spring-jdbc、spring-tx、spring-orm
  • 数据库驱动、c3p0连接池
  • spring-aop、spring-aspects
  • aspectj织入包、aop联盟
  • spring-web
  • spring-test、junit4类库

web

jstl.jar

整合spring到web项目

配置监听器

配置监听器,让spring容器随项目的启动而创建

<!--配置监听器-->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 指定容器的配置文件位置 -->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-name>classpath:applicationContext.xml</param-name>
</ocntext-param>

准备spring配置文件

在src目录下创建applicationContext.xml文件,并导入beans、context、aop、tx约束

整合struts2到web项目

创建Action对象

public class UserAction extends ActionSupport implements ModelDriven<User> {
    private User user = new User();
    public String regist() throws Exception {
        //1.service执行注册逻辑
        userService.regist(user);
        //2.重定向到登录页面
        return "toLogin";
    }
    @Override
    public User getModel() {
        return user;
    }
}

创建struts2配置文件

<struts>
    <package name="crm" namespace="/" extends="struts-default">
        <action name="userAction_*" class="cn.it.web.action.UserAction" method="{1}">
            <result name="toLogin" >/login.jsp</result>
        </action>
    </package>
</struts>

配置入口过滤器

<!--配置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>

spring整合strurs2

配置整合spring常量

在struts.xml中配置

<!--配置常量，指定由spring完成属性注入-->
<context name="struts.objextFactory" value="spring"></context>

struts2创建Action,由spring负责组装

方案一:Action对象仍然由struts2创建,spring负责组装依赖

  1. 指定由spring自动装配依赖属性


  2. 在action中准备依赖属性

    public class UserAction extends ActionSupport implements ModelDriven {
    private UserService userService;
    }

  3. 在spring中配置依赖属性对象

Action对象创建与依赖注入全部由spring完成

方案二:Action对象创建与依赖注入全部由spring完成(推荐使用)

  1. 将Action配置到spring容器中

    <bean name="userService" class="cn.it.service.UserServiceImpl"></bean>
<bean name="userAction" class="cn.it.web.action.UserAction">
    <property name="userService" ref="userService"></property>
</bean>

  2. 在Action配置中的class属性,填写对象的BeanName


    login.jsp

搭建Hibernate框架

准备实体与映射文件

如：

  • User.java
  • User.hbm.xml

准备主配置文件

  • 主配置文件名称：hibernate.cfg.xml
  • 导入dtd映射文件

  • 填写配置

    <hibernate-configuration>
    <session-factory>
        <!-- 5个必选 -->
         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
         <property name="hibernate.connection.url">jdbc:mysql:///hibernate</property>
         <property name="hibernate.connection.username">root</property>
         <property name="hibernate.connection.password">123</property>
         <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- 3个选选 -->
         <!-- 设置sql语句打印在控制台上 -->
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>

        <!-- 自动建表 -->
        <property name="hibernate.hbm2ddl.auto">update</property>

        <!-- 引入映射文件 -->
        <mapping resource="cn/test/domain/User.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

代码测试

@Test
//测试框架搭建是否成功
public void test(){
    Configuration conf = new Configuration().configure();
    SessionFactory sf = conf.buildSessionFactory();
    Session session = sf.opensession();
    //开启事务
    Transaction tx = session.beginTransaction();
    //执行操作
    session.sace(new User("测试"));
    //提交事务
    tx.commit();
    //关闭资源
    session.close();
    sf.close();
}

整合spring与hibernate

整合方式一:使用原生Hibernate配置文件

<!--配置sessionFactory-->
<bean name="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
    <!--使用原生hibernate.cfg.xml加载配置-->
    <property name="configLocation" value="classpath:hibernate.cfg.xml"></property> 
</bean>

整合方式二:将Hibernate配置转移到spring中

<!--将Hibernate配置转移到spring中-->
<bean name="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
    <!--指定可选|必选属性-->
    <property name="hibernateProperties">
        <props>
            <!--必选配置-->
            <prop key="hibernate.connection.driver_class">com.mysql.jdbc.Driver</prop>
            <prop key="hibernate.connection.url">jdbc:mysql:///hibernate</prop>
            <prop key="hibernate.connection.username">root</prop>
            <prop key="hibernate.connection.password">123</prop>
            <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
            <!--可选配置-->
            <prop key="hibernate.show_sql">true</prop>
            <prop key="hibernate.format_sql">true</prop>
            <prop key="hibernate.hbm2ddl.auto">update</prop>
        </props>
    </property>
    <!--引入映射文件-->
    <property name="" value=""></property>
</bean>

将c3p0连接池配置到SessionFactory中

准备db.properties

jdbc.jdbcUrl=jdbc:mysql:///hibernate
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.user=root
jdbc.password=123

读取db.properties

<context:property-placeholder location="classpath:db.properties" />

配置连接池对象,注入连接配置

<--c3p0连接池-->
<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
    <property name="driverClass" value="${jdbc.driverClass}"></property>
    <property name="user" value="${jdbc.user}"></property>
    <property name="password" value="${jdbc.password}"></property>
</bean>

将连接池对象注入到SessionFactory中

<!--将Hibernate配置转移到spring中-->
<bean name="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
    <!--将连接池注入SessionFactory-->
    <property name="dataSource" ref="dataSource"></property>
    <!--指定可选|必选属性-->
    <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>
            <prop key="hibernate.hbm2ddl.auto">update</prop>
        </props>
    </property>
    <!--引入映射文件-->
    <property name="" value=""></property>
</bean>

将Dao&Hibernate模板配置到spring

书写Dao类

public Class UserDaoImpl implements UserDao {
    private HibernateTemplate ht;

    public void setHt(HibernateTemplate ht){
        this.ht = ht;
    }

    public void save(User user){
        ht.save(user);
    }
}

配置Hibernate模板到spring

<!--配置Hibernate模板-->
<bean name="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate" >
    <property name="dataSource" ref="dataSource"></property>
</bean>

配置dao到spring

<bean name="userDao" class="cn.it.dao.impl.UserDaoImpl" >
    <property name="ht" ref="hibernateTemplate"></property>
</bean>

整合AOP事务

完成Service

public Class UserServiceImpl implements UserService {
    private UserDao userDao;

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

    public void regist(User user){
        userDao.regist(user);
    }
}

配置核心事务管理器

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

事务配置

xml配置
<!--配置事务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="save*" propagation="REQUIRED" read-only="false" isolation="REPEATABLE_READ"/>
        <tx:method name="update*" propagation="REQUIRED" read-only="false" isolation="REPEATABLE_READ"/>
        <tx:method name="delete*" propagation="REQUIRED" read-only="false" isolation="REPEATABLE_READ"/>
        <tx:method name="find*" propagation="REQUIRED" read-only="true" isolation="REPEATABLE_READ"/>
        <tx:method name="*" propagation="REQUIRED" read-only="false" isolation="REPEATABLE_READ"/>
    </tx:attributes>
</tx:advice>
<!--配置切面-->
<aop:config>
    <aop:pointcut experssion="execution(* cn.it.service.*serviceImpl.*(..))" id="txPC" />
    <aop:advice advice-ref="txAdvice" pointcut-ref="txPC" />
</aop:config>
注解配置
<!--开启注解管理事务开关-->
<tx:annocation-driven transaction-manager="transactionManager" />

Service中使用注解

@Transactional(propagation=Propagation.REQUIRED,readOnly=true,isolation=Isolation.REPEATABLE_READ)
public class UserServiceImpl implements UserService {

    @Transactional(propagation=Propagation.REQUIRED,readOnly=false,isolation=Isolation.REPEATABLE_READ)
    @Override
    public void regist(User user) {
        //1.判断注册名是否重复
        User existUser = userDao.getByUserCode(user.getUser_code());
        if (existUser != null) {
            throw new RuntimeException("用户名已经存在!");
        }
        //保存用户
        userDao.save(user);

    }
}

解决no-session问题

配置扩大session作用范围的过滤器

<!--注意:所有除struts2以外的过滤器都应配置到strut2过滤器之前-->
<!--解决no-session过滤器：OpenSessionInViewFilter-->
<filter>
    <filter-name>OpenSession</filter-name>
    <filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>OpenSession</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
宏微
关注
专栏目录
IntelliJ IDEA 下Spring整合Struts2、Hibernate
Coder Wang
09-20 1896
1. 整合原理： Spring与Struts2整合实际上是将Action对象交给Spring容器来负责创建。 Spring与Hibernate整合就是将sessionFactory交给Spring来负责维护，以及Spring维护session和aop事务。 2. 需要导入的特殊jar包 Hibernate中 java persist api java的持久化规范(接口) MySQL数据...
最新版本的Struts2+Spring4+Hibernate4框架整合
10-15
整合使用最新版本的三大框架（即Struts2、Spring4和Hibernate4），搭建项目架构原型。 项目架构原型：Struts2.3.16 + Spring4.1.1 + Hibernate4.3.6。 此外，还有：log4j、slf4j、junit4、ehcache等知识点。 项目...
SSH（第四步）—— 单独配置Hibernate框架到web项目
阿伟的博客
09-30 327
From : blog.mwxu16.cn 注意： 点击即可下载：完整的SSH项目整合Demo 一、导包（在第0步导包环节已经导入） 二、创建实体类这里创建两个实体类：
spring配置文件最全约束
zhengholien的java净土
09-12 1万+
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.spring
Spring+Struts2+hibernate整合
m0_37307255的博客
04-12 2479
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...
Struts2/Spring/Hibernate框架的整合与综合实例
pan_junbiao的博客
10-22 2942
1、框架介绍 1.1 Struts2框架 Struts是最早的Java开源框架之一，也是现在Java Web框架的事实标准。Struts是MVC设计模式一个优秀的实现。Struts定义了通用的Controller（控制器），通过配置文件（一般是struts-config.xml）隔离了Model（模型）和View（视图），以Action的概念对用户请求做了封装，使代码更清晰易读。到目前为止，S...
Struts2+spring+hibernate整合
Jaosn.Yang的博客
11-15 2686
第四章 搭建SSH框架 本章目标 掌握Spring与Struts 2的集成重点（难点） 掌握Spring与Hibernate的集成重点（难点） SSH系统程序架构 SSH架构 Struts 2 + Spring + Hibernate 以Spring作为核心框架，数据持久化使用Hibernate完成，表现层使用Struts 2 Spring提供对象管理、面向切面编程等实用功能 通过...
struts2+spring4+hibernate5整合实例
feinifi的博客
03-20 1586
struts2作为一个很传统的mvc框架，在一些项目中，仍然发挥着重要的作用，另外hibernate和spring的结合也是很常见的，这里介绍struts2+hibernate5+spring4的整合，因为struts2支持最高的spring是4版本，所以这里采用的是spring4。整合的思路比较简单，可以从struts2+spring整合，然后接着整合hibernate+spring。也可以反过...
spring框架与struts2框架的整合
weixin_43474701的博客
03-11 2081
spring与struts2的整合 1：单独配置struts 一：导入struts包 二：编写Action public class JboaEmployeeAction extends ActionSupport { public String login(){ System.out.println(“login…”); return SUCCESS; } } 三：配置struts.xml <?xml version="1.0" encoding="UTF-8" ?> i
Struts+Spring+Hibernate整合
最新发布
2401_85111576的博客
05-28 936
该文件中提供了Oracle11g和SQL Server两种数据库接口（接入点），甚至可以写入更多的数据库的信息，“#”是注销，即其后的代码不可用。3.整合Struts和Spring。
【Java编程】SSH：Struts、Spring、Hibernate
书山有路，学海无涯。记录成长，追逐梦想
12-18 918
SSH 框架指的是 Struts、Spring 和 Hibernate 三者的集成。集成 SSH 框架的系统从职责上分为表示层、业务逻辑层、数据持久层和域模块层。Struts 属于 MVC 框架的一种，提供了对 MVC 系统底层的支持，负责 MVC 的分离，在 Struts 框架的模型部分，控制业务跳转，利用 Hibernate 框架对持久层提供支持，Spring 则管理 Struts 和 Hibernate。
详解JAVAEE——SSH三大框架整合（spring+struts2+hibernate）
08-30
详解JAVAEE——SSH三大框架整合（spring+struts2+hibernate） 知识点一：SSH三大框架整合概述 SSH三大框架整合是指将Spring、Struts2和Hibernate三个框架进行整合，以便于在JAVAEE项目中实现复杂的业务逻辑。这种...
最新项目系统：Struts2+Spring4+Hibernate4三大框架整合
04-29
总的来说，"最新项目系统：Struts2+Spring4+Hibernate4三大框架整合"为学习和实践Java Web开发提供了一个实用的平台，对于提升开发者的技术水平和项目经验具有极大的帮助。通过深入研究和实践，开发者可以掌握Java ...
基于Struts2, Spring, Hibernate的整合实例设计源码
04-15
基于Struts2, Spring, Hibernate的整合实例设计源码，该项目包含27个文件，主要文件类型有14个java源文件，以及7个xml配置文件。此外，还包括2个properties文件，以及2个jsp页面文件。该项目是一个基于Struts2, ...
SSH(struts2,Hibernate,Spring)整合及测试亲测可用
10-27
在整合过程中，开发者需要注意配置文件的正确设置，包括Struts2的struts.xml、Hibernate的hibernate.cfg.xml以及Spring的applicationContext.xml等。还需要确保各框架之间的依赖注入正确无误，例如，Spring需要知道...
Shiro的认证和权限控制
热门推荐
宏微的博客
02-28 3万+
Shiro的权限和权限
Ehcache缓存的使用
宏微的博客
03-03 1万+
Ehcache缓存的使用
文件上传与下载的功能实现
宏微的博客
12-26 1万+
1、文件上传 1.1、文件上传原理 1.2、文件上传核心api 1.3、文件上传代码实现 2、文件下载案例实现
Excel文件一键上传并解析导入数据库
宏微的博客
02-15 1万+
文件一键上传 解析excel
Struts2、Spring、Hibernate三者整合详细教程
Struts2与Spring、Hibernate三者整合 Struts2、Spring 和 Hibernate三者整合是 Java Web 开发中的一种常见实践，通过将这三种技术结合起来，开发者可以充分发挥每种技术的优势，实现更高效、更灵活的Web应用程序。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值