ssh第四讲--Struts2、Spring5、Hibernate整合

SSH项目整合:无障碍整合Struts2+Spring+Hibernate(详解+案例+源代码) 删除版本低的。 阅读详情

Struts2、Spring5、Hibernate整合

软件:MyEclipse

一、创建Maven项目:
  1. new一个maven项目
  2. 将jdk换成1.8、web module换成3.0
  3. web.xml:
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0">
  <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>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring.xml</param-value>
  </context-param>
</web-app>
  1. pom.xml:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>20200529-SSH</groupId>
  <artifactId>20200529-SSH</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>20200529-SSH Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <properties>
       <!-- 统一源码的编码方式 -->
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
       <!-- 统一各个框架版本 -->
       <struts.version>2.5.10</struts.version>
       <spring.version>4.3.8.RELEASE</spring.version>
       <hibernate.version>5.1.7.Final</hibernate.version>
   </properties>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
     <!-- Spring 核心依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Spring web依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Spring整合ORM框架依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Struts2 核心依赖 -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>${struts.version}</version>
        </dependency>
        <!-- Struts2和Spring整合依赖 -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-spring-plugin</artifactId>
            <version>${struts.version}</version>
        </dependency>
        <!-- Hibernate 核心依赖 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <!-- MySQL 依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.42</version>
        </dependency>
        <!-- C3P0 依赖 -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5</version>
        </dependency>
        <!-- AspectJ依赖 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.10</version>
        </dependency>
        <!-- SLF4J依赖 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.25</version>
        </dependency>
         <!-- 导入java ee jar 包 -->  
        <dependency>  
            <groupId>javax</groupId>  
            <artifactId>javaee-api</artifactId>  
            <version>7.0</version>  
        </dependency>
        <!-- Servlet api -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>3.1.0</version>
			<scope>provided</scope>
		</dependency>

		<!-- JSTL -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
			<type>jar</type>
			<version>1.2</version>
		</dependency>  
  </dependencies>
  <build>
    <finalName>20200529-SSH</finalName>
    <plugins>
            <!-- 统一源代码编译输出的JDK版本 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.6.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <!-- 打包时跳过单元测试 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.19.1</version>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>
            <!-- 集成Tomcat插件 -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <path>/${project.artifactId}</path>
                </configuration>
            </plugin>
        </plugins>
  </build>
</project>
二、struts2、Spring5、hibernate配置:

src/main/resources:

  1. jdbc.properties(数据库配置)文件:
jdbc.url=jdbc:mysql://localhost:3306/数据库名?useSSL=true&characterEncoding=UTF-8
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.username=xxx
jdbc.password=xxx
  1. log4j.properties(打印日志信息):
log4j.rootCategory=INFO, console
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{yyyy-MM-dd HH\:mm\:ss} %5p %t %c{2}\:%L - %m%n
  1. spring.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"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.3.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
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 开启包扫描,并注册注解 -->
    <context:component-scan base-package="com.lxf.*"/>
    <!-- 引入属性文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 配置C3P0连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!-- 数据库连接相关信息 -->
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="driverClass" value="${jdbc.driverClass}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!-- 配置Hibernate的SessionFactory -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <!-- 注入连接池 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 配置Hibernate属性 -->
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.show_sql">true</prop><!-- 是否展示SQL -->
                <prop key="hibernate.hbm2ddl.auto">update</prop><!-- 是否自动创建表结构 -->
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
            </props>
        </property>
        <!-- 扫描并加载注解过的实体类 -->
        <property name="packagesToScan" value="com.lxf.model"/>
    </bean>

    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <!-- 注入SessionFactory -->
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

    <!-- 配置事务增强 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- 配置需要进行事务管理的方法,和事务传播行为 -->
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!-- 配置切面 -->
    <aop:config>
        <!-- 配置切入点 com.yjq.ssh.*.service.*+.*(..)
            * org.ssh.service.*+.*(..)
                *:表示方法的作用域,*表示所有
                org.ssh.service.*:表示org.ssh.service下的任何包
                org.ssh.service.*+:表示org.ssh.service下的任何包及其子包
                *(..):*表示任何方法,(..)表示方法的任何参数
         -->
        <aop:pointcut id="pointcut" expression="execution(* com.lxf.service.*+.*(..))"/>
        <!-- 适配切入点和事务增强 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"/>
    </aop:config>
