SSH整合

最新推荐文章于 2021-10-26 10:24:22 发布
最新推荐文章于 2021-10-26 10:24:22 发布
阅读量444 收藏
点赞数 1
分类专栏： eclipse SSH
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZJ_DE/article/details/50999028
版权

下面为大家带来一个SSH整合的小列子。

目录结构：


一：加入spring框架

            1.添加spring jar文件
        a)spring 依赖的类库
            spring-aop-4.1.1.RELEASE.jar
            spring-aspects-4.1.1.RELEASE.jar
            spring-beans-4.1.1.RELEASE.jar
            spring-context-4.1.1.RELEASE.jar
            spring-context-support-4.1.1.RELEASE.jar
            spring-core-4.1.1.RELEASE.jar
            spring-expression-4.1.1.RELEASE.jar
            spring-jdbc-4.1.1.RELEASE.jar
            spring-orm-4.1.1.RELEASE.jar
            spring-test-4.1.1.RELEASE.jar
            spring-tx-4.1.1.RELEASE.jar
            spring-web-4.1.1.RELEASE.jar
        b)spring需要的支持库
            com.springsource.org.aopalliance-1.0.0.jar
            com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
            commons-logging-1.1.1.jar
    2.创建spring配置文件,添加自动扫描
        <context:component-scan base-package="com.neu"></context:component-scan>
        在beans节点中添加属性如下:
        default-autowire="byName"
         (用于自动按照对象名装载数据,为了能够自动装载sessionFactory)

二：加入hibernate框架

1.添加hibernatejar文件
        a)required
            antlr-2.7.7.jar
            dom4j-1.6.1.jar
            hibernate-commons-annotations-4.0.5.Final.jar
            hibernate-core-4.3.6.Final.jar
            hibernate-jpa-2.1-api-1.0.0.Final.jar
            jandex-1.1.0.Final.jar
            javassist-3.18.1-GA.jar
            jboss-logging-3.1.3.GA.jar
            jboss-logging-annotations-1.2.0.Beta1.jar
            jboss-transaction-api_1.2_spec-1.0.0.Final.jar    
        b)optional/c3p0
            c3p0-0.9.2.1.jar
            hibernate-c3p0-4.3.6.Final.jar
            mchange-commons-java-0.2.3.4.jar
        c)数据库驱动
            ojdbc14.jar
    2.不创建hibernate.cfg.xml(hibernate配置信息统一,在spring 配置文件中配置)
    3.创建实体类(采用注解的方式)

我这里实体类有2个：StuInfo和TeaInfo

StuInfo实体类：

package com.neu.entity;

import java.io.Serializable;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

@Entity
@Table(name="STU_INFO")
public class StuInfo implements Serializable {
	
	private static final long serialVersionUID = 1L;
	
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="STU_ID")
	private Integer stuId;
	@Column(name="STU_NAME")
	private String stuName;
	@Column(name="STU_PWD")
	private String stuPwd;
	@ManyToOne(targetEntity=TeaInfo.class,cascade=CascadeType.ALL,
			fetch=FetchType.EAGER)
	@JoinColumn(name="STU_TEA_ID") //STU_INFO表的外鍵
	private TeaInfo tea;
	
	public Integer getStuId() {
		return stuId;
	}
	public void setStuId(Integer stuId) {
		this.stuId = stuId;
	}
	public String getStuName() {
		return stuName;
	}
	public void setStuName(String stuName) {
		this.stuName = stuName;
	}
	public String getStuPwd() {
		return stuPwd;
	}
	public void setStuPwd(String stuPwd) {
		this.stuPwd = stuPwd;
	}
	public TeaInfo getTea() {
		return tea;
	}
	public void setTea(TeaInfo tea) {
		this.tea = tea;
	}
	

}

TeaInfo实体类： 

package com.neu.entity;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

@Entity
@Table(name="TEA_INFO")
public class TeaInfo implements Serializable {
	
	private static final long serialVersionUID = 1L;
	
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="TEA_ID")
	private Integer teaId;
	@Column(name="TEA_NAME")
	private String teaName;
	@Column(name="TEA_AGE")
	private Integer teaAge;
	@OneToMany(targetEntity=StuInfo.class,mappedBy="tea")
	private Set<StuInfo> stus = new HashSet<StuInfo>();
	
	public Integer getTeaId() {
		return teaId;
	}
	public void setTeaId(Integer teaId) {
		this.teaId = teaId;
	}
	public String getTeaName() {
		return teaName;
	}
	public void setTeaName(String teaName) {
		this.teaName = teaName;
	}
	public Integer getTeaAge() {
		return teaAge;
	}
	public void setTeaAge(Integer teaAge) {
		this.teaAge = teaAge;
	}
	public Set<StuInfo> getStus() {
		return stus;
	}
	public void setStus(Set<StuInfo> stus) {
		this.stus = stus;
	}
	

}

