`
周一Monday
  • 浏览: 346769 次
  • 来自: 北京
社区版块
存档分类
最新评论

Spring之Spring2.5集成Hibernate3.6

阅读更多

 搭建开发环境:

Spring2.5需要的JAR文件:

spring-framework-2.5.6\dist\spring.jar

spring-framework-2.5.6\lib\jakarta-commons\commons-logging.jar

spring-framework-2.5.6\lib\aspectj\aspectjweaver.jar

 

Hibernate3.6需要的JAR文件

hibernate-distribution-3.6.0.Final\hibernate3.jar

hibernate-distribution-3.6.0.Final\lib\required\*

hibernate-distribution-3.6.0.Final\lib\jpa\hibernate-jpa-2.0-api-1.0.0.Final.jar

 

数据库驱动包

mysql-connector-java-5.1.7-bin.jar

 

方式一:

 

1.实体类与映射文件

package org.monday.hibernate1;

import java.util.Date;

public class Emp {

	private int id; // 编号
	private String name; // 姓名
	private int age; // 年龄
	private double salary; // 薪水
	private Date birthday; // 生日

	public Emp() {
	}

	public Emp(int id, String name, int age, double salary, Date birthday) {
		this.id = id;
		this.name = name;
		this.age = age;
		this.salary = salary;
		this.birthday = birthday;
	}

	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 int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}

	@Override
	public String toString() {
		return "Emp [id=" + id + ", name=" + name + ", age=" + age
				+ ", salary=" + salary + ", birthday=" + birthday + "]";
	}

}

 

 

Emp.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="org.monday.hibernate1">
	<class name="Emp" table="EMP">
		<id name="id">
			<generator class="assigned" />
		</id>
		<property name="name" />
		<property name="age" />
		<property name="salary" />
		<property name="birthday" />
	</class>
</hibernate-mapping>

 

2.开发Dao

package org.monday.hibernate1;

import java.util.List;

public interface EmpDao {

	/** 插入 */
	public void insert(Emp emp);

	/** 更新*/
	public void update(Emp emp);

	/** 删除*/
	public void delete(Emp emp);
	
	/** 根据id删除 */
	public void delete(int id);

	/** 根据id查询雇员的详细信息 */
	public Emp findById(int id);

	/** 查询全部雇员信息 */
	public List<Emp> findAll();

	/** 根据雇员姓名查询其薪水 */
	public double findSalary(String name);

	/** 查询部总记录数 */
	public int totalCount();

	/** 批量插入 */
	public void insertBatch(List<Emp> emps);

	/** 批量删除 */
	public void deleteBatch(int... ids);
}

 

3.开发Dao实现类

package org.monday.hibernate1;

import java.util.List;

import javax.annotation.Resource;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

@Repository("empDao")
public class EmpDaoImpl implements EmpDao {

	@Resource
	private SessionFactory sessionFactory;

	/*
	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}
	*/
	
	/** 取得当前可用的Session */
	private Session getSession(){
		return sessionFactory.getCurrentSession();
	}
	
	/** 插入 */
	@Transactional
	public void insert(Emp emp) {
		getSession().save(emp);
	}

	/** 更新 */
	@Transactional
	public void update(Emp emp) {
		getSession().update(emp);
	}

	/** 删除 */
	@Transactional
	public void delete(Emp emp) {
		getSession().delete(emp);
	}

	/** 根据id删除 */
	@Transactional
	public void delete(int id) {
		/** 方法一 */
		/*
		Emp emp=(Emp) getSession().get(Emp.class,id);
		getSession().delete(emp);
		*/
		/** 方法二*/
		getSession().createQuery("delete from Emp where id=?").setParameter(0, id).executeUpdate();
	}

	/** 根据id查询雇员的详细信息 */
	@Transactional(readOnly=true)
	public Emp findById(int id) {
		return (Emp) getSession().get(Emp.class,id);
	}

	/** 查询全部雇员信息 */
	@Transactional(readOnly=true)
	public List<Emp> findAll() {
		return getSession().createQuery("from Emp").list();
	}

	/** 根据雇员姓名查询其薪水 */
	@Transactional(readOnly=true)
	public double findSalary(String name) {
		return (Double) getSession().createQuery("select e.salary from Emp e where e.name=?").setParameter(0, name).uniqueResult();
	}

	/** 查询部总记录数 */
	@Transactional(readOnly=true)
	public int totalCount() {
		return Integer.parseInt( getSession().createQuery("select count(id) from Emp").uniqueResult()+"");
		
		//return (Integer) getSession().createQuery("select count(id) from Emp").uniqueResult();
		//会抛出java.lang.ClassCastException: java.lang.Long cannot be cast to java.lang.Integer
	}

	/** 批量插入 */
	@Transactional
	public void insertBatch(List<Emp> emps) {
		for (int i = 0; emps != null && i < emps.size(); i++) {
			getSession().save(emps.get(i));
			if(i%20==0){
				getSession().flush();
				getSession().clear();
			}
		}	
	}

	/** 批量删除 */
	@Transactional
	public void deleteBatch(int... ids) {
		/** 方法一 */
		for (int i = 0; ids != null && i < ids.length; i++) {
			Emp emp=(Emp) getSession().get(Emp.class,ids[i]);
			getSession().delete(emp);
			if(i%20==0){
				getSession().flush();
				getSession().clear();
			}
		}
		
		/** 方法二*/
		/*
		StringBuffer hql=new StringBuffer();
		hql.append("delete from Emp where id in");
		hql.append("(");
		for (int i = 0; ids != null && i < ids.length; i++) {
			if(i==ids.length-1){
				hql.append("?");
			}else{
				hql.append("?,");
			}
		}
		hql.append(")");
		Query query=getSession().createQuery(hql.toString());
		for (int j=0; ids != null && j < ids.length; j++) {
			query.setParameter(j, ids[j]);
		}
		query.executeUpdate();
		*/
		
		/** 方法三*/
		/*
		StringBuffer hql=new StringBuffer();
		hql.append("delete from Emp where id in");
		hql.append("(");
		for (int i = 0; ids != null && i < ids.length; i++) {
			if(i==ids.length-1){
				hql.append(ids[i]);
			}else{
				hql.append(ids[i]+",");
			}
		}
		hql.append(")");
		getSession().createQuery(hql.toString()).executeUpdate();
		*/
	}
}

 

这里的操作需要通过Spring容器来注入SessionFactory,从而获取Session进行一系列Hibernate操作,而不依赖于Spring的API,只不过SessionFactory要依赖Spring容器来注入。而事务使用注解配置。

 

4.Spring的配置文件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:tx="http://www.springframework.org/schema/tx"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="
	http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/tx
	http://www.springframework.org/schema/tx/spring-tx.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd">

	<!-- 配置注解扫描器 -->
	<context:annotation-config/>
	<!-- 指定要扫描的包 -->
	<context:component-scan base-package="org.monday.hibernate1"/>
	<!-- 将Hibernate的异常转变成Spring的DataAccessException异常 -->
	<bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor"/>

	<!-- 配置sessionFactory -->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="configLocation" value="classpath:hibernate.cfg.xml"/>
		<property name="mappingLocations" value="org/monday/hibernate1/*.hbm.xml"/>
	</bean>
	
	<!-- 配置事务 -->
	<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory"/>
	</bean>
	<tx:annotation-driven transaction-manager="transactionManager"/>

</beans>

 5.测试

package org.monday.hibernate1;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

	private ApplicationContext ctx = new ClassPathXmlApplicationContext("org/monday/hibernate1/beans1.xml");
	private EmpDao empDao = (EmpDao) ctx.getBean("empDao");

	@Test
	public void testInsert() {
		Emp emp = new Emp(101, "zy_test1", 21, 3000, randomDate("1980-01-01","1999-12-31"));
		empDao.insert(emp);
	}

	@Test
	public void testUpdate() {
		Emp emp = new Emp(1, "zy_test", 19, 1000, randomDate("1980-01-01","1999-12-31"));
		empDao.update(emp);
	}

	@Test
	public void testDeleteEmp() {
		Emp emp = new Emp();
		emp.setId(100);
		empDao.delete(emp);
	}

	@Test
	public void testDeleteInt() {
		empDao.delete(99);
	}

	@Test
	public void testFindById() {
		Emp emp = empDao.findById(1);
		System.out.println(emp);
	}

	@Test
	public void testFindAll() {
		List<Emp> list = empDao.findAll();
		for (Emp e : list) {
			System.out.println(e);
		}
	}

	@Test
	public void testFindSalary() {
		double salary = empDao.findSalary("zy_test");
		System.out.println(salary);
	}

	@Test
	public void testTotalCount() {
		int count = empDao.totalCount();
		System.out.println("共" + count + "条记录");
	}

	@Test
	public void testInsertBatch() {
		List<Emp> emps = new ArrayList<Emp>();
		for (int i = 1; i <= 100; i++) {
			int age = (int) (Math.random() * 100) + 1;
			double salary = (int) (Math.random() * 3000) + 1;
			Emp emp = new Emp(i, "zy_test" + i, age, salary, randomDate("1980-01-01", "1999-12-31"));
			emps.add(emp);
		}
		empDao.insertBatch(emps);
	}

	@Test
	public void testDeleteBatch() {
		int[] ids = {96,95};
		empDao.deleteBatch(ids);
	}

	/** 在给定的日期范围内生成随即日期 */
	private static Date randomDate(String beginDate, String endDate) {
		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
		try {
			long start = format.parse(beginDate).getTime();
			long end = format.parse(endDate).getTime();
			long time = Math.abs(start + (long) (Math.random() * (end - start)));
			return new Date(time);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
}

 

方式二:

直接看Dao实现类吧

package org.monday.hibernate2;

import java.util.List;

import org.springframework.orm.hibernate3.HibernateTemplate;

public class EmpDaoImpl implements EmpDao {

	private HibernateTemplate hibernateTemplate;

	public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
		this.hibernateTemplate = hibernateTemplate;
	}

	/** 插入 */
	public void insert(Emp emp) {
		hibernateTemplate.save(emp);
	}

	/** 更新 */
	public void update(Emp emp) {
		hibernateTemplate.update(emp);
	}

	/** 删除 */
	public void delete(Emp emp) {
		hibernateTemplate.delete(emp);
	}

	/** 根据id删除 */
	public void delete(int id) {
		Emp emp = (Emp) hibernateTemplate.get(Emp.class, id);
		hibernateTemplate.delete(emp);
	}

	/** 根据id查询雇员的详细信息 */
	public Emp findById(int id) {
		return (Emp) hibernateTemplate.get(Emp.class, id);
	}

	/** 查询全部雇员信息 */
	public List<Emp> findAll() {
		return hibernateTemplate.find("from Emp");
	}

	/** 根据雇员姓名查询其薪水 */
	public double findSalary(String name) {
		List<Double> list = hibernateTemplate.find("select e.salary from Emp e where e.name=?", name);
		return list.size() > 0 ? list.get(0) : 0;
	}

	/** 查询部总记录数 */
	public int totalCount() {
		List<Long> list = hibernateTemplate.find("select count(*) from Emp");
		return list.size() > 0 ? Integer.parseInt(list.get(0)+"") : 0;
	}

	/** 批量插入 */
	public void insertBatch(List<Emp> emps) {
		for (int i = 0; emps != null && i < emps.size(); i++) {
			hibernateTemplate.save(emps.get(i));
			if (i % 20 == 0) {
				hibernateTemplate.flush();
				hibernateTemplate.clear();
			}
		}
	}

	/** 批量删除 */
	public void deleteBatch(int... ids) {
		/** 方法一 */
		for (int i = 0; ids != null && i < ids.length; i++) {
			Emp emp = (Emp) hibernateTemplate.get(Emp.class, ids[i]);
			hibernateTemplate.delete(emp);
			if (i % 20 == 0) {
				hibernateTemplate.flush();
				hibernateTemplate.clear();
			}
		}
	}
}

 这里注入的不在是SessionFactory而是HibernateTemplate,这是Spring为辅助Hibernate开发提供的模版类。

而事务不用注解了(之前写过了),用XML配置注解

此时Spring的配置文件编写如下:

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

	
	<!-- 配置数据库连接信息 -->
	<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
		<property name="url" value="jdbc:mysql://localhost:3306/spring"/>
		<property name="username" value="root"/>
		<property name="password" value="root"/>
	</bean>

	<!-- 配置sessionFactory -->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource"/>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">org.hibernate.dialect.MySQLInnoDBDialect</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.hbm2ddl.auto">update</prop>
			</props>
		</property>
		<!-- 
			个人觉得这么配置方便,不用将所有的映射文件都列出来,因为有时会忘记配置映射文件
		 -->
		 <property name="mappingLocations" value="org/monday/hibernate2/*.hbm.xml"/>
		<!-- 
			或者
			<property name="mappingResources">
			<list>
				<value>org/monday/hibernate2/Emp.hbm.xml</value>
			</list>
		</property>
		 -->
		
	</bean>
	
	<!-- 配置DAO -->
	<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
		<property name="sessionFactory" ref="sessionFactory"/>
	</bean>
	<bean id="empDao" class="org.monday.hibernate2.EmpDaoImpl">
		<property name="hibernateTemplate" ref="hibernateTemplate"/>
	</bean>
	
	<!-- 配置事务 -->
	<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory"/>
	</bean>
	<tx:advice id="tx" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="*"/>
			<tx:method name="find*" read-only="true"/>
		</tx:attributes>
	</tx:advice>
	<aop:config>
		<aop:pointcut id="perform" expression="execution( * org.monday.hibernate2.*.*(..))" />
		<aop:advisor advice-ref="tx" pointcut-ref="perform"/>
	</aop:config>

</beans>

 

方式三:

直接看Dao实现类吧。

package org.monday.hibernate3;

import java.util.List;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public class EmpDaoImpl extends HibernateDaoSupport implements EmpDao {

	/** 插入 */
	public void insert(Emp emp) {
		getHibernateTemplate().save(emp);
	}

	/** 更新 */
	public void update(Emp emp) {
		getHibernateTemplate().update(emp);
	}

	/** 删除 */
	public void delete(Emp emp) {
		getHibernateTemplate().delete(emp);
	}

	/** 根据id删除 */
	public void delete(int id) {
		Emp emp = (Emp) getHibernateTemplate().get(Emp.class, id);
		getHibernateTemplate().delete(emp);
	}

	/** 根据id查询雇员的详细信息 */
	public Emp findById(int id) {
		return (Emp) getHibernateTemplate().get(Emp.class, id);
	}

	/** 查询全部雇员信息 */
	public List<Emp> findAll() {
		return getHibernateTemplate().find("from Emp");
	}

	/** 根据雇员姓名查询其薪水 */
	public double findSalary(String name) {
		List<Double> list = getHibernateTemplate().find("select e.salary from Emp e where e.name=?", name);
		return list.size() > 0 ? list.get(0) : 0;
	}

	/** 查询部总记录数 */
	public int totalCount() {
		List<Long> list = getHibernateTemplate().find("select count(*) from Emp");
		return list.size() > 0 ? Integer.parseInt(list.get(0)+"") : 0;
	}

	/** 批量插入 */
	public void insertBatch(List<Emp> emps) {
		for (int i = 0; emps != null && i < emps.size(); i++) {
			getHibernateTemplate().save(emps.get(i));
			if (i % 20 == 0) {
				getHibernateTemplate().flush();
				getHibernateTemplate().clear();
			}
		}
	}

	/** 批量删除 */
	public void deleteBatch(int... ids) {
		/** 方法一 */
		for (int i = 0; ids != null && i < ids.length; i++) {
			Emp emp = (Emp) getHibernateTemplate().get(Emp.class, ids[i]);
			getHibernateTemplate().delete(emp);
			if (i % 20 == 0) {
				getHibernateTemplate().flush();
				getHibernateTemplate().clear();
			}
		}
	}
}

 

继承了HibernateDaoSupport,这也是Spring提供的一个辅助类

而Spring的配置文件变动如下:

 

<!-- 配置DAO -->
	<!-- 
		<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
			<property name="sessionFactory" ref="sessionFactory"/>
		</bean>
		<bean id="empDao" class="org.monday.hibernate2.EmpDaoImpl">
			<property name="hibernateTemplate" ref="hibernateTemplate"/>
		</bean>
	-->
	<bean id="empDao" class="org.monday.hibernate3.EmpDaoImpl">
			<property name="sessionFactory" ref="sessionFactory"/>
	</bean>

 

三种方式,我个人喜欢第一种。

因为不用依赖Spring的API,不过反过来一想,既然开发都依赖Spring框架了,那这点依赖又算什么。

哈,确实不算什么,只是觉得使用Hibernate的原生API比Spring的好用。(一家之言,欢迎拍转,呵呵~)

而关于配置文件,我认为还是不要写在一起的好,Hibernate的配置就用hibernate.cfg.xml,而Spring就用beans.xml将组件组装起来。类似于Struts2的“分离关注”思想吧。(谁该做的,就让谁做,不要大杂烩。)

最好JDBC的数据库连接配置也单独写在一个配置文件中。

关于实体类的映射文件建议还是配置在beans.xml中吧。不用每次开发完实体类都要在hibernate.cfg.xml中配置,有时太忙了就忘记了。(自己犯过这样的错误...

在Sping中写成类似

<property name="mappingLocations" value="org/monday/hibernate3/*.hbm.xml"/>

通配符的形式,就不怕忘记啦。

 

分享到:
评论
1 楼 gary052402 2015-01-16  
不错,赞一个。

相关推荐

    Hibernate3.6

    在实际开发中,开发者可以结合 Spring 框架,利用 Spring 的 Transaction Management 和 DAO 支持,进一步简化 Hibernate 的使用。 总结起来,Hibernate 3.6 作为一款成熟的 ORM 框架,通过对象化的数据库操作方式...

    Spring2.5+Struts2.3+hibernate3.6 整合实现登陆的实例

    这个实例是基于Spring 2.5、Struts2.3和Hibernate 3.6进行集成,用于实现一个基本的用户登录功能,下面将详细介绍这三个框架的核心功能以及它们如何协同工作。 **Spring 2.5** 是一个全面的Java应用框架,提供依赖...

    EXt2.1+sturts2.0+spring2.5+hibernate

    标题中的"EXt2.1+sturts2.0+spring2.5+hibernate"是一个典型的Java Web开发技术栈,它包含了四个关键组件:EXT JS 2.1、Struts 2.0、Spring 2.5和Hibernate。这些技术在2000年代末至2010年代初是非常流行的,它们...

    Java SSH框架整合搭建Web系统(Struts1.2+Spring2.5+Hibernate3.2)

    ### Java SSH框架整合搭建Web系统(Struts1.2+Spring2.5+Hibernate3.2) #### 一、准备工作 在开始构建基于Struts1.2+Spring2.5+Hibernate3.2的Web应用之前,需要进行一系列的基础设置工作。 **1.1 创建工程** ...

    jbpm4.4+spring2.5.6+hibernate 3.6+struts2.2.1 集成 保证运行成功

    这个集成项目是基于特定版本的这些技术,包括jbpm4.4(业务流程管理),spring2.5.6(依赖注入和事务管理),hibernate 3.6(对象关系映射),以及struts2.2.1(MVC框架)。下面将详细介绍这些组件以及它们如何协同...

    struts2.2+spring3+hibernate3.6

    Struts2、Spring3和Hibernate3.6是Java开发中非常经典的三大框架组合,它们各自在Web应用开发中承担着不同的职责,共同构建了一个高效、灵活的企业级应用开发环境。 Struts2作为MVC(Model-View-Controller)架构的...

    spring3.0.5与JPA2.0(hibernate3.6)的集成详细说明

    本篇将详细讲解如何将Spring 3.0.5与JPA 2.0(基于Hibernate 3.6)进行集成,以构建高效、灵活的应用程序。 首先,让我们了解Spring 3.0.5的核心特性。Spring 3.0引入了若干改进和新特性,包括对JSR-303(Bean ...

    Spring3.2+Struct2.16+hibernate3.6整合

    这个"Spring3.2+Structs2.16+Hibernate3.6整合"的主题意味着我们将探讨如何将这三个组件集成到一个项目中,以实现模型-视图-控制器(MVC)架构的完美融合。 首先,Struts2是Apache软件基金会的一个开源项目,它基于...

    ssh(struts2.2.1+_hibernate3.6+spring3.0.5)整合配置

    下面将详细介绍如何整合Struts2.2.1、Hibernate3.6和Spring3.0.5。 首先,确保准备好所有必要的库文件,包括: 1. Struts2的struts2-2.2.1-all.zip 2. Hibernate的hibernate-distribution-3.6.0.Final-dist.zip 3. ...

    Spring3.2和Hibernate3.6整合源码和jar包

    整合Spring3.2和Hibernate3.6的关键在于如何将Hibernate的SessionFactory和TransactionManager集成到Spring的IoC容器中。这通常通过以下步骤实现: 1. 引入相关库:在项目中添加Spring和Hibernate的jar包,包括...

    整合Struts2.2与Hibernate3.6需要的Spring3.1相关JAR文件

    在整合Struts2.2与Hibernate3.6时,Spring3.1作为粘合剂,帮助管理这两个框架之间的交互。以下是一些关键的知识点: 1. **Struts2**:Struts2是一个基于MVC设计模式的Web框架,它提供了强大的动作调度、结果映射和...

    spring4:Spring4+Hibernate3.6配置

    整合Spring4和Hibernate3.6能够提供一个强大、灵活且易于维护的Java企业级应用开发基础,通过它们的协同工作,开发者可以更高效地构建数据驱动的应用程序。在实际项目中,你需要根据具体需求来调整配置,优化性能,...

    stuts2 spring hibernate 集成

    完整的SSH集成,STRUTS2.0+SPRING 2.5+ HIBERNATE 3.6完美集成

    spring3,struts2,hibernate3.6

    标题中的"spring3,struts2,hibernate3.6"指的是三个著名的Java Web开发框架:Spring、Struts2和Hibernate。这些框架在Java企业级应用程序中被广泛使用,它们各自处理不同的职责,以实现高效的MVC(Model-View-...

    spring3.0API.chm、hibernate3.6API、struts2API

    标题中的"spring3.0API.chm、hibernate3.6API、struts2API"涉及的是三个关键的Java企业级开发框架:Spring、Hibernate和Struts2,它们是SSH(Spring、Struts、Hibernate)框架组合的一部分,广泛应用于构建复杂的Web...

    Struts2+Spring3.02+Spring Security3+Hibernate3.6

    Struts2、Spring3.02、Spring Security3和Hibernate3.6是Java Web开发中的四大框架,它们各自承担着不同的职责,共同构建了一个高效、稳定的后端架构。以下将详细解析这四个组件及其整合应用。 **Struts2** 是一个...

    最新struts2.2_hibernate3.6_spring3.0整合

    Struts2.2、Hibernate3.6和Spring3.0是Java Web开发中非常重要的三个框架,它们分别在MVC模式、持久层管理和依赖注入方面发挥着关键作用。本整合教程将详细介绍如何将这三个框架有效地集成在一起,以构建高效、灵活...

    Struts2.3.16.1+Hibernate3.6.10+Spring3.2.8整合

    Struts2.3.16.1+Hibernate3.6.10+Spring3.2.8整合 能够运行,没有任何问题 另外附带applicationContext.xml、struts.xml、hibernate.cfg.xml

    struts2.2.3+ hibernate3.6+spring3.0.5

    在这个项目中,使用的是Struts2.2.3、Hibernate3.6和Spring3.0.5的版本,这是一套相对稳定的配置,已经在实际项目中得到了验证,不存在兼容性问题,对于初学者来说是学习和实践的良好平台。 **Struts2** 是一个基于...

Global site tag (gtag.js) - Google Analytics