</beans>
  1. struts2配置:
<?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="default" extends="struts-default" namespace="/">
        <default-action-ref name="default" />
        <action name="default">
            <result>/index.jsp</result>
        </action>
    </package>

    <!-- 商品相关请求转发 -->
    <!-- Struts2在2.5版本后添加strict-method-invocation(严格方法访问),默认为true,不能使用动态方法调用功能,故需设为false -->
    <package name="commodity" extends="struts-default" namespace="/"
        strict-method-invocation="false">
        <!-- 保存商品 -->
        <action name="commodity_*" class="com.lxf.action.CommodityAction" method="{1}Commodity">
            <result>/index.jsp</result>
            <result name="input">/index.jsp</result>
        </action>
    </package>

    <!-- 引入资源文件 -->
    <constant name="struts.custom.i18n.resources" value="messageResource"></constant>

</struts>
三、Java类测试

src/main/java/com/lxf:

action包(controller层):

package com.lxf.action;

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

import com.opensymphony.xwork2.ActionSupport;
import com.lxf.model.Commodity;
import com.lxf.service.CommodityService;

/**
 * 商品操作-控制层
 *
 */
@Controller
@Scope("prototype")
public class CommodityAction extends ActionSupport {

    private static final long serialVersionUID = 1L;
    @Autowired
    private CommodityService commodityService;
    private String pname;
    private double price;

    /**
     * 保存商品操作
     * 
     * @return
     */
    public String saveCommodity() {
        Commodity commodity = new Commodity(pname, price);
        commodityService.saveCommodity(commodity);
        this.addActionMessage("保存成功...");
        return SUCCESS;
    }

    public String getPname() {
        return pname;
    }

    public void setPname(String pname) {
        this.pname = pname;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;

    }

    @Override
    public void validate() {
        if(pname == null || "".equals(pname.trim())) {
            this.addFieldError("pname", "商品名称不能为空");
        }
    }

}

dao包(model层):

CommodityDao接口:

package com.lxf.dao;

import com.lxf.model.Commodity;

/**
 * 商品操作-持久层接口
 *
 */
public interface CommodityDao {
    void saveCommodity(Commodity commodity);
}

impl.CommodityDaoImpl实现类:

package com.lxf.dao.impl;

import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.stereotype.Repository;

import com.lxf.dao.CommodityDao;
import com.lxf.model.Commodity;



/**
 * 商品信息-服务层实现
 *
 */
@Repository
public class CommodityDaoImpl implements CommodityDao {

	//Hibernate快捷操作模板,封装部分底层。
	//opensession,要自己开session,要自己关session
	//开关全都是内部封装的
    private HibernateTemplate template;
    @Autowired
    public CommodityDaoImpl(SessionFactory sessionFactory) {
        this.template = new HibernateTemplate(sessionFactory);
    }
    
	@Override
	public void saveCommodity(Commodity commodity) {
		// TODO Auto-generated method stub
		template.save(commodity);
	}
    
}

model包(model层):

Commodity实体类:

package com.lxf.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;

@Entity
@Table(name="commodity", catalog = "gc0910")
public class Commodity {

    @Id
    @GeneratedValue(generator = "id")
    @GenericGenerator(name = "id", strategy = "native") //自定义主键生成策略 generator = name
    private int id;// 商品ID
    @Column(length = 100)
    private String name;// 商品名称
    @Column()
    private double price;// 商品价格

    public Commodity() {
    }

    public Commodity(String name, double price) {
        this.name = name;
        this.price = price;
    }

    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 double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

model包(model层):

CommodityService接口:

package com.lxf.service;

import com.lxf.model.Commodity;

/**
 * 商品操作-服务层接口
 *
 */
public interface CommodityService {
    void saveCommodity(Commodity commodity);
}

impl.CommodityServiceImpl实现类:

package com.lxf.service.impl;

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

import com.lxf.dao.CommodityDao;
import com.lxf.model.Commodity;
import com.lxf.service.CommodityService;

@Service
public class CommodityServiceImpl implements CommodityService {

