整合SSH(Spring, Struts, Hibernate)

最新推荐文章于 2023-12-18 18:10:29 发布
最新推荐文章于 2023-12-18 18:10:29 发布
阅读量147 收藏
点赞数
分类专栏： ssh框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41988977/article/details/81160232
版权

1.先建manve项目

2.完善基本的目录结构

3.配置pom.xml文件

 <maven.compiler.target>1.7</maven.compiler.target>
    <!--统一配置ssh的版本号-->
    <spring.version>3.1.1.RELEASE</spring.version>
    <hibernate.version>3.6.5.Final</hibernate.version>
    <struts2.version>2.3.1</struts2.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!-- java servlet api -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <!-- spring -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!--创建动态代理-->
    <dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib-nodep</artifactId>
      <version>2.2</version>
    </dependency>
    <!-- hibernate-->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>${hibernate.version}</version>
    </dependency>
    <!-- struts2 -->
    <dependency>
      <groupId>org.apache.struts</groupId>
      <artifactId>struts2-core</artifactId>
      <version>${struts2.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.struts</groupId>
      <artifactId>struts2-junit-plugin</artifactId>
      <version>${struts2.version}</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.apache.struts</groupId>
      <artifactId>struts2-spring-plugin</artifactId>
      <version>${struts2.version}</version>
    </dependency>
    <!-- mysql驱动包 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.0.5</version>
    </dependency>
    <!-- c3p0连接池 -->
    <dependency>
      <groupId>c3p0</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.1.2</version>
    </dependency>
    <!--json-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.47</version>
    </dependency>

  </dependencies>

  <build>
    <finalName>sshdaytest</finalName>

    <!--把xml映射文件强制性集合到项目发布到tomcat服务器-->
    <resources>
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.xml</include>
          <include>**/*.properties</include>
        </includes>
        <filtering>false</filtering>
      </resource>
      <resource>
        <directory>src/main/resources</directory>
        <includes>
          <include>**/*.xml</include>
          <include>**/*.properties</include>
        </includes>
        <filtering>false</filtering>
      </resource>
    </resources>
    <pluginManagement>

. Java代码层面

1）Entity层

1.1）先建立一个Database，位置在IDEA界面的右面点击Database---->点击界面的加号------->Data Source-----> Mysql---->根据自己的情况进行配置，相关截图如下：

这里补充一点，就是在建立自己的Mysql的时候，一定要点击里面的Test Connection,确认自己的配置是正确的；

4.生成之后右侧有如下图

  1.2）操作Persistence，自动生成Entity；我们可以看到在Idea界面里面看不到Persistence选项（将鼠标悬浮在左下角的正方形那里，截图如下），因为一开始使用maven来搭建项目，我们并没有显示引入hibernate，所以没有Persistence界面，所以我们作如下操作来显示加入Hibernate;  点击 File-----> Project Structure------>Modules----->点击+-------->选择Hibernate------>Apply------>OK; 看界面，我们可以看到 Persistence出现了，截图如下：

加入配置文件

      1.3）配置aplicationContext.xml，applicationContext.xml是spring的配置文件，因为在这个项目中我们需要让spring接管Hibernate的配置工作，所以我们直接建立applicationContext.xml文件并配置数据库信息， 为了方便数据库信息的管理，我们同时建立db.properties。所以我们的操作是在src/main/resources下面建立两个文件，一个是applicationContext.xml，一个是db.properties; 

）配置aplicationContext.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">
    <!-- 引入db.properties文件 -->
    <context:property-placeholder location="classpath:db.properties" />

    <!-- 开启注解annotation -->
    <context:annotation-config/>
    <!-- 开启扫描annotation自动注册bean,并检查@Controller, @Service, @Repository注解已被注入 -->
    <context:component-scan base-package="com.test.controller"/>
    <context:component-scan base-package="com.test.service"/>
    <context:component-scan base-package="com.test.dao" />

    <!-- c3p0连接池管理 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${database.driverClassName}"></property>
        <property name="jdbcUrl" value="${database.url}"></property>
        <property name="user" value="${database.username}"></property>
        <property name="password" value="${database.password}"></property>
        <!-- 设置数据库连接池的最大连接数 -->
        <property name="maxPoolSize">
            <value>50</value>
        </property>
        <!-- 设置数据库连接池的最小连接数 -->
        <property name="minPoolSize">
            <value>5</value>
        </property>
        <!-- 设置数据库连接池的初始化连接数 -->
        <property name="initialPoolSize">
            <value>5</value>
        </property>
        <!-- 设置数据库连接池的连接最大空闲时间 -->
        <property name="maxIdleTime">
            <value>20</value>
        </property>
        <!-- c3p0缓存Statement的数量数 -->
        <property name="maxStatements">
            <value>50</value>
        </property>
        <!-- 当连接池里面的连接用完的时候,C3P0再一下获取新的连接数 -->
        <property name="acquireIncrement">
            <value>20</value>
        </property>

    </bean>

    <!-- hibernate 管理-->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
        <!-- 引用上面设置的数据源 -->
        <property name="dataSource">
            <ref bean="dataSource" />
        </property>
        <!--hibennate参数设置-->
        <property name="hibernateProperties">
            <props>
                <!--方言-->
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <!--自动重复连接数据库-->
                <prop key="hibernate.autoReconnect">true</prop>
                <!--策略更新表结构和数据-->
                <prop key="hibernate.hbm2ddl.auto">update</prop>
                <!--控制台打印sql语句-->
                <prop key="hibernate.show_sql">true</prop>
                <!--格式化sql语句-->
                <prop key="hibernate.format_sql">true</prop>
                <!-- 解决session关闭问题 -->
                <prop key="hibernate.enable_lazy_load_no_trans">true</prop>
                <!--使用session-->
                <prop key="current_session_context_class">thread</prop>
                <!--启用二级缓存-->
                <prop key="hibernate.cache.provider_class">org.hibernate.cache.HashtableCacheProvider</prop>
                <!--外连接抓取树的最大深度 -->
                <prop key="hibernate.max_fetch_depth">3</prop>
                <!--再次连接的url-->
                <prop key="hibernate.connection.url">jdbc:mysql://localhost:3306/emp</prop>
                <!--再次连接数据库的驱动-->
                <prop key="hibernate.connection.driver_class">com.mysql.jdbc.Driver</prop>
            </props>

        </property>

        <!-- 扫描po层的类加载到hibernate -->
        <property name="packagesToScan">
            <list>
                <value>com.test.po</value>
            </list>
        </property>
        <property name="mappingLocations">
            <list>
                <value>classpath:com/test/po/Emp.hbm.xml</value>
                <value>classpath:com/test/po/Dept.hbm.xml</value>
            </list>
        </property>
        <!--加载所有的xml文件 会自动生成-->
        <!--<property name="mappingLocations">-->
            <!--<list>-->
                <!--<value>classpath:com/test/po/Dept.hbm.xml</value>-->
                <!--<value>classpath:com/test/po/Emp.hbm.xml</value>-->
            <!--</list>-->
        <!--</property>-->

    </bean>

    <!-- 用注解来实现事物管理 -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    <!--注册事务-->
    <tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true"/>
</beans>

               1.3.1) db.properties文件内容如下（是Mysq数据库的配置信息）

database.database=mysql
database.driverClassName=com.mysql.jdbc.Driver
database.username=root
database.password=root
database.show_sql=true
database.url=jdbc:mysql://localhost:3306/emp?useUnicode=true&characterEncoding=UTF-8

上面是这个项目完成的pom.xml文件，在这一步主要要配置的是dataSource这个bean 和sessionFactory这个bean
这里有一个要注意的，我们刚建立applicationContext.xml的时候，会在编辑界面出现一个黄条，如下

这个时候我们要点击“Configure application context”然后编辑，apply

        1.4) 生成Entity类；这个时候，如果上面正确的话,点击Persistence，会出现如下的界面：

我们右击sessionFactory--->Generate Persistence Mapping----> By Database Schema; 在Import Database Schema界面进行如下的选择

自动生成po层

4）Action层

Action主要是调用业务逻辑，结合struts.xml来进行处理页面跳转，我们是希望实现用户登录，在action包下建立一个UserAction.java，代码如下


@Controller("empAction")
@Scope("prototype")   //表示每次接受一个请求创建一个Action对象
public class EmpAction  extends ActionSupport {
    @Resource
    private EmpService empService;
    public  String index(){

//        添加
//        Emp emp=new Emp();
//        emp.setEmpname("胜勇");
//        emp.setJob("卖药的");
//        emp.setMgr(110);
//        emp.setHiredate(new Timestamp(new Date().getTime()));
//        emp.setSal(5000);
//        emp.setComm(200);
//        Boolean result = empService.insertEmp(emp);
//        if(result){
//            System.out.println("添加成功");
//        }
//        else {
//            System.out.println("添加失败");
//        }
//  删除
//        Boolean aBoolean = empService.deleteEmp(7);
//        System.out.println(aBoolean);


//        更改
//        Emp emp=new Emp();
//        emp.setEmpname("胜勇");
//        emp.setJob("卖药的");
//        emp.setMgr(110);
//        emp.setHiredate(new Timestamp(new Date().getTime()));
//        emp.setSal(5000);
//        emp.setComm(200);
//        emp.setDeptno(2);
//        emp.setEmpno(4);
//        Boolean aBoolean = empService.updateEmp(emp);
//        System.out.println(aBoolean);


        //根据id查询一条数据
//        Emp emp = empService.selectById(2);
//        System.out.println(emp);



        //查询全部
//        List<Emp> emps = empService.selectEmp();
//     for(Emp emp:emps){
//         System.out.println(emp);
//     }
        //多条件查询
//        List<Emp> emps = empService.selectBynameordept("王五", 2);
//        for (Emp emp:emps){
//            System.out.println(emp);
//        }
        //查询所有部门
        List<Dept> depts = empService.selectDept();
        for(Dept dept:depts){
            System.out.println(dept);
        }
        return "index";
    }

1）接下来我们要引入struts2， 首先还是在src/main/java/resources/下面建立一个struts.xml文件，内容如下

<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
        "http://struts.apache.org/dtds/struts-2.3.dtd">

<struts>
    <!--开发模式-->
    <constant name="struts.devMode" value="false"/>
    <!--struts2框架就会把bean转发给spring来创建，装配，注入。但是bean创建完成之后，还是由struts容器来管理其生命周期-->
    <constant name="struts.objectFactory" value="spring" />
    <package name="default" namespace="/" extends="struts-default">
        <action name="emp_*" class="com.test.controller.EmpAction" method="{1}">
            <result name="index">{1}.jsp</result>
        </action>

    </package>
</struts>

 

2) 配置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>
  <!-- spring容器监听器 -->
  <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>

</web-app>

以下再写其他层代码

不忘初心-倩
关注
专栏目录
最新版本的Struts2+Spring4+Hibernate4框架整合
10-15
整合使用最新版本的三大框架（即Struts2、Spring4和Hibernate4），搭建项目架构原型。 项目架构原型：Struts2.3.16 + Spring4.1.1 + Hibernate4.3.6。 此外，还有：log4j、slf4j、junit4、ehcache等知识点。 项目...
SSH(struts2,Hibernate,Spring)整合及测试亲测可用
10-27
SSH，即Struts2、Hibernate和Spring的组合，是Java Web开发中的一种经典框架集成，用于构建企业级的MVC（Model-View-Controller）应用。这个整合旨在提供一个高效、灵活且可扩展的开发环境，使开发者可以专注于业务...
IDEA 下写出第一个 SSH 整合框架练手项目( 一 ,Spring 与 Hibernate 整合)
过道
11-22 4747
最近几周快速的学完了 SSH 框架，因为很快，所以几乎没记住什么，又抄着视频写了一个项目，决定自己只看源码的再写一遍。 视频地址：  基于SSH实现员工管理系统之案例实现篇 我的源码地址 ： 点击进入 github
【Java编程】SSH：Struts、Spring、Hibernate
书山有路，学海无涯。记录成长，追逐梦想
12-18 942
SSH 框架指的是 Struts、Spring 和 Hibernate 三者的集成。集成 SSH 框架的系统从职责上分为表示层、业务逻辑层、数据持久层和域模块层。Struts 属于 MVC 框架的一种，提供了对 MVC 系统底层的支持，负责 MVC 的分离，在 Struts 框架的模型部分，控制业务跳转，利用 Hibernate 框架对持久层提供支持，Spring 则管理 Struts 和 Hibernate。
整合SSH(Spring+Struts+Hibernate)
weixin_47039303的博客
12-18 1028
0.前言, 由于工作需要故来学习SSH的整合,structs其实相当于(把view和controller结合起来,没有像现在的前后端分离,请求会发送给Action处理,在structs.xml映射地址和类) Hibernate(就是处理数据库的,几乎自动化,也可以写sql语句)在 SSH 框架中，Spring。//会调用action的方法,完成成员的变化,思路确实比较清晰,可是我要的数据如果是一次性的呢?//写配置文件的表和字段名和类型,不存在表会自动创建,其实高版本可以使用@Table来指定的,更方便。
java ssh框架 struts spring hibernate 简介
whatday的专栏
07-28 1539
目录 什么是SSH框架 浅谈Struts 什么是Struts Struts的核心构成 为什么使用Struts 浅谈Hibernate 什么是Hibernate Hibernate的核心构成 浅谈Spring 为什么使用Spring 什么是SSH框架 官方的说法：SSH是 struts+spring+hibernate的一个集成框架，是目前较流行的一种web应用程序开源框架。 SSH不是一个框架，而是把多个框架（Struts、Spring以及Hibernate）紧密的结合在一起.
Spring+Struts2+hibernate整合
m0_37307255的博客
04-12 2490
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 429
说明：这里是使用eclipse来编写SSH，初次整理，请多关照！ 具体整合步骤如下： 1.添加相对应的jar包（36个jar包） 2.添加hibernate配置文件 hibernate.cfg.xml 3.添加spring配置文件applicationContex.xml（如不想修改配置，请将文件放置WEB-INF目录下） 4.配置applicationContex.xml：    4
Struts2+spring+hibernate整合
Jaosn.Yang的博客
11-15 2693
第四章 搭建SSH框架 本章目标 掌握Spring与Struts 2的集成重点（难点） 掌握Spring与Hibernate的集成重点（难点） SSH系统程序架构 SSH架构 Struts 2 + Spring + Hibernate 以Spring作为核心框架，数据持久化使用Hibernate完成，表现层使用Struts 2 Spring提供对象管理、面向切面编程等实用功能 通过...
SSH框架整合过程（Struts2+Spring+Hibernate）
热门推荐
冷血之心的博客
12-29 1万+
在学习java框架的过程中，我总结过MySQL数据库图文安装详解及相关问题  手把手在MyEclipse中搭建Hibernate开发环境  手把手在MyEclipse中搭建Spring开发环境     MyEclipse中搭建Struts2开发环境  在将三大框架都学习一遍之后，再来看看如何整合SSH框架。先来看看SSH框架如何配合使用，如图所示： 整合步骤：1、导入所需jar包，下载地址：XXX
SSH框架（Struts2+Spring+Hibernate）搭建整合详细步骤
unber的博客
08-16 2141
​ 在实际项目的开发中，为了充分利用各个框架的优点，我们通常都会把Spring与其他框架整合在一起使用。本节将针对 SSH（Struts2、Hibernate和 Spring）框架的整合内容进行详细讲解。 ​
SSH 框架 struts-2.3.34 spring4.3.12 hibernate5.0.12
04-07
SSH框架，全称为Struts2、Spring和Hibernate的组合，是Java Web开发中常见的三大开源框架集成。这个框架集合提供了一种高效且强大的方式来构建企业级应用，它整合了模型-视图-控制器（MVC）设计模式、依赖注入（DI）...
SSH整合 Struts2.1+Spring4.1+Hibernate4.1
09-15
SSH整合是指将Struts2、Spring和Hibernate这三个流行的开源Java框架集成在一起，以构建高效、模块化的企业级Web应用程序。这个“SSH整合 Struts2.1+Spring4.1+Hibernate4.1”是一个预配置的框架模板，适用于快速开发...
详解JAVAEE——SSH三大框架整合（spring+struts2+hibernate）
08-30
详解JAVAEE——SSH三大框架整合（spring+struts2+hibernate） 知识点一：SSH三大框架整合概述 SSH三大框架整合是指将Spring、Struts2和Hibernate三个框架进行整合，以便于在JAVAEE项目中实现复杂的业务逻辑。这种...
一篇了解Struts2+Hibernate+Spring以及ssh集成框架
spirit_captive的博客
10-31 1017
本篇文章将基于Maven项目来讲解，如不懂maven,可以参考发布的前文 依赖下载的Maven网站：https://mvnrepository.com/ Struts2 struts是什么？ 基于mvc模式设计的一个web应用框架，是struts1的升级版，实现了servlet的功能，进而控制页面跳转。 用法： 1.环境搭建，在pom.xml中导入相关的依赖包 <properties> <junit.version>3.8.1</jun...
基于Java语言的蓝牙遥控器设计源码，支持键盘、鼠标、影音遥控器
最新发布
10-05
该项目为基于Java语言的蓝牙遥控器设计源码，包含539个文件，涵盖307个Java源文件、120个XML配置文件、34个PNG图片文件、16个Gradle构建文件、12个Git忽略文件、9个文本文件、6个JAR包文件、5个JSON配置文件、5个JPG图片文件。该遥控器支持键盘、鼠标和影音控制功能，适用于多种场合。
数据手册-74HC573-datasheet.zip
10-05
数据手册-74HC573-datasheet.zip
苏州科技大学在辽宁2020-2024各专业最低录取分数及位次表.pdf
10-05
那些年，与你同分同位次的同学都去了哪里？全国各大学在辽宁2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
SSH整合实战：Struts+Spring+Hibernate基础教程
"SSH整合实例，基于Struts、Spring和Hibernate的Web开发教程" SSH整合，即Struts、Spring和Hibernate的集成，是Java Web开发中常见的三层架构模式，用于实现模型-视图-控制器（MVC）设计模式。这个整合实例提供了一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值