正文

ssh框架整合中的备忘记录

Monkey_Hi猴子喂  Monkey_Hi猴子喂  2022-09-17  721

关键词：

整合ssh需要的jar包：
struts2-core.jar
struts2-convention-plugin-2.*.*.*.jar ------是struts2的注解开发jar包
struts2-spring-plugin-2.*.*.*.jar ------struts2用于整合spring的jar包
（spring中也有一个 spring-struts2的jar包，也是用来整合两个框架的jar包，引入其中一个可以）

Hibernate框架开发的响应的jar:
hibernate-core.*.jar
hibrenate目录下\lib\required\*.jar
bibernate目录下\lib\jpa\*.jar
日志相关记录： * slf4j整合log4j的jar包
以及数据库驱动包

spring框架开发的响应jar;
ioc:
spring-beans-*.*.*.release.jar
spring-context-*.*.*.release.jar
spring-core-*.*.*.ralease.jar
com.springsource.org.apache.log4j-*.*.*.jar
com.springsource.org.apache.commons.logging-*.*.*.jar

aop:
spring-aop-*.*.*.jar
spring-aspects-*.*.*.release.jar
com.springsource.org.aopalliance-*.*.*.jar
com.springcource.org.aspectj.weaver-*.*.*.release.jar

spring-tx-*.*.*.release.jar spring事务类包
spring-jdbc-*.*.*.release.jar
spring-orm-*.*.*.release.jar （整合hibernate框架）（过期）
已经变成这个spring-springframework-*.*.*.jar
spring-web-*.*.*.jar（整合web的包）
spring-test-*.*.*.release.jar （整合JUnit单元测试）
spring-struts2(与上面的二选一)
c3p0（连接池）

jar包链接: http://pan.baidu.com/s/1hr3YMu4 密码: tj5u

Struts2与Spring整合

web.xml文件配置

（Control + Shift + T 可以打开open type 查找类第一次用。）下面class中的路径都是可以用type 查找到。

<?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" 
            id="WebApp_ID" version="3.0">
    
    <!-- Spring的框架的核心监听器 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <context-param>
        <!-- 让监听器去加载classpath文件下的applicationContext.xml配置文件 -->
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
        
    <!-- Struts2的框架的核心过滤器的配置 -->
    <filter>
        <filter-name>struts</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    
    <filter-mapping>
        <filter-name>struts</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    
  <display-name>S1_SSH_zhenghe</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>    
  
</web-app>

　　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: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">

</beans>

Struts2与Spring整合（两种方法：一种是有Struts2 创建Action 反之则是Spring创建Action

Action类由Struts2自身创建（注意一下配置文件的区别就行了）

applicationContext.xml中

--Service和DAO的配置

<!-- 配置业务层的类 -->
    <bean id="productService" class="com.zz.service.ProductService">
        <property name="productDao" ref="productDao"></property>
    </bean>
     
    <!-- 配置DAO的类 -->
    <bean id="productDao" class="com.zz.dao.ProductDao"></bean>

struts.xml

   <package name="ssh" extends="struts-default" namespace="/">
       <action name="product_*" class="com.zz.action.ProductAction" method="{1}"></action>
   </package>

Action类交给Spring创建<推荐使用这种方式：能更好的使用aop>

applicationContext.xml中

--action、Service和DAO的配置

　　<!-- 配置Action类  因为是默认是单例，所以要加上scope-->
    <bean id="productAction" class="com.zz.action.ProductAction" scope="prototype">
        <!-- 手动注入Service -->
        <property name="productService" ref="productService"></property>
    </bean>
    <!-- 配置业务层的类 -->
    <bean id="productService" class="com.zz.service.ProductService">
        <property name="productDao" ref="productDao"></property>
    </bean>
     
    <!-- 配置DAO的类 -->
    <bean id="productDao" class="com.zz.dao.ProductDao"></bean>

struts.xml

<!-- 由Spring创建action  class填Spring配置文件中的id-->
   <package name="ssh" extends="struts-default" namespace="/">
           <action name="product_*" class="productAction" method="{1}"></action>
   </package>

与Hibernate整合

jdbc.properties

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssh
jdbc.username=root
jdbc.password=root

applicationContext.xml

<!--  引入外部文件 -->
    <context:property-placeholder location="classpath:jdbc.properties" />
    <!-- 配置连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClass}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    
    <!-- 配置hibernate的相关属性 -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <!-- 注入连接池 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 配置hibernate的属性 -->
        <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>
        <!-- 加载Hibernate中的映射文件 -->
    <property name="mappingResources">
        <list>
            <value>com/zz/domain/Product.hbm.xml</value>
        </list>
    </property>
    </bean>

