Spring整合Hibernate JPA

最新推荐文章于 2024-09-20 13:48:45 发布
最新推荐文章于 2024-09-20 13:48:45 发布
阅读量1.4k 收藏 3
点赞数 1
分类专栏： Java后端 Spring全家桶 文章标签： 后端 spring hibernate sql java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50216991/article/details/124393527
版权

JPA:就是由Sun公司提供的一套对于持久层操作的标准(接口加文档),没有具体的实现。

Hibernate：是Gavin King 开发的一套对于持久层操作的自动ORM框架。

Hibernate JPA：是在Hibernate3.2版本中，提供的对于JPA标准的实现。提供了一套按照JPA标准来实现持久层开发的APi。

下面具体的代码实现：

1.导入Maven依赖：

    <dependencies>
    <!--Spring Ioc相关依赖-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.3.18</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.18</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>5.3.18</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>5.3.18</version>
    </dependency>

    <!--Spring Aop的相关依赖-->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.8.RC2</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>5.3.18</version>
    </dependency>

    <!--Spring jdbc的相关依赖-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.3.18</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>5.3.18</version>
    </dependency>

    <!--spring orm的相关依赖-->
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-orm -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>5.3.18</version>
    </dependency>

    <!--单元测试用的依赖-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13</version>
        <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.3.18</version>
    </dependency>

    <!--日志依赖-->
    <!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>

    <!--Hibernate的核心依赖,9个必须要导入-->
    <!-- https://mvnrepository.com/artifact/antlr/antlr -->
    <dependency>
        <groupId>antlr</groupId>
        <artifactId>antlr</artifactId>
        <version>2.7.7</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.dom4j/dom4j -->
    <dependency>
        <groupId>org.dom4j</groupId>
        <artifactId>dom4j</artifactId>
        <version>2.1.3</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.apache.geronimo.specs/geronimo-jta_1.1_spec -->
    <dependency>
        <groupId>org.apache.geronimo.specs</groupId>
        <artifactId>geronimo-jta_1.1_spec</artifactId>
        <version>1.1.1</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.hibernate.common/hibernate-commons-annotations -->
    <dependency>
        <groupId>org.hibernate.common</groupId>
        <artifactId>hibernate-commons-annotations</artifactId>
        <version>5.1.2.Final</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>5.6.5.Final</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.hibernate.javax.persistence/hibernate-jpa-2.1-api -->
    <dependency>
        <groupId>org.hibernate.javax.persistence</groupId>
        <artifactId>hibernate-jpa-2.1-api</artifactId>
        <version>1.0.0.Final</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.jboss/jandex -->
    <dependency>
        <groupId>org.jboss</groupId>
        <artifactId>jandex</artifactId>
        <version>2.0.0.Final</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.javassist/javassist -->
    <dependency>
        <groupId>org.javassist</groupId>
        <artifactId>javassist</artifactId>
        <version>3.28.0-GA</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.jboss.logging/jboss-logging -->
    <dependency>
        <groupId>org.jboss.logging</groupId>
        <artifactId>jboss-logging</artifactId>
        <version>3.4.1.Final</version>
    </dependency>

    <!--mysql数据驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.25</version>
    </dependency>

    <!--连接池相关的依赖-->
    <dependency>
        <groupId>com.mchange</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.5.5</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-c3p0 -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-c3p0</artifactId>
        <version>5.6.7.Final</version>
    </dependency>

    <dependency>
        <groupId>com.mchange</groupId>
        <artifactId>mchange-commons-java</artifactId>
        <version>0.2.19</version>
    </dependency>

    <!--hibernate jpa 相关依赖-->
    <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-entitymanager -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-entitymanager</artifactId>
        <version>5.6.7.Final</version>
    </dependency>
    
</dependencies>

创建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:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--配置读取properties文件的工具类-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--配置c3p0数据库连接池-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="driverClass" value="${jdbc.driver.class}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!--Spring整合 Hibernate JPA ,配置EntityManagerFactory-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <!--hibernate相关属性的注入:-->
                <!--database配置数据库类型-->
                <property name="database" value="MYSQL"/>
                <!--开启正向工程，自动创建表-->
                <property name="generateDdl" value="true"/>
                <!--开启显示执行的sql-->
                <property name="showSql" value="true"/>
            </bean>
        </property>
        <!--配置要扫描的实体的包-->
        <property name="packagesToScan">
            <list>
                <value>com.haiexijun.pojo</value>
            </list>
        </property>
    </bean>

    <!--配置Hibernate的事务管理器-->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>


    <!--开启注解事务处理-->
    <tx:annotation-driven transaction-manager="transactionManager"/>

    <!--配置springIOC的注解扫描-->
    <context:component-scan base-package="com.haiexijun"/>

