Spring与Hibernate整合

最新推荐文章于 2021-07-26 20:15:52 发布
最新推荐文章于 2021-07-26 20:15:52 发布
阅读量308 收藏
点赞数
分类专栏： 框架 Java Web
原文链接：https://dpb-bobokaoya-sm.blog.csdn.net/article/details/90312221
版权
Java 同时被 3 个专栏收录
19 篇文章 0 订阅
订阅专栏
Web
14 篇文章 0 订阅
订阅专栏
框架
7 篇文章 0 订阅
订阅专栏

1、创建一个maven项目PomDependency，以pom方式打包。 在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/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.guo</groupId>
	<artifactId>PomDependency</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>pom</packaging>
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>

		<dependency><!--servelt -->
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>4.0.0-b07</version>
			<scope>provided</scope>
		</dependency>

		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>3.0.1</version>
		</dependency>

		<dependency>
			<groupId>mysql</groupId><!-- MySql -->
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.39</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>4.3.21.RELEASE</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>4.3.21.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjrt</artifactId>
			<version>1.9.2</version>
		</dependency>

		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>1.9.2</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>4.3.7.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>4.3.7.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.3.7.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-jpa</artifactId>
			<version>1.8.0.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>com.fasterxml.jackson.datatype</groupId>
			<artifactId>jackson-datatype-hibernate5</artifactId>
			<version>2.9.9</version>
		</dependency>
		<!-- 2.Spring dao依赖 -->
		<!-- spring-jdbc包括了一些如jdbcTemplate的工具类 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>4.3.7.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>4.3.7.RELEASE</version>
		</dependency>
		<!-- 3.Spring web依赖 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>4.3.7.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>4.3.7.RELEASE</version>
		</dependency>
		<!-- 4.Spring test依赖：方便做单元测试和集成测试 <dependency> <groupId>org.springframework</groupId> 
			<artifactId>spring-test</artifactId> <version>4.3.7.RELEASE</version> </dependency> -->


		<!-- Log4J -->
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.17</version>
		</dependency>

		<!--mybatis -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.4.1</version>
		</dependency>

		<dependency>
			<groupId>com.mchange</groupId>
			<artifactId>c3p0</artifactId>
			<version>0.9.2.1</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>1.3.0</version>
		</dependency>


		<!-- JSTL -->
		<dependency>
			<groupId>jstl</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>2.9.1</version>
		</dependency>

		<dependency>
			<groupId>com.github.pagehelper</groupId>
			<artifactId>pagehelper</artifactId>
			<version>5.0.0</version>
		</dependency>

		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jsp-api</artifactId>
			<version>2.0</version>
			<scope>provided</scope>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>5.0.8.RELEASE</version>
		</dependency>

		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>2.5</version>
			<scope>provided</scope>
		</dependency>

		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<version>5.0.7.Final</version>
		</dependency>

		<dependency>
			<groupId>org.javassist</groupId>
			<artifactId>javassist</artifactId>
			<version>3.20.0-GA</version>
		</dependency>

		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-nop</artifactId>
			<version>1.6.4</version>
		</dependency>

	</dependencies>
</project>

2、再新建一个Maven项目，以jar形式打包，继承PomDependency
在src/mian/resources下创建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: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">


	<context:property-placeholder location="classpath:db.properties" />

	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${mysql.driver}" />
		<property name="jdbcUrl" value="${mysql.url}" />
		<property name="user" value="${mysql.username}" />
		<property name="password" value="${mysql.password}" />
	</bean>

	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.show_sql">true</prop><!-- 显示当前执行的sql语句 -->
				<prop key="hibernate.hbm2ddl.auto">update</prop><!-- 开启正向工程 -->
			</props>
		</property>
		<property name="packagesToScan"><!-- 扫描实体所在的包 -->
			<list>
				<value>com.guo.bean</value>
			</list>
		</property>
	</bean>

	<!-- 配置HiberanteTemplate对象 -->
	<bean id="template" class="org.springframework.orm.hibernate5.HibernateTemplate">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>
	<!-- 配置Hibernate的事务管理器 -->
	<bean id="transactionManager"
		class="org.springframework.orm.hibernate5.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>
	<tx:annotation-driven transaction-manager="transactionManager" />


	<!-- 注解装配 -->
	<context:component-scan
		base-package="com.guo.dao.impl,com.guo.service.impl,com.guo.action" />