配置DAO、事务管理器、开启注解

    <!-- 配置DAO的类 -->
    <bean id="productDao" class="com.zz.dao.ProductDao">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    
    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory"    ref="sessionFactory"></property>
    </bean>
    
    <!-- 开启注解事务 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

DAO类 extends HibernateDaoSupport 在save方法内不用set方法就可直接调用（this.getHibernateTemplate().save(product);）

添加注解后直接在 service类上添加一个 @Transactional 注解

以上就是各个整合的配置了下面是各个文件及类的全部的总代码

package com.zz.domain;

/*
 * 商品的实体
 */
public class Product {

    private Integer pid;
    private String pname;
    private Double price;
    
    public Integer getPid() {
        return pid;
    }
    public void setPid(Integer pid) {
        this.pid = pid;
    }
    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;
    }
}

package com.zz.dao;

import com.zz.domain.Product;

/*
 * 商品管理类的DAO类
 */
public class ProductDao extends HibernateDaoSupport{

    /**
     * DAO 中的保存商品的方法
     * @param product
     */
    public void save(Product product) {
        System.out.println("DAO中的方法执行了..");
        this.getHibernateTemplate().save(product);
    }

}

package com.zz.service;

import com.zz.dao.ProductDao;
import com.zz.domain.Product;

/*
 * 商品管理类的业务层类
 */
@Transactional

public class ProductService {

    private ProductDao productDao;

    public void setProductDao(ProductDao productDao) {
        this.productDao = productDao;
    }

    
    /**
     * 业务层保存商品的方法
     * @param product
     */
    public void save(Product product) {
        System.out.println("Service中的save方法执行了...");
        productDao.save(product);
        
    }
    
}

package com.zz.action;
/*
 * 管理类的Action类
 */

import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import com.zz.domain.Product;
import com.zz.service.ProductService;

public class ProductAction extends ActionSupport implements ModelDriven<Product>{

    //模型驱动使用个的类
    private Product product = new Product();
    @Override
    public Product getModel() {
        // TODO Auto-generated method stub
        return product;
    }
    
    //Struts和Spring整合过程中按名称自动注入的业务层
    private ProductService productService;

    public void setProductService(ProductService productService) {
        this.productService = productService;
    }

    /*
     * 保存商品的执行的方法：save
     */
    public String save(){
        System.out.println("Action中的方法执行了....");
        productService.save(product);
        return NONE;
    }
    
    
}

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<%@ taglib uri="/struts-tags" prefix="s" %>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
    
    <title>My JSP 'addProduct.jsp' starting page</title>
    
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">    
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="This is my page">
    <!--
    <link rel="stylesheet" type="text/css" href="styles.css">
    -->

  </head>
  
  <body>
  <h1>保存商品的页面</h1>
    <s:form action="product_save" method="post" namespace="/" theme="simple">
        <table border="1" width="400">
            <tr>
                <td>商品名称</td>
                <td><s:textfield name="pname"/></td>
            </tr>
            <tr>
                <td>商品价格</td>
                <td><s:textfield name="price"/></td>
            </tr>
            <tr>
                <td colspan="2"><input type="submit" value="添加"/></td>
            </tr>
        </table>
    </s:form>
  </body>

<!--addProduct.jsp-->

</html>

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" 
            id="WebApp_ID" version="3.0">
    
    <!-- Spring的框架的核心监听器 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <context-param>
        <!-- 让监听器去加载classpath文件下的applicationContext.xml配置文件 -->
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
        
    <!-- Struts2的框架的核心过滤器的配置 -->
    <filter>
        <filter-name>struts</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    
    <filter-mapping>
        <filter-name>struts</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    
  <display-name>S1_SSH_zhenghe</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-filessh框架整合
1、建立一个web项目2、导入Struts2框架点击next选择springPlugin包导入3、导入spring框架 点击next选择包4、导入hibernate框架选择如下配置mysql完成了   查看详情  
                
ssh框架整合项目
这里整合的是struts2+spring+hibernate框架，只是简单的整合。项目工程的结构如下： 下面是使用的pom文件。<properties><!--统一源码的编码方式--><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><!--统一各个框...  查看详情  
                
ssh框架的基本整合
SSH框架的基本整合AOP注解方式编写切面类（包含通知和切入点）开启自动代理JDBC模板技术Spring提供模板技术，数据库的操作以后编写DAO层，都可以继承JdbcDaoSupport类（JDBC模板）Spring框架可以整合开源连接池Spring事务管理Spring框...  查看详情  
                