三：在spring配置文件中配置数据库相关信息

    1.在src下创建配置文件,db.properties,其中编写数据连接信息

jdbc.url= jdbc:mysql://127.0.0.1:3306/mysql
jdbc.driver=com.mysql.jdbc.Driver
jdbc.user=root
jdbc.password=123456
jdbc.maxPoolSize=5
jdbc.minPoolSize=2
jdbc.initialPoolSize=2

   2.在spring中配置

<!-- 读取src下数据配置文件 -->
    <context:property-placeholder location="classpath:db.properties"/>
   ①.dataSource
        <!-- 配置数据源 -->
    <bean name="dataSource"
        class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="user" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <property name="initialPoolSize" value="${jdbc.initPoolSize}"></property>
        <property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property>
        <property name="minPoolSize" value="${jdbc.minPoolSize}"></property>
    </bean>
    ②.sessionFactory
    <bean name="sessionFactory"
        class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <!-- 配置Hibernate需要的属性 -->
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop>
                <prop key="hibernate.hbm2ddl.auto">create</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
            </props>
        </property>
        <!-- 设置实体类所在的包 -->
        <property name="packagesToScan"
            value="com.neu.entity"></property>
        <!-- <property name="mappingLocations"
            value="classpath:com/neu/entity/*.hbm.xml"></property> -->
    </bean>

四：测试代码(创建业务逻辑和数据访问层)
    1.dao层
        a)创建dao的接口
        b)创建实现类,要继承HibernateDaoSupport
        @Repository("stuInfoDao") 表示持久化层
    2.biz层
        a)创建service接口
        b)创建实现类
            要创建dao接口的对象,提供setter方法
            @Service("stuInfoService")

StuInfoDao接口：

package com.neu.dao;

import com.neu.entity.StuInfo;

public interface StuInfoDao {
	
	public void save(StuInfo stu);

}

StuInfoDaoImpl实现类： 

package com.neu.dao.impl;

import org.springframework.orm.hibernate4.support.HibernateDaoSupport;
import org.springframework.stereotype.Repository;

import com.neu.dao.StuInfoDao;
import com.neu.entity.StuInfo;

@Repository("stuInfoDao")
public class StuInfoDaoImpl extends HibernateDaoSupport implements StuInfoDao {

	@Override
	public void save(StuInfo stu) {
		super.getHibernateTemplate().save(stu);
	}

}

StuInfoService接口： 

package com.neu.biz;

import com.neu.entity.StuInfo;

public interface StuInfoService {
	
	public boolean doSave(StuInfo stu);

}

StuInfoServiceImpl实现类： 

package com.neu.biz.impl;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.neu.biz.StuInfoService;
import com.neu.dao.StuInfoDao;
import com.neu.entity.StuInfo;

@Service("stuInfoService")
public class StuInfoServiceImpl implements StuInfoService {

	@Resource(name="stuInfoDao")
	private StuInfoDao stuInfoDao;
	
	public void setStuInfoDao(StuInfoDao stuInfoDao) {
		this.stuInfoDao = stuInfoDao;
	}

	@Override
	@Transactional
	public boolean doSave(StuInfo stu) {
		boolean flag = false;
		try {
			this.stuInfoDao.save(stu);
			flag = true;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		return flag;
	}

}

五：配置声明式的事务：

1.配置事务的管理者
    <!-- 配置事务的管理者 -->
    <bean name="txManager"
        class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"></property>
        <property name="dataSource" ref="dataSource"></property>    
    </bean>
    2.配置事务管理的类型(创建事务管理的通知)
    <!-- 配置事务通知 -->
    <tx:advice id="txAdvice"
        transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="do*"/>
            <tx:method name="*" propagation="SUPPORTS"
                read-only="true"/>
        </tx:attributes>
    </tx:advice>
    3.通过aop把我们的事务与类管理(织入)
    <!-- 织入 -->
    <aop:config>
        <aop:pointcut expression="execution(* com.neu.biz.impl.*.*(..))"
            id="txCut"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txCut"/>
    </aop:config>
    
