AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Spring整合Hibernate JPA

2022-11-22 99
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
RDS MySQL Serverless 基础系列，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
云数据库 RDS MySQL，集群系列 2核4GB
推荐场景：
搭建个人博客
云数据库 RDS MySQL，高可用系列 2核4GB
简介： Spring整合Hibernate JPA

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));
    }
}
文章标签：
云数据库 RDS MySQL 版
Java
Spring
Maven
API
数据库
数据库连接
关键词：
Hibernate jpa
Spring JPA
Spring hibernate
Hibernate spring
相关实践学习
如何在云端创建MySQL数据库
开始实验后，系统会自动创建一台自建MySQL的 源数据库 ECS 实例和一台 目标数据库 RDS。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心，利用清洁计算为万物互联的新世界提供源源不断的能源动力，目前开服的区域包括中国（华北、华东、华南、香港）、新加坡、美国（美东、美西）、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程，来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品：云服务器ECS 云服务器 ECS（Elastic Compute Service）是一种弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率，使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
害恶细君
目录
相关文章
土木林森
|
12天前
|
SQL Java 数据库连接
从理论到实践：Hibernate与JPA在Java项目中的实际应用
本文介绍了Java持久层框架Hibernate和JPA的基本概念及其在具体项目中的应用。通过一个在线书店系统的实例，展示了如何使用@Entity注解定义实体类、通过Spring Data JPA定义仓库接口、在服务层调用方法进行数据库操作，以及使用JPQL编写自定义查询和管理事务。这些技术不仅简化了数据库操作，还显著提升了开发效率。
土木林森
26 3
Codelinghu
|
1月前
|
SQL Java 关系型数据库
Springboot引入jpa来管理数据库
Springboot引入jpa来管理数据库
Codelinghu
36 0
Springboot引入jpa来管理数据库
木子0204
|
1月前
|
SQL Java 数据库连接
springBoot+Jpa(hibernate)数据库基本操作
springBoot+Jpa(hibernate)数据库基本操作
木子0204
42 0
程序员小海绵
|
2月前
|
Java 数据库连接 API
【Java笔记+踩坑】Spring Data JPA
从常用注解、实体类和各层编写方法入手，详细介绍JPA框架在增删改查等方面的基本用法，以及填充用户名日期、分页查询等高级用法。
程序员小海绵
130 0
【Java笔记+踩坑】Spring Data JPA
Yaiba123
|
3月前
|
XML JSON Java
使用IDEA+Maven搭建整合一个Struts2+Spring4+Hibernate4项目，混合使用传统Xml与@注解，返回JSP视图或JSON数据，快来给你的SSH老项目翻新一下吧
本文介绍了如何使用IntelliJ IDEA和Maven搭建一个整合了Struts2、Spring4、Hibernate4的J2EE项目，并配置了项目目录结构、web.xml、welcome.jsp以及多个JSP页面，用于刷新和学习传统的SSH框架。
Yaiba123
90 0
使用IDEA+Maven搭建整合一个Struts2+Spring4+Hibernate4项目，混合使用传统Xml与@注解，返回JSP视图或JSON数据，快来给你的SSH老项目翻新一下吧
Yaiba123
|
3月前
|
安全 Java 数据安全/隐私保护
基于SpringBoot+Spring Security+Jpa的校园图书管理系统
本文介绍了一个基于SpringBoot、Spring Security和JPA开发的校园图书管理系统，包括系统的核心控制器`LoginController`的代码实现，该控制器处理用户登录、注销、密码更新、角色管理等功能，并提供了系统初始化测试数据的方法。
Yaiba123
59 0
基于SpringBoot+Spring Security+Jpa的校园图书管理系统
如夜了我衣衫太薄便归家靠路灯
|
3月前
|
Java 关系型数据库 MySQL
springboot 整合 jpa，mysql
springboot 整合 jpa，mysql
如夜了我衣衫太薄便归家靠路灯
56 2
土木林森
|
3月前
|
Java Spring 数据库
怎样动动手指就能实现数据操作？Spring Data JPA背后的魔法揭秘
【8月更文挑战第31天】在Java开发中，数据库交互至关重要。传统的JDBC操作繁琐且难维护，而Spring Data JPA作为集成JPA的数据访问层解决方案，提供了CRUD等通用操作接口，显著减少代码量。通过继承`JpaRepository`，开发者能轻松实现数据的增删改查，甚至复杂查询和分页也不再困难。本文将通过示例详细介绍如何利用Spring Data JPA简化数据访问层的开发，提升代码质量和可维护性。
土木林森
43 0
土木林森
|
3月前
|
Java 数据库连接 数据库
携手前行：在Java世界中深入挖掘Hibernate与JPA的协同效应
【8月更文挑战第31天】Java持久化API（JPA）是一种Java规范，为数据库数据持久化提供对象关系映射（ORM）方法。JPA定义了实体类与数据库表的映射及数据查询和事务控制方式，确保不同实现间的兼容性。Hibernate是JPA规范的一种实现，提供了二级缓存、延迟加载等丰富特性，提升应用性能和可维护性。通过结合JPA和Hibernate，开发者能编写符合规范且具有高度可移植性的代码，并利用Hibernate的额外功能优化数据持久化操作。
土木林森
42 0
wljslmz
|
3月前
|
存储 Java 数据库
区分 Spring Data JPA 中的 findById() 和 getOne()
【8月更文挑战第21天】
wljslmz
84 0

热门文章

最新文章

  • 1
    Spring-boot+Dubbo应用启停源码分析
  • 2
    SpringMvc+Spring+MyBatis 基于注解整合
  • 3
    Spring Cloud实战小贴士：Zuul统一异常处理（一）
  • 4
    转：spring配置文件中xsd引用问题
  • 5
    Spring Boot Controller
  • 6
    Spring装配Bean---使用xml配置
  • 7
    面向切面的Spring
  • 8
    Ehcache 整合Spring 使用页面、对象缓存
  • 9
    在Spring中使用JDK定时器实现调度任务
  • 10
    【异常】spring-boot配置文件中server.context-path不起作用的解决方案
  • 1
    Java面试题：简述ORM框架（如Hibernate、MyBatis）的工作原理及其优缺点。
    78
  • 2
    如何在Spring Boot中集成Hibernate
    118
  • 3
    使用Hibernate实现复杂数据库查询优化策略
    48
  • 4
    使用Hibernate实现复杂数据库查询优化策略
    59
  • 5
    必知的技术知识：HHS整合（Struts2+Spring+Hibernate）
    38
  • 6
    技术经验分享：Hibernate之HQL
    31
  • 7
    程序技术好文：电脑睡眠（sleep）和休眠（Hibernate）的区别，以及休眠功能的设置
    143
  • 8
    技术好文共享：电脑睡眠（sleep）和休眠（Hibernate）的区别，以及休眠功能的设置
    95
  • 9
    深入理解Java中的JPA与Hibernate
    57
  • 10
    从理论到实践：Hibernate与JPA在Java项目中的实际应用
    47

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第四阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库

    • 相关实验场景

    更多
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    阿里云OSS设置跨域访问