ssh框架的基本整合
SSH框架的基本整合AOP注解方式编写切面类（包括通知和切入点）开启自己主动代理JDBC模板技术Spring提供模板技术，数据库的操作以后编写DAO层，都能够继承JdbcDaoSupport类（JDBC模板）Spring框架能够整合开源连接池Spring事务管理Sprin...  查看详情  
                
ssh框架整合shiro权限
关于整合shiro，首先在ssh整合的基础上进行组合1.首先，要导入几个依赖（整合ssh与shiro的依赖）：    <properties><shiro.version>1.3.2</shiro.version> //整合shiro的版本</properties>  <de  查看详情  
                
ssh框架整合
学习搭建框架有得于对框架的理解，排错也比较有思路。这次文章介绍使用eclipse详细整合Spring、Struts2和Hibernate的过程。需求：使用SSH框架对用户信息保存到数据库中。做的过程中会遇到很多问题，一步一步慢慢来，整合完Struts2...  查看详情  
                
ssh框架整合的其它方式
--------------------siwuxie095                SSH框架整合的其它方式		    1、主要是整合			Spring框架和Hibernate框架时，可以不写  查看详情  
                
spring学习————整合web项目(ssh)
　　　　　清楚了spring的IOC和AOP，最后一篇就来整合SSH框架把，记录下来，以后应该会用的到。　　　　　　　　　　　　　　　　　　　　--WH一、web项目中如何使用spring？　　　　　　当tomcat启动时，就应该加载spring的配置...  查看详情  
                
ssh整合
技术分析之SSH框架的整合技术分析之SSH框架开发的基本回顾1.1.1   SSH框架的整合方式一：零障碍整合(带有Hibernate配置文件)1.1.1.1创建web项目，引入相关jar包.【Struts2】D:struts2struts-2.3.24appsstruts2-blankWEB-INFlib*.jarStruts2需要...  查看详情  
                
ssh框架整合
  第一步添加spring 1.新建webproject2.导包springjar和hibernatejar3.添加spring能力addSpringcapabilities得到applicationContext.xml加入头文件<?xmlversion="1.0"encoding="UTF-8"?><beansxmlns="http://www.  查看详情  
                
ssh三大框架的整合
SSH三个框架的知识点一、Hibernate框架1.Hibernate的核心配置文件   1.1数据库信息、连接池配置   1.2Hibernate信息   1.3映射配置   1.4Hibernate核心配置文件如果单纯使用Hibernate框架，核心配置...  查看详情  
                
ssh三大框架整合步骤
Struts2:需要整合的第一个框架：1.创建一个动态web项目		2.导入struts2必须的jar放到lib目录下，再buildpath添加web工程中		3.配置struts2的核心配置文件：struts.xml		4.在web.xml文件中添加struts2的核心过滤器		5.添加测试页面		6.导入tomcatjar包...  查看详情  
                
ssh三大框架的整合
SSH三个框架的知识点（http://www.cnblogs.com/tuhooo/p/6491906.html）一、Hibernate框架1.Hibernate的核心配置文件   1.1数据库信息、连接池配置   1.2Hibernate信息   1.3映射配置   1.4Hi  查看详情  
                
ssh程序框架的整合
spring整合hibernate有两种方式1、注解方式2、xml方式实现　　Spring整合Hibernate有什么好处？　　1、由IOC容器来管理Hibernate的SessionFactory　　2、让Hibernate使用上Spring的声明式事务xml:那什么我们先创建一个账户，再把jar包导一下：<d...  查看详情  
                
ssh框架整合
一．创建数据库并设置编码。A) create databaseoadefault character set utf8。二．MyEclipse工程A) 在Myeclipse里创建web工程，并设置编码为utf8.B) 添加框架环境1.添加Junit4 library（Myeclipse自带）2.添加Struts2环境①  查看详情  
                
ssh整合
首先，SSH不是一个框架，而是多个框架（struts+spring+hibernate）的集成，是目前较流行的一种Web应用程序开源集成框架，用于构建灵活、易于扩展的多层Web应用程序。 集成SSH框架的系统从职责上分为四层:表示层、业务逻辑层、...  查看详情  
                
ssh框架整合
配置web.xml：<?xmlversion="1.0"encoding="UTF-8"?><web-appxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns="http://java.sun.com/xml/ns/javaee"xmlns:web="http://java.sun.com/xml/ns/javae  查看详情  
                
ssh_框架整合2—查询显示
4.完成功能. (1)com.atguigu.ssh.actions包下新建EmployeeAction.java　　　1packagecom.atguigu.ssh.actions;23importjava.util.Map;45importorg.apache.struts2.interceptor.RequestAware;67importcom.atguigu.ssh.servi  查看详情