</beans>

创建数据库hibernate02

jdbc配置文件：

jdbc.url=jdbc:mysql://localhost:3306/hibernate02
jdbc.driver.class=com.mysql.cj.jdbc.Driver
jdbc.username=root
jdbc.password=zc20020106

2.编写实体类

package com.haiexijun.pojo;

import javax.persistence.*;
import java.io.Serializable;

@Entity
@Table(name = "t_users")
public class Users implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)//自增
    @Column(name = "userid")
    private Integer userId;
    @Column(name = "username")
    private String userName;
    @Column(name = "userage")
    private Integer userAge;

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Integer getUserAge() {
        return userAge;
    }

    public void setUserAge(Integer userAge) {
        this.userAge = userAge;
    }

    @Override
    public String toString() {
        return "Users{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", userAge=" + userAge +
                '}';
    }
}

3.创建usersDao类及其实现类

package com.haiexijun.dao.impl;

import com.haiexijun.dao.usersDao;
import com.haiexijun.pojo.Users;
import org.springframework.stereotype.Repository;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.util.List;

@Repository
public class usersDaoImpl implements usersDao {

    @PersistenceContext(name = "entityManagerFactory")
    private EntityManager entityManager;

    @Override
    public void insertUsers(Users users) {
        entityManager.persist(users);
    }

    @Override
    public void updateUsers(Users users) {
        entityManager.merge(users);
    }

    @Override
    public void deleteUsers(Users users) {
        Users u =selectUsersById(users.getUserId());
        this.entityManager.remove(u);
    }

    @Override
    public Users selectUsersById(Integer userid) {
        return entityManager.find(Users.class,userid);
    }

    @Override
    public List<Users> selectUserByAge(Integer age) {
        //这里from会报错，但是没有毛病！
        return entityManager.createQuery("from Users where userAge = :abc").setParameter("abc",age).getResultList();
    }

    @Override
    public List<Users> selectUserByAgeUseSQL(Integer age) {
        //这里要绝对注意哦，在Hibernate JPA中如果通过?还传入参数，查数是从1开始的。我们之前学习的Hibernate是从0开始的。
        return entityManager.createNativeQuery("select * from t_users where userage=?",Users.class).setParameter(1,age).getResultList();
    }

    @Override
    public List<Users> selectUserByAgeUseQBC(Integer age) {
        //CriteriaBuilder对象：创建一个CriteriaQuery,创建查询条件
        CriteriaBuilder builder=entityManager.getCriteriaBuilder();
        //CriteriaQuery对象：执行查询的Criteria对象
        CriteriaQuery<Users> query=builder.createQuery(Users.class);
        //获取要查询的实体类对象
        Root<Users> root=query.from(Users.class);
        //封装查询条件
        Predicate predicate=builder.equal(root.get("userAge"),age);
        query.where(predicate);
        //执行查询
        TypedQuery<Users> typedQuery=entityManager.createQuery(query);
        List<Users> users=typedQuery.getResultList();
        return users;
    }
}

测试代码：

package com.haiexijun.dao.impl;