    可以通过注解完成事务的配置,必须添加以下内容(2,3两步可以省略)
    <tx:annotation-driven transaction-manager="txManager"/>
    在需要使用事务的方法上添加 注解
    @Transactional

六：添加Struts2框架

1.添加jar
        a)struts核心包
        asm-3.3.jar
        asm-commons-3.3.jar
        asm-tree-3.3.jar
        commons-fileupload-1.2.2.jar
        commons-io-2.0.1.jar
        commons-lang3-3.1.jar
        freemarker-2.3.19.jar
        javassist-3.11.0.GA.jar
        ognl-3.0.5.jar
        struts2-core-2.3.4.jar
        xwork-core-2.3.4.jar
        b)struts-sprint-plugin.jar
            struts2-spring-plugin-2.3.4.jar
        c)支持注解的jar
            struts2-convention-plugin-2.3.4.jar
        d)支持junit的jar
            struts2-junit-plugin-2.3.4.jar
    2.创建struts配置文件,web.xml
    3.在web.xml中配置
        <filter>
            <filter-name>struts2</filter-name>
            <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
            <init-param>
                <param-name>actionPackages</param-name>
                <param-value>classpath:com.neu.action.impl</param-value>
            </init-param>
        </filter>
    
        <filter-mapping>
            <filter-name>struts2</filter-name>
            <url-pattern>/*</url-pattern>
        </filter-mapping>
    4.创建Action
    @Controller
    @Scope("prototype")  //必须
    @ParentPackage("struts-default")
    @Namespace("/")
    给每一个方法添加如下注解
    @Action(value="reg",results={
            @Result(name="success",location="/success.jsp")
    })

BaseAction:要继承ActionSupport，实现SessionAware接口

package com.neu.action;

import java.util.Map;

import org.apache.struts2.interceptor.SessionAware;

import com.opensymphony.xwork2.ActionSupport;

public class BaseAction extends ActionSupport implements SessionAware {

	private static final long serialVersionUID = 1L;
	
	protected Map<String, Object> session;

	@Override
	public void setSession(Map<String, Object> arg0) {
		this.session = arg0;
	}

}

StuInfoAction:其要继承上面的BaseAction 

package com.neu.action.impl;

import javax.annotation.Resource;

import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Namespace;
import org.apache.struts2.convention.annotation.ParentPackage;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;

import com.neu.action.BaseAction;
import com.neu.biz.StuInfoService;
import com.neu.entity.StuInfo;

@Controller
@ParentPackage("struts-default")
@Scope("prototype")
@Namespace("/")
@Results({
	@Result(name="error",location="/error.jsp")
			})
public class StuInfoAction extends BaseAction {
	
	private static final long serialVersionUID = 1L;
	
	private StuInfo stu;
	@Resource(name="stuInfoService")
	private StuInfoService stuInfoService;
	
	public StuInfo getStu() {
		return stu;
	}
	
	//通过setter方法注入，所以页面上要写成stu.stuName等。
	public void setStu(StuInfo stuInfo) {
		this.stu = stuInfo;
	}

	public void setStuInfoService(StuInfoService stuInfoService) {
		this.stuInfoService = stuInfoService;
	}

	@Action(value="reg",results={
			@Result(name="success",location="/success.jsp")
	})
	public String reg()throws Exception{
		boolean flag = stuInfoService.doSave(stu);
		if(flag){
			session.put("stu", stu);
			return SUCCESS;
		}
		return ERROR;
	}
}

测试1：TestConf 第一个@Test是测试spring框架和hibernate框架整合是否成功，配置文件是否正确。第二个@Test是测试能否添加数据。 

package conf;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.neu.biz.StuInfoService;
import com.neu.entity.StuInfo;
import com.neu.entity.TeaInfo;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:beans.xml"})
public class TestConfig extends AbstractJUnit4SpringContextTests {
	
	@Resource(name="stuInfoService")
	private StuInfoService stuInfoService;
	
	@Test
	public void testConfig(){
		System.out.println("YYYYYYYY");
		//这个是测配置的
	}
	
	
	//这个是添加方法
	@Test
	public void testDoSave(){
		TeaInfo tea = new TeaInfo();
		tea.setTeaName("teaaaaa1");
		tea.setTeaAge(35);
		
		StuInfo stu = new StuInfo();
		stu.setStuName("stu1");
		stu.setStuPwd("123445");
		stu.setTea(tea);
		stuInfoService.doSave(stu);
		System.out.println("----------");
	}

}

测试2：StuInfoActionTest 最终测试，注意测试1和测试2不一样。 

package com.neu.action.impl;

import org.apache.struts2.StrutsSpringJUnit4TestCase;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.opensymphony.xwork2.ActionProxy;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:beans.xml"})
public class StuInfoActionTest extends StrutsSpringJUnit4TestCase<StuInfoAction> {

	@Test(expected=java.lang.NullPointerException.class)
	public void testReg()throws Exception{
		request.setParameter("stu.stuName", "ddd");
		request.setParameter("stu.tea.teaName", "aaa");
		ActionProxy p =super.getActionProxy("/reg.action");
		Assert.assertNotNull(p);
		String result = p.execute();
	}
}

测试结果：

数据库中：

数据确实加进数据库了。

其余的方法都差不多。

beans.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:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.1.xsd"
		default-autowire="byName">
	
	<!-- 配置自动扫描  扫描com.neu包下的所有的类，为注解做准备-->
	<context:component-scan base-package="com.neu"></context:component-scan>
	
	<!-- 读取db.properties的内容 -->
	<context:property-placeholder location="classpath:db.properties"/>
	<!-- 配置dataSource -->
	<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="jdbcUrl" value="${jdbc.url}"></property>
		<property name="driverClass" value="${jdbc.driver}"></property>
		<property name="user" value="${jdbc.user}"></property>
		<property name="password" value="${jdbc.password}"></property>
		<property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property>
		<property name="minPoolSize" value="${jdbc.minPoolSize}"></property>
		<property name="initialPoolSize" value="${jdbc.initialPoolSize}"></property>
	</bean>
	
	<!-- 配置sessionFactory -->
	<bean name="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource"></property>
		<!-- 配置Hibernate需要的属性 -->
		<property name="hibernateProperties">
			<props>
			 	<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
			 	<prop key="hibernate.hbm2ddl.auto">create</prop>
			 	<prop key="hibernate.show_sql">true</prop>
			 	<prop key="hibernate.format_sql">true</prop>
			</props>
		</property>
		<!-- 设置实体类所在的包 -->
		<property name="packagesToScan" value="com.neu.entity"></property>
	</bean>
	
	<!-- 设置声明式的事务 -->
	<bean name="txManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory"></property>
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	<tx:annotation-driven transaction-manager="txManager"/>
</beans>


温水煮蛙
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java-项目-学生管理系统
乙醇麻痹的冰冷的博客
09-12 218
做一个学生管理系统，需求是这样的： 每个学生有如下信息：学号（String）、姓名、年龄、性别、地址 程序开始显示如下 1.新增 2.删除 3.修改 4.查询 5.打印 6.排序 7.【预留】 8.退出 用户输入功能编号，选择有误需要重输。 选1：每次新增一个人，所有数据做校验，学号唯一，年龄6~60，性别男女 不合法要提示为什么不合法，新增失败，然后返回主界面 2.先校验学生信息是否为空，若空报...
SSH整合Jar包
04-09
SSH整合在JavaWeb开发中是一项重要的技术组合，它包含了三个主要的开源框架：Spring、Struts和Hibernate。这些框架分别负责应用的业务逻辑管理、视图层控制和数据持久化。接下来，我们将深入探讨SSH整合的关键知识点...
ssh整合
没啥简介
07-04 5225
ssh整合 环境 struts2+spring4+hibernate4 jdk1.7 myeclipse 一、导包 1.struts2中的包 struts-2.3.30\apps\struts2-blank\WEB-INF的lib中的全部； struts-2.3.30\lib中的： aopalliance-1.0.jar struts2-spring-plu
ssh整合案例
杨校的博客
04-08 796
Struts2的导入jar包如下： Spring4.2.4的导入jar包如下： HIbernate 5.0.7 的导入jar包如下： MySQL数据库 驱动jar包：
ssh 整合ajax,基于整合ssh ajax案例.doc
weixin_42494628的博客
08-06 215
SSH+Ajax整合????数据库建好我们来搭建SSH框架吧！ ????1.首先创建web工程 ????2.在工程中添加SSH支持 ????SSH的添加顺序和他们的(SSH=Struts+Spring+Hibernate)缩写名字顺序是一致的，不知道起名字的时候是不是按照他们的引入顺序起的。注意：SSH支持引入的时候必须是这个顺序，否则里面会出现很多错误。解决起来很麻烦。尤其是spring的部分。...
SSH的整合
m0_58525944的博客
10-26 1088
ssh 为 struts+spring+hibernate的一个集成框架，是一种Web应用程序开源框架。 一、SSH整合的思路步骤 web+spring+struts+hibernate+杂鱼（杂鱼：比如缓存echache框架、日志框架、tomcat等等） 思路步骤： 1、导入所需要的pom依赖 2、几大框架的配置文件（web.xml/struts.xml、hibernate的配置、spring的配置） 3、spring与hibernate整合 4、spring跟struts整合 5、.
SSH 整合Swagger2
kelly921011的博客
03-19 950
之前用的是springboot整合swagger2,新公司这边的系统是之前开发的，用的是SSH框架，这里记录一下 整合过程，以及遇到的坑。 1.导入依赖 <!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger2 --> <dependency> <groupId>io.springfox</groupId>
SSH整合实例
Radom&7
08-25 615
这是很久以前学习SSH的一个整合例子，现在整理一下，以便于以后学习。关于SSH框架的整合步骤可以查看我的另外一篇文章《SSH框架搭建》：http://blog.csdn.net/qq_26641781/article/details/76612765整个项目目录： conf文件夹为SSH框架的配置信息db.properties是对数据库信息的配置：user=root password= drive
java ssh 整合_Java - 框架之 SSH 整合
weixin_35943736的博客
02-21 102
十四. ssh 整合1 - 包1. Struts jar 包- Struts-2.xx\apps\stutrs2-blank\WEB-INF\lib2. Hibernate jar 包- hibernate-release-5.0.7.Final\lib\required- mysql 驱动包- 日志记录3. Spring jar 包十五. ssh 整合 - 配置文件1. Struts 配置文件-...
SSH整合导包
hou973561160的博客
09-19 426
一、ssh的图形化记忆运作流程 二、Struts2、hibernate、spring需要引用的jar包 Struts2： 　　基本开发：struts-2.3.32\apps\struts2-blank.war解压后的全部jar, 　　注解开发：struts2-spring-plugin-2.3.32.jar 　　spring整合：struts2-spr
SSH整合项目
07-01
SSH整合项目指的是在Java开发中，使用Spring、Struts2和Hibernate这三个开源框架进行集成的Web应用程序项目。这个项目描述中提到的是一个已经搭建完成的框架，但是去掉了Hibernate的配置文件，可能意味着项目选择了...
SSH整合jar包
06-04
SSH整合jar包是一个集合了所有在Java开发中用于Spring、Struts和Hibernate（SSH）集成应用所需的库文件的压缩包。SSH是Java企业级开发中非常流行的一种框架组合，它能够帮助开发者快速构建高效、可维护的企业级Web...
ssh整合所需要的jar包
03-21
SSH整合，全称为Struts2、Spring和Hibernate的整合，是Java Web开发中常见的技术栈。这三种框架分别负责表现层、业务层和持久层的管理，通过合理的整合，可以构建出高效、灵活且易于维护的Web应用。下面将详细介绍...
SSH整合源码分析
01-16
Spring整合Struts2 Spring整合Hibernate Struts2是一个web层框架 用于和数据库进行交互 Spring框架用来处理业务层 包括IOC容器 和Aop功能 Hibernate是一个持久化层框架 用于操作数据库
SSH整合视频
03-16
SSH整合视频，无法免费上传，共同学习，主页有更多的学习视频
ssh整合Demo
04-27
SSH整合指的是Spring、SpringMVC和Hibernate这三大Java开源框架的集成应用。SSH是Java Web开发中的经典组合，它们各自负责不同的职责：Spring作为基础框架，提供依赖注入和AOP（面向切面编程）；SpringMVC处理HTTP...
ssh整合 jar包
03-09
SSH整合是指在Java Web开发中，将Spring、Struts2和Hibernate这三大开源框架进行集成，以实现高效、灵活和可扩展的业务应用。这些框架分别负责不同的职责：Spring作为核心容器，管理对象的依赖注入；Struts2是MVC...
MyEclipse中SSH整合详细步骤
"SSH整合教程基于Myeclipse6.5" SSH（Struts+Spring+Hibernate）是一个常见的Java Web开发框架组合，它整合了三个强大的开源框架，用于构建高效、可维护的Web应用。SSH整合使得开发人员可以利用Struts的MVC设计模式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值