    @Autowired
    private CommodityDao commodityDao;

	@Override
	public void saveCommodity(Commodity commodity) {
		commodityDao.saveCommodity(commodity);
	}

}

整合之后的Hibernate template用法:https://www.cnblogs.com/xrab/p/5586775.html

eclipse搭建(Struts2.5+Spring5.0+hibernate5.2)整合框架Demo实例 eclipse手动搭建(Struts2.5+Spring5.0+hibernate5.2)整合框架,可运行实例 立即下载

相关推荐

struts2spring5hibernate5整合包

struts2.5.14,spring5.0.3,hibernate5.12整合包,测试正常

框架(Spring、Struts2和Hibernate三者)整合

总结一下就是: 1.Struts2与Spring相连的是:action不是Struts2框架new 出来的,而是从Spring的xml(applicationContext.xml)配置文件中拿出 2.Spring和Hibernate相通的是:Hibernate的SessionFactory采用Spring注入,同时dao的实现类继承Spring的类(HibernateDaoSupport)

~~~~~~~~~~~~ 4787

SSH三大框架整合 struts2+hibernate+spring (全注解方式进行配置)

SSH三大框架整合 struts2+hibernate+spring (全注解方式进行配置)

SSH入门Spring篇(1)——struts2+hibernate5+spring5整合

文章目录1.写在前面spring的作用对控制反转的理解2.一个非常简单的spring例子(由依赖类到依赖接口)导入spring的4个基础jar包以及common-logging-1.2.jar抽象接口 ICustomerDao.java实现类 CustomerDao.java配置文件 applicationContext.xml测试代码3.ssh框架整合 1.写在前面 spring的作用 传统设计...

yogima的博客 2121

GD32F103RCT6/GD32F303RCT6(6.2)USART串口实战:从寄存器配置到DMA高效传输

本文详细介绍了GD32F103RCT6和GD32F303RCT6的USART串口通信实战,从寄存器配置到DMA高效传输的全过程。通过具体的代码示例和优化建议,帮助开发者快速掌握串口通信的关键技术,提升嵌入式开发效率。特别强调了DMA在高速数据传输中的优势和应用技巧。

weixin_33725239的博客 308

SSH框架整合分析,以Hibernate5、Spring5、Struts2为例

1.下载Hibernate源文件 下载地址:Hibernate5.0.0RELEASE 下载完成后,解压,选取lib下required中的核心文件 antlr-2.7.7.jar dom4j-1.6.1.jar hiber...

chuxi3409的博客 361

[USACO2023-JAN-Bronze] T2 Air Cownditioning II 题解

[USACO2023-JAN-Bronze] T2 Air Cownditioning II题解

1652

SSM(springmvc+spring+mybatis)整合过程

SSM(springmvc+spring+mybatis)整合过程 一、SSM框架比较S2SH框架的优缺点比较 站在个人使用这两个框架的观点儿上来说的话,我觉得这个不能定死的说,常用的S2SH,SpringMVC等,还可以考虑jFinal。 首先说S2SH,这个是用的比较多的,特别是在中小型项目中,针对大型项目就不行了,是Struts和hibernate过于庞大,过于

Summer_YuXia的博客 1135

系统磁盘从MBR格式转换成GPT格式来升级win11

之前的《》中说到,需要把磁盘格式转化为MBR格式才能执行下去。问题是,win10升级win11要求启动方式为UEFI的话,磁盘格式不能为MBR。其实不升级也不影响啥,但是就是想好看点。所以花了点时间折腾了一下。我这是双系统,所以直接去A系统修复B系统的磁盘格式和引导。

qq_42520962的博客 9041

GEOPHYSICS 投稿避坑指南:从格式规范到双盲评审的实战解析

本文详细解析了GEOPHYSICS期刊投稿的全流程避坑指南,从格式规范、数据声明到双盲评审的实战策略。特别强调了数学公式排版、图表制作标准以及投稿系统的隐藏关卡,帮助作者避免常见错误,提升投稿成功率。

weixin_30606461的博客 236

Spring整合Struts2和Hibernate5

Spring整合Struts和Hibernate 一. 整合方式分类 1.零障碍整合(带hibernate的配置文件) 2. 不带有hibernate配置文件 二. spring的整合的思想 将Struts中和hibernate中需要创建的对象和配置文件中的信息整合到spring中 Hibernate中的sessionFactory 三. 具体的实...

ѧѦ ѧ 776

从封装到先进封装:一文讲透Chiplet、2.5D/3D堆叠与系统集成

封装是芯片产业链中连接硅片与电路板的桥梁,承担物理保护、电气连接、散热与机械支撑等核心任务。传统封装从DIP、QFP发展到BGA,通过提升引脚密度满足早期性能需求。随着摩尔定律放缓,单纯缩小晶体管尺寸难以为继,先进封装应运而生,其核心理念从“封装单颗芯片”转向“系统级高密度集成”。扇出型封装、2.5D硅中介层、3D堆叠、Chiplet和系统级封装等技术,通过微米级互连和垂直堆叠,大幅提升I/O密度与带宽,成为AI芯片、HBM存储、高性能计算等领域的关键支撑。本文梳理先进封装的技术演进、分层架构与工程难点,帮

weixin_29185167的博客 369

SSH之IDEA2017整合Struts2+Spring+Hibernate

推荐大家使用maven解决依赖问题,可以省去手动解决依赖的问题,项目参考:链接 摘要 IDEA无疑是Java编程的利器,在下面我们将介绍如何使用IDEA来整合SSH(Struts2 + Spring + Hibernate);介绍將分为三个部分来讲,分别是新建工程,Spring引入并测试, Hibernate引入并测试,Struts2引入并测试; 下面使用的IDEA的版本是2017.1 以下...

kevin的专栏 3万+

ESP32-CAM 赋能 AI 视觉巡检小车:自主避障与目标追踪实现全解析

本文基于 ESP32-CAM 实现了低成本 AI 视觉巡检小车的核心功能,硬件成本<100 元,兼顾自主避障与目标追踪。算法升级:移植 YOLOv5nano 量化模型(INT8),提升目标检测精度(如识别巡检场景中的 “异常物体”“人员”);无线拓展:通过 MQTT 协议将巡检图像、距离数据上传到阿里云 / 腾讯云,实现远程监控;多传感器融合:增加温湿度(DHT11)、红外测温(MLX90614)模块,扩展巡检维度;路径规划:结合 SLAM 算法,实现自主建图与路径巡检。

weixin_42300449的博客 368

【Java基础篇】Java重要特性,JDK,JRE,JVM区别和联系,环境变量

JDK使用时的执行流程: • 开发者视角(需要开发java程序):需要安装JDK a. 首先使用JDK调用Tools&Tool APIs(开发者工具)编写好Java程序--xxx.java b. 再次调用Tools&Tool APIs中的javac.exe(编译程序)来编译.java文件(将java文件编译成字节码.class文件) c. 调用java.exe来启动JRE d. 在JRE上运行JAVA字节码(加载特定的.class文件,调用这个class文件中的main方法

Yaoyao2024的博客 2163

SSH框架搭建和整合(struts2、spring4、hibernate5)

声明:  本博文是个人通过对ssh框架的学习、理解还有一些看法而描述出来的,可能有不足之处,请大家谅解,但希望能帮助到大家! 目的: 使初学者能更好的去了解SSH框架。 给以后的自己,也给别人一个参考。 尝试搭建一个完整的SSH框架项目。 一、SSH三大框架的概述   ssh为 struts+spring+hibernate的一个集成框架,是目前较流行的一种Web...

weixin_30820077的博客 5078

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

SSH框架(Struts2+Spring+Hibernate)搭建整合详细步骤

​ 在实际项目的开发中,为了充分利用各个框架的优点,我们通常都会把Spring与其他框架整合在一起使用。本节将针对 SSH(Struts2、Hibernate和 Spring)框架的整合内容进行详细讲解。 ​

unber的博客 2517

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

struts2+spring4+hibernate5整合实例

struts2作为一个很传统的mvc框架,在一些项目中,仍然发挥着重要的作用,另外hibernate和spring的结合也是很常见的,这里介绍struts2+hibernate5+spring4的整合,因为struts2支持最高的spring是4版本,所以这里采用的是spring4。整合的思路比较简单,可以从struts2+spring整合,然后接着整合hibernate+spring。也可以反过...

feinifi的博客 1777

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

Spring2.5+Struts2+Hibernate3整合之五

转载请注明:来自http://blog.youkuaiyun.com/M_ChangGong/ 作者:张燕广该篇主要编写Service层代码以及针对Service层功能的Junit测试代码在src下创建包com.zyg.ssh.service,在该包下创建接口StudentService,其代码如下:package com.zyg.ssh.service;import java.util.

长弓的专栏 4088

SSH2 Step by Step- Step 4 - Struts2、Spring和Hibernate的整合

折腾了好几天,终于把SSH2的框架搭起来,期间经历的兴奋,痛苦,犹豫...最终是领悟:太完美的要求,其实就是拖延...所以在以下的jar包的选择上,跟前面几篇的原则有了很大的区别: Struts包保持原样。Spring 和hibernate的包按最大的导入,因为少了个jar文件导致的错误查找,实在是这两天最痛苦的事情。Hibernate从4.0降到3.6.8,原因是Hibernate4改

bruesz的专栏 3786

SSH框架搭建之整合Spring、Struts2、Hibernate

SSH框架搭建之整合Spring、Struts2、Hibernate,添加框架依赖,配置数据源会话工厂,进行简单测试

weixin_46741943的博客 1122

SSH的整合,Spring与Hibernate整合,与Struts2整合,ssh整合

前言,Spring管理实务,Hibernate控制持久层,Struts控制action层 一,Spring和hibernate的整合 导入Hibernate的jar包,在Hibernate文件夹下的 lib的required文件夹下。 导入Spring的jar包,在Spring的文件夹自行找(以上两个框架请自行上网下载 1、导入hibernate的包和Spring的包    1.1、导入

guin_guo的博客 1020

Spring+Struts2+Hibernate(ssh)三大框架整合流程

整合ssh三大框架详细流程,分两种方式整合Hibernate 一、SSH整合前的准备;二、Spring整合Struts2;三、Spring整合Hibernate一(带有Hibernate配置文件);四、Spring整合Hibernate二(不带有Hibernate配置文件);五、相关问题(如:延迟加载异常)

honhong1024的博客 2万+

SSH框架整合实战:从零搭建可运行的Struts2+Spring+Hibernate示例项目

在企业级Java Web开发中,SSH(Struts2+Spring+Hibernate)框架整合涉及版本兼容、依赖冲突、事务管理等核心问题。理解MVC分层架构与IoC/DI原理,掌握依赖注入和事务边界的配置方法,是提升老系统维护效率的关键。通过Maven管理依赖、Spring管理Bean生命周期、Hibernate实现ORM映射,开发者可快速构建稳定的增删改查应用。本文提供一套实测稳定的版本组合与完整配置方案,覆盖从环境准备到启动测试的全流程,并附常见报错排查清单,帮助开发者一次跑通SSH整合项目。

weixin_34026276的博客 371

SSH框架整合(Spring整合Struts2,和Spring整合Hibernate)

SSH整合原理: 导包:共40个jar包,其中:40=41-1(重复) Hibernate5(9): hibernate解压目录/lib/required struts2.3(14): struts2解压目录/apps/blank.war(空白项目) 注意...

chousheng1613的博客 218
上一篇: ssh第三讲--spring5概述、IoC与AOP
下一篇: ssm第一讲--Mybatis详细学习
Alvin Hansen
博客等级 码龄7年 46粉丝 156原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值