</beans>

3、创建实体类、dao、service、action等接口与实现类

package com.guo.bean;

import java.io.Serializable;

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

@Entity
@Table(name="person")  //表名
public class Person implements Serializable {

	private static final long serialVersionUID = 1L;

	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)//主键自增长
    private Integer id;
	
	@Column(name="name")
    private String name;
	
	@Column(name="gender")
    private Character gender;
	
	@Column(name="age")
    private Integer age;
	
	@Column(name="province")
    private String province;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Character getGender() {
        return gender;
    }

    public void setGender(Character gender) {
        this.gender = gender;
    }

    public Integer getAge() {
        return age;
    }

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

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    @Override
    public String toString() {
        return "Person [id=" + id + ", name=" + name + ", gender=" + gender + ", age=" + age + ", province=" + province
                + "]";
    }

    public Person(Integer id, String name, Character gender, Integer age, String province) {
        this.id = id;
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.province = province;
    }
    

    public Person(String name, Character gender, Integer age, String province) {
		this.name = name;
		this.gender = gender;
		this.age = age;
		this.province = province;
	}

	public Person() {
    }

	public Person(int id) {
		this.id = id;
	}
}

package com.guo.dao;

import java.util.List;

import com.guo.bean.Person;

public interface PersonDao {
     void add(Person p);
    Person getByID(Integer id);
    void update(Person p);
    void delete(Person p);
    List<Person> getAll();
    List<Person> getByName(String name);
}

package com.guo.dao.impl;

import java.util.List;

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

import com.guo.bean.Person;
import com.guo.dao.PersonDao;


@Repository
public class PersonDaoImpl implements PersonDao {
	
	@Autowired
	private HibernateTemplate template;
	
	public void setHibernateTemplate(HibernateTemplate template) {
		this.template = template;
	}
	
    @Override
    public void add(Person p) {
        template.save(p);
    }

	@Override
	public Person getByID(Integer id) {
		return template.get(Person.class, id);
	}

	@Override
	public void update(Person p) {
		template.update(p);
	}

	@Override
	public void delete(Person p) {
		template.delete(p);
	}

	@Override
	public List<Person> getAll() {
		Session session = template.getSessionFactory().getCurrentSession();
		try {
			Criteria c = session.createCriteria(Person.class);
	        return (List<Person>)c.list();
		} finally {
			//session.close();关闭会出现异常LogicalConnectionManagedImpl@654c1a54 is closed
		}
	}

    @Override
	public List<Person> getByName(String name) {
		Session session = template.getSessionFactory().getCurrentSession();
        try {
        	//方式一：
        	Query query = session.createQuery(" from Person where name = :abc");
        	Query queryTemp = query.setString("abc",name);
        	return queryTemp.list();
		} catch (Exception e) {
			//方式二：
			SQLQuery entity = session.createSQLQuery("select * person where name = ?").addEntity(Person.class);
        	entity.setString(0, name);
        	return entity.list();
		}finally {
			//session.close();关闭会出现异常LogicalConnectionManagedImpl@654c1a54 is closed
		}
	}

}

package com.guo.service.impl;

import java.util.List;

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

import com.guo.bean.Person;
import com.guo.dao.PersonDao;
import com.guo.service.PersonService;

@Service
@Transactional//对于事务提交方式默认的是回滚

public class PersonServiceImpl implements PersonService {

	@Autowired
	private PersonDao personDao;

	public void setPersonDao(PersonDao personDao) {
		this.personDao = personDao;
	}