import com.haiexijun.pojo.Users;
import junit.framework.TestCase;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class usersDaoImplTest extends TestCase {

    @Autowired
    private usersDaoImpl usersDao;

    @Test
    @Transactional
    @Rollback(value = false)
    public void testInsertUsers() {
        Users users=new Users();
        users.setUserName("张五");
        users.setUserAge(20);
        usersDao.insertUsers(users);
    }
    @Test
    @Transactional
    @Rollback(value = false)
    public void testUpdateUsers() {
        Users users=new Users();
        users.setUserId(1);
        users.setUserName("张四");
        users.setUserAge(20);
        usersDao.updateUsers(users);
    }

    @Test
    @Transactional
    @Rollback(value = false)
    public void testDeleteUsers() {
        Users users=new Users();
        users.setUserId(1);
        users.setUserName("张四");
        users.setUserAge(20);
        usersDao.deleteUsers(users);
    }

    @Test
    @Transactional
    @Rollback(value = false)
    public void testSelectUsersById() {
        Users users= usersDao.selectUsersById(1);
        System.out.println(users);
    }

    @Test
    @Transactional
    @Rollback(value = false)
    public void testSelectUserByAge() {
        List<Users> usersList = usersDao.selectUserByAge(20);
        System.out.println(usersList);
    }

    @Test
    @Transactional
    @Rollback(value = false)
    public void testSelectUserByAgeUseSQL() {
        System.out.println(usersDao.selectUserByAgeUseSQL(20));
    }

    @Test
    @Transactional
    @Rollback(value = false)
    public void testSelectUserByAgeUseQBC() {
        System.out.println(usersDao.selectUserByAgeUseQBC(20));
    }
}
Spring Boot 整合Spring Data JPA之Hibernate JPA（七）
m0_38075227的博客
08-28 286
Spring Boot 整合Spring Data JPA之Hibernate JPA（七） 在spring boot整合spring data jpa之前先了解一下Hibernate JPA JPA:由 Sun 公司提供了一对对于持久层操作的标准(接口+文档) Hibernate:是 Gavin King 开发的一套对于持久层操作的自动的 ORM 框架。 Hibernate JPA:是在 Hibernate3.2 版本那种提供了对于 JPA 的标准的实现。提供了一套按 照 JPA 标准来实现持久层开发的
hibernate(jpa)+spring
qq_33854869的博客
07-13 567
项目中用到了hibernate,抽个时间记录下(前面有个简陋的介绍spring+redis+hibernate,此篇对hibernate有个更为详细的使用). Hibernate是一种ORM(Object Relational Mapping)映射工具，能够建立面向对象的域模型和关系数据模型之间的映射 Object Mapping（Hibernate） Relational 面向对象领域
springmvc+jpa(hibernate实现)+spring整合实例
04-29
工作用了springmvc+jpa+spring这么长时间，这段时间正好有点时间就想整合一下，但在整合过程中遇到了各种问题，上网查了很多资料但讲的都很模糊或者是没有注释，在我一步一步的试验中终于整合成功了，做为我自已以后复习用的资料我注释写的很全，其中项目里面的配置文件或是代码每行都有注释，网上这种整合实例很少，就奉献出来大家一起学习吧，在整合过程中遇到一个很奇怪的问题，就是spring的事务我配置成@Transactional(readOnly = true)只读事务，但是还可以对数据库进行操作，大家如果知道原因的就一起交流下吧
Spring JPA 中的 Hibernate
CodersCoder的博客
12-10 346
Hibernate 架构分析 首先看一下 Hibernate 5.2 版本中，官方提供的架构图。 从架构图上，我们可以知道 Hiberante 实现的 ORM 的接口有两种，一种是 Hiberante 自己的 API 接口；一种是 Java Persistence API 的接口实现。 因为 Hibernate 其实是比 Java Persistence API 早几年发展的，后来才有了 Java 的持久化协议。以我个人的观点来看，随着时间的推移，Hiberante 的实现逻辑可能会逐渐被弱化，由 Jav
掌握Spring Boot数据库集成：用JPA和Hibernate构建高效数据交互与版本控制
最新发布
2202_76097976的博客
09-20 3636
这篇博客从基础配置到高级优化，全面探讨了Spring Boot中使用JPA和Hibernate进行数据库交互的相关技术，并为数据迁移和版本控制提供了可行的方案。
spring + jpa + hibernate
qq_26182553的博客
07-13 323
1. 添加依赖Jar文件。除了必要的spring和Hibernate依赖外，下面的jar必不可少， 否则会抛出异常“No Persistence provider for EntityManager named *” org.hibernate hibernate-entitymanager 4.2.8.Final 2. spring-jpa-hibernat
spring+hibernate JPA
qiuyabing的专栏
05-07 129
关于spring+hibernate JPA的一个例子       通过spring配置来实现对数据库的访问和对事务的管理 简单的对一张表（table）的操作 实体类： User.java package domain; import javax.persistence.Column;import javax.persistence.Entity;import javax.pers...
Spring+Hibernate+SpringJPA
weixin_43343423的博客
09-05 151
dao层几种配法 1.优先使用内置接口方法 2.按方法命名规范定义接口 3.手动定制sql或hql方式 4.手动提供接口实现类 第一种UserRepository package dao; import model.User; import org.springframework.data.jpa.repository.Modifying; import org.springframework....
spring 整合 hibernate jpa2 实例
04-12
总的来说，这个"spring 整合 hibernate jpa2 实例"展示了如何利用Spring的便利性和JPA2的强大功能来简化数据库操作。通过合理的配置和接口设计，我们可以构建出高效、易于维护的Java应用。同时，使用Maven作为构建...
springmvc spring hibernate jpa maven 整合
11-18
这个项目"springmvc spring hibernate jpa maven 整合"就是这样一个例子，它整合了四个关键的技术组件：Spring MVC、Spring、Hibernate和JPA，以及依赖管理工具Maven。让我们详细探讨这些技术及其在项目中的作用。 ...
Hibernate JPA整合Spring
失忆๑的博客
08-19 146
一）添加新的jar包 二）配置文件的修改 主要修改的是配置文件内信息 1.修改上下文对象 2.修改事物管理器 3.删除HibernateTempLate模板类 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instan...
Spring整合JPA(Hibernate实现)
Clare Tung
08-26 879
完整项目下载: GitHub：https://github.com/tangqiangDong/Spring-JPA.git CSDN资源：https://download.csdn.net/download/qq_36135928/10627609 1、引入pom依赖。 &lt;properties&gt;     &lt;spring-version&gt;4.3.7.R...
Spring基础入门7 - JPA/Hibernate
Li_Xiang_996的博客
02-08 1042
1. 数据访问层 (DAO模式) 通常我们的应用都要使用数据，涉及到大量的数据存取, 对于企业级应用，数据存放在关系型数据库是最常用的方案。前文提到Spring MVC将前端展现与业务逻辑分离，为了让程序结构更清晰，我们还会将数据访问从业务逻辑中也分离出来，做为一个数据访问层(持久化数据层)。这样我们就获得了一个J2EE经典的三层架构: 表现层 - 业务逻辑层 - 数据访问层。 数据访问层通常使用的DAO模式进行封装，DAO模式主要包括三部分: DAO接口: 对需要的数据库操作的接口，提供外部(业务逻
【SpringBoot整合JPA框架（hibernate实现）详解】（附详细代码）
qq_45759093的博客
02-20 3513
Java Persistence API（JPA）是Java EE和Java SE平台的一部分，提供了一种简单的对象关系映射（ORM）机制，用于将Java对象持久化到关系型数据库中。JPA通过注解或XML配置文件实现实体类与数据库表之间的映射，简化了数据库操作的过程。
jpa+spring+hibernate
cxfking的专栏
03-04 522
一 前言        最近在做个项目,JPA使用了hibernate3.6.后来觉得JPA单独使用不是很给力,于是就想到了和spring集成.刚开始,我是用spring2.5.6和hibernate3.6集成的,屡次不成功.后来研究发现,hibernate3.6的JPA是2.0的.狂晕.下面是spring3.0.5(支持JPA2.0)和hibernate3.6集成,其中源代码在附件里， 只有
Spring JPA/Hibernate学习笔记
weixin_45926582的博客
06-03 211
Hibernate：进行数据库操作的封装 Hibernate对象的三种状态 临时态(Transient) 是指从对象通过new语句创建到被持久化之前的状态，此时对象不在Session的缓存中。 这个对象所保存的数据与数据库没有任何关系，除非通过Session的save()、saveOrUpdate()、persist()、merge()方法把瞬时态/临时态对象与数据库关联，并把数据插入或者更新到数据库，这个对象才转换为持久态对象。 特点： •1不在Session缓存中，不与任何Session实
spring mvc 与JPA/Hibernate的整合示例
04-21
为了整合Spring MVC、JPA和Hibernate，我们需要在`pom.xml`中添加相应的依赖。确保包括以下依赖： 1. Spring MVC相关依赖，如`spring-webmvc` 2. JPA核心依赖，如`javax.persistence` 3. Hibernate实现JPA的依赖，...
Spring Hibernate 整合要点之JPA
07-20
Spring Hibernate整合要点之JPA 1 依赖包 2 注解实体 3 DAO实现 4 JPA配置 5 spring配置 6 修改web.xml
Spring + hibernate + JPA 配置
weixin_33730836的博客
10-02 123
最近对hibernate的JPA实现比较感兴趣，在此记录下配置方法，备查。先上maven依赖包配置，这里使用的是spring3.1.2和hibernate3.6.0<dependencies> <dependency> <groupId>org.hibernate</groupI...
Spring-JPA（使用Hibernate作为JPA的实现）
一朝风月
12-24 4887
1 简介 在Spring2.0版本中，Spring首次集成了JPA，很多开发人员都推荐在基于Spring的应用程序中使用JPA实现持久化。实际上，有些人还将Spring-JPA合称为POJO开发的梦之队。 2 示例 在本示例中使用Hibernate作为JPA的实现，也可以选择类似的其他技术如MyBatis也是可以的。 2.1 配置数据源 我这边采用的是Hive作为数据源从中读取records表的数...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

害恶细君

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值