	@Override
	public void add(Person p) {
		if (p != null)
			personDao.add(p);
	}

	@Override
	public Person getByID(Integer id) {
		return personDao.getByID(id);
	}

	@Override
	public void update(Person p) {
		if (p != null)
			personDao.update(p);
	}

	@Override
	public void delete(Person p) {
		if (p != null)
			personDao.delete(p);
	}

	@Override
	public List<Person> getAll() {
		return personDao.getAll();
	}
    @Override
	public List<Person> getByName(String name) {
		return personDao.getByName(name);
	}

}


package com.guo.action;

import java.util.List;

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

import com.guo.bean.Person;
import com.guo.service.PersonService;


@Controller
@Scope(scopeName="prototype")//多例模式
public class PersonAction {
    @Autowired//自动装配
    private PersonService personService;

    public void setPersonService(PersonService personService) {
		this.personService = personService;
	}

    public void add(Person p) {
        personService.add(p);
    }
    
    Person getByID(Integer id){
    	return personService.getByID(id);
    }
    public void update(Person p){
    	personService.update(p);
    }
    public void delete(Person p){
    	personService.delete(p);
    }
    public List<Person> getAll(){
    	return personService.getAll();
    }

    public List<Person> getByName(String name) {
		return personService.getByName(name);
	}
    
}

4、测试：

        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
		PersonAction action = context.getBean(PersonAction.class);
		Person add = new Person("张三", '男', 20, "京");
		//插入
		action.add(add);
		//删除
		//Person delete = new Person(1);
		//action.delete(delete);

		//按主键查询
		System.out.println(action.getByID(2));
		//按姓名查询
		System.out.println(action.getByName("张三"));
qq_40302790
关注
专栏目录
Springframework和Hibernate版本对应关系
jingde528的博客
05-05 2398
Springframework和Hibernate版本对应关系，配置Hibernate4，Spring和Hibernate版本兼容问题
Spring集成Hibernate 3
m0_46013789的博客
01-13 2554
一、集成的注意事项 SessionFactory的创建交由IOC容器来管理，通过Configuration对象创建。 Hibernate事务交给spring的声明式事务管理。 现可以通过spring配置，依赖IOC容器，DI注入来实现。 两种方式： 方式1 Spring直接加载hibernate.cfg.xml文件的方式整合 方式2 连接池交给spring管理 【一部分配置写到hibernate中(hibernate常用配置)，一部分在spring中完成(ses...
解决：在maven中pom文件添加hibernate3的依赖
qq_39380155的博客
05-20 1885
<dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-core</artifactId> <version>3.6.9.Final</version> </dependency>
Spring3与Hibernate进行集成（使用注解）
一名菜鸟攻城师
03-15 174
  首先写POM.xml   &lt;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.apa...
SSH整合——spring跟hibernate兼容问题
秦雁回的博客
03-14 1369
BUG描述： Could not open Hibernate Session for transaction; nested exception is java.lang.NoClassDefFoundError: org/hibernate/engine/transaction/spi/TransactionContext解决过程： 发现可能是版本兼容问题，我用的是spring4.0.3,h
spring 与 hibernate整合
11-24
综上所述，Spring 与 Hibernate 的整合涉及多个层面，从配置管理到事务处理，再到业务逻辑的实现，都需要精心设计和合理配置。理解这些知识点对于提升 Java 开发技能至关重要，尤其是在企业级应用开发中。通过示例...
Spring与Hibernate整合.zip
05-20
本压缩包"Spring与Hibernate整合.zip"显然包含了一个关于如何将这两个框架集成到同一Java EE项目的教程或示例代码。下面将详细讲解Spring和Hibernate整合的关键步骤和概念。 1. **Spring的Bean管理**：首先，Spring...
Spring与Hibernate整合小例子
07-12
"Spring与Hibernate整合"是为了实现业务逻辑层和数据访问层的高效协作。整合过程通常包括以下几个步骤： 1. **引入依赖**：首先，需要在项目中添加Spring和Hibernate的相关库。这通常通过Maven或Gradle的依赖管理来...
Spring与Hibernate整合实例（博客用户登录增删改查）
01-03
在这个“Spring与Hibernate整合实例（博客用户登录增删改查）”中，我们将探讨如何将这两个强大的框架——Spring和Hibernate——结合起来，以实现一个博客系统的用户管理功能，包括用户登录、注册、信息修改以及数据...
Spring5：整合Hibernate(xml配置方式，问题和错误)
编程学习者的博客
02-16 1541
1.声明 当前内容主要为复习使用当前的Spring5整合Hibernate5的操作，并发现其中的问题 当前出现的问题： Could not obtain transaction-synchronized Session for current thread（当前执行的hibernate的session中没有事务支持） 需要创建Hibernate的事务管理器<tx:advice> 需要添加aop-config的配置并未当前的执行的sql的方法动态织入事务 Legacy-style quer
如何使用maven项目下载spring和hibernate的依赖jar文件
weixin_33851177的博客
04-01 299
为什么80%的码农都做不了架构师？>>> ...
Spring5整合Hibernate5的版本适配问题和解决方法
aa10133的博客
03-16 3796
针对的问题： 使用hibernate5.4以及以上的版本整合spring5.1时,在IoC容器使用下面的类配置hibernate事务时会出现hibernate5.LocalSessionFactory的问题，Eclipse报的错误很含糊，但是也能找到一点线索，会有一行ClassNotDefFound错误。 错误说明：就是两者的版本不适配。 这个问题最好的解决方法就是换成相称的版本，直接看下面解决...
Hibernate、Jpa与Spring data Jpa三者关系与整合
Andre_151
07-02 481
目录简介Hibernate基础Hibernate+JPAHibernate+Spring Data JPA 简介 Hibernate Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 JPA JPA全称是Java Persistence API，即java持久化API，是sun公司推出的一
Spring集成ORM框架之Hibernate的使用
polo_longsan的专栏
06-10 1338
最近在学习Spring整合ORM框架。在使用Hibernate的时候遇到很多问题，花费了几天时间总算解决了。Hibernate的主要接口是org.hibernate.session，session提供了基本的数据操作功能如更新、插入、删除、加载数据对象的功能。session要通过SessionFactory来打开，关闭及管理。下面来看代码： 1、和之前一样首先通过新建一个maven项目Sprin
struts2+ hibernate4 +spring4 匹配版本
乐乐的专栏
11-06 1255
4.0.2.RELEASE 1.8.0 4.3.5.Final 2.3.16.3 4.11
Spring
weixin_46692492的博客
07-26 174
1.Spring Spring是一系列框架 Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架。 Spring核心，SpringMVC，Spring Boot Spring核心：DI,IOC,AOP，容器context SpringMVC代替了Servlet （SSM，Spring+SpringMVC+MyBatis） ​ (SSH , Spring+Struts+Hibernate) Spr
springmvc，spring，hibernate5.0整合
while(True): print('adorable')
11-04 451
目录1. pom依赖2. web.xml3. spring核心配置文件3.1 jdbc配置信息3.2 sping 配置文件4. 实体映射5. 项目结构5.1 curd5.2 页面6. 测试 1. spring版本 5.1.5 RELEASE 2. hibernate版本 5.3.9.Final 3. 数据源使用c3p0 项目使用eclipse2017 + maven构建, 完成学生的新增，查询功能。学生表是根据hibernate对实体类进行映射生成的。 1. pom依赖 <?xml version
Spring与Hibernate整合教程
Spring还提供了事务管理、数据访问抽象等服务，便于与Hibernate整合。 4. **整合过程**： - **添加Spring支持**：首先在Eclipse中为项目添加Spring支持，导入所需的Spring库，如`spring.jar`、`aopalliance.jar`等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值