【自我提升】JPA从搭建到CRUD快速入门（IDEA+MAVEN）

已于 2023-07-12 10:50:31 修改
阅读量1.3k 收藏 2
点赞数 1
分类专栏： java基础 文章标签： java jpa orm hibernate
于 2023-07-11 16:18:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47959003/article/details/131661608
版权

写在前面：今天又学习一点新的东西，方面日后查询和巩固学习，下面将学习过程记录下来。

一、创建MAVEN工程

1. 打开IDEA创建一个纯净的maven工程项目

 2. 打开pom文件，导入maven坐标

注意：我使用的postgres数据库，如果你使用的其他数据库，只需要将这个依赖替换即可。不管什么数据库，你都需要注意依赖的版本，和你自己下载的数据库相匹配。

maven仓库地址：

maven仓库地址https://central.sonatype.com/?smo=true

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.hibernate.version>5.0.7.Final</project.hibernate.version>
    </properties>


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

        <!-- hibernate对jpa的支持包 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${project.hibernate.version}</version>
        </dependency>

        <!-- c3p0 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>${project.hibernate.version}</version>
        </dependency>
        

        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>42.6.0</version>
        </dependency>

        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
            <scope>provided</scope>
        </dependency>

    </dependencies>

二、项目结构完善

目录结构如下所示：

 1. 创建实体类

package com.study.entity;


import lombok.Data;

import javax.persistence.*;

/**
 * 客户类
 */
@Entity
@Table(name = "cst_customer")
@Data
public class Customer {
    /**
     * 声明主键的配置
     * @Id 主键
     * @GeneratedValue 主键生成策略，GenerationType.IDENTITY为自增策略
     * @Column 配置属性和字段映射关系
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "cust_id")
    private Long custId;
    @Column(name = "cust_name")
    private String custName;
    @Column(name = "cust_source")
    private String custSource;
    @Column(name = "cust_level")
    private String custLevel;
    @Column(name = "cust_industry")
    private String custIndustry;
    @Column(name = "cust_phone")
    private String custPhone;
    @Column(name = "cust_address")
    private String custAddress;
}

2. 创建工具类

        通过静态代码块的形式来解决EntityManagerFactory创建实例浪费资源的问题。

  • 第一次访问getEntityManager：首先经过静态代码块，创建工厂对象，再调用方法，创建一个EntityManager对象。
  • 第二次访问getEntityManager，直接通过一个已经创建好的factory对象，返回一个EntityManager对象 。
package com.study.utils;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

/**
 * 1. 解决通过EntityManagerFactory浪费资源的问题
 * 2. 静态代码块的形式来解决
 *
 * 第一次访问getEntityManager：首先经过静态代码快，创建工厂对象，再调用方法，创建一个EntityManager对象
 * 第二次访问getEntityManager，直接通过一个已经创建好的factory对象，返回一个EntityManager对象
 */
public class JPAUtil {
    private static EntityManagerFactory factory;
    static {
        //加载配置文件，创建EntityManagerFactory
        factory = Persistence.createEntityManagerFactory("myJpa");

    }

    /**
     * 获取EntityManager实体对象
     */
    public static EntityManager getEntityManager(){
        return factory.createEntityManager();
    }
}

3. persistence.xml 持久化配置

注意：如果使用的是mysql，则需要将数据库配置替换:

            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="root"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/HeimaSpringData?userSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=Asia/Shanghai"/>
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
    <!--需要配置persistence-unit节点
        持久化单元：
            name:持久化单元名称
            transaction-type:事务管理的方式
                JTA:分布式事务管理
                RESOURCE_LOCAL:本地事务管理
    -->
    <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
        <!--jpa的实现方式-->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <!--可选配置：配置jpa实现方式的配置信息-->
        <properties>
            <!-- 数据库信息
                用户名，javax.persistence.jdbc.user
                密码，  javax.persistence.jdbc.password
                驱动，  javax.persistence.jdbc.driver
                数据库地址   javax.persistence.jdbc.url
            -->
            <property name="javax.persistence.jdbc.user" value="postgres"/>
            <property name="javax.persistence.jdbc.password" value="123456"/>
            <property name="javax.persistence.jdbc.driver" value="org.postgresql.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:postgresql://localhost:5432/lianxi"/>


            <!--配置jpa实现方(hibernate)的配置信息
                显示sql           ：   false|true
                自动创建数据库表    ：  hibernate.hbm2ddl.auto
                        create      : 程序运行时创建数据库表（如果有表，先删除表再创建）
                        update      ：程序运行时创建表（如果有表，不会创建表）
                        none        ：不会创建表
            -->
            <property name="hibernate.show_sql" value="true" />
            <property name="hibernate.hbm2ddl.auto" value="update" />
        </properties>
    </persistence-unit>

</persistence>
  • create      : 程序运行时创建数据库表（如果有表，先删除表再创建）
update      ：程序运行时创建表（如果有表，不会创建表）
none        ：不会创建表

三、JAP之CRUD操作

在测试目录下，创建一个测试类JpaTest.java；CRUD大体上可以分为五个步骤：

  1. 获取EntityManager对象
  2. 开启事务
  3. CRUD操作
  4. 提交事务
  5. 释放资源

1. 新增操作

    @Test
    public void testSave(){
        //加载配置文件创建工厂
        //通过实体管理工厂获取实体管理器
        EntityManager em = JPAUtil.getEntityManager();
        //获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();//开启事务
        //完成增删改查操作
        Customer customer = new Customer();
        customer.setCustName("测试88");
        customer.setCustIndustry("测试行业");
        //保存
        em.persist(customer);
        //提交事务
        tx.commit();
        //释放资源
        em.close();
    }

2. find（）查询和 getReference()查询，两个查询的结果都是一样的。只不过getReference()是懒加载，可以节省资源。

    /**
     * 查询操作
     */
    @Test
    public void testFind(){
        //通过工具类获取一个EntityManager对象
        EntityManager em = JPAUtil.getEntityManager();
        EntityTransaction ts = em.getTransaction();
        ts.begin();//开启事务
        //根据id查询数据
        Customer customer = em.find(Customer.class, 1L);
        System.out.println(customer);
        //提交事务
        ts.commit();
        //释放资源
        em.close();
    }

    /**
     * 查询操作
     * 特点：获取的是一个动态代理对象，调用getReference不会立即发送sql语句查询。当调用查询结果对象的时候才会查询（什么时候用什么时候查）
     * 什么时候用什么时候才加载，懒加载
     * 一般用延迟加载的方式比较好，这样可以节省资源，避免浪费效率
     */
    @Test
    public void textReference(){
        //通过工具类获取一个EntityManager对象
        EntityManager em = JPAUtil.getEntityManager();
        EntityTransaction ts = em.getTransaction();
        ts.begin();//开启事务
        //根据id查询数据
        Customer customer = em.getReference(Customer.class, 1L);
        System.out.println(customer);
        //提交事务
        ts.commit();
        //释放资源
        em.close();
    }

3.  删除操作(先查询，然后删除)

    /**
     * 删除客户方法
     */
    @Test
    public void testDelete(){
        EntityManager entityManager = JPAUtil.getEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        //根据id查询数据
        Customer customer = entityManager.getReference(Customer.class, 4L);
        //删除对象
        entityManager.remove(customer);
        transaction.commit();
        entityManager.close();
    }

4.更新操作(先查询后更新操作)

    /**
     * 客户的更新操作
     */
    @Test
    public void testUpdate(){
        EntityManager entityManager = JPAUtil.getEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        //根据id查询数据
        Customer customer = entityManager.find(Customer.class, 5L);
        //更新对象
        customer.setCustPhone("147852369");
        entityManager.merge(customer);
        transaction.commit();
        entityManager.close();
    }

jpql常用条件查询

        在JPA（Java Persistence API）中，可以使用JPQL（Java Persistence Query Language）进行条件查询。JPQL是一种面向对象的查询语言，类似于SQL，但是操作的是实体对象而不是数据库表。

下面是一些示例JPQL查询的条件语句：

（1）基本的条件查询：例如查询工资大于50000的员工对象.

String jpql = "SELECT e FROM Employee e WHERE e.salary > :salary";
List<Employee> employees = entityManager.createQuery(jpql, Employee.class)
    .setParameter("salary", 50000)
    .getResultList();

（2）使用逻辑运算符：查询工资大于50000且所属部门为"IT"的员工对象.

String jpql = "SELECT e FROM Employee e WHERE e.salary > :minSalary AND e.department = :department";
List<Employee> employees = entityManager.createQuery(jpql, Employee.class)
    .setParameter("minSalary", 50000)
    .setParameter("department", "IT")
    .getResultList();

(3)使用模糊查询:查询名字中包含"Smith"的员工对象。

String jpql = "SELECT e FROM Employee e WHERE e.name LIKE :keyword";
List<Employee> employees = entityManager.createQuery(jpql, Employee.class)
    .setParameter("keyword", "%Smith%")
    .getResultList();

(4)使用IN子句：查询所属部门为"IT"或"HR"的员工对象。

String jpql = "SELECT e FROM Employee e WHERE e.department IN :departments";
List<String> departmentList = Arrays.asList("IT", "HR");
List<Employee> employees = entityManager.createQuery(jpql, Employee.class)
    .setParameter("departments", departmentList)
    .getResultList();

(5) 使用like查询

String jpql = "FROM Customer WHERE custName LIKE ?";
List<Customer> customers = entityManager.createQuery(jpql, Customer.class)
    .setParameter(1, "%Smith%")
    .getResultList();

(6) 查询排序

String jpql = "select count(custId) from Customer";
Query query = em.createQuery(jpql);//创建Query查询对象，query对象才是执行jqpl的对象

(7)分页查询

        //3.查询全部
        //i.根据jpql语句创建Query查询对象
        String jpql = "from Customer";
        Query query = em.createQuery(jpql);
        //ii.对参数赋值 -- 分页参数
        //起始索引
        query.setFirstResult(1);
        //每页查询的条数
        query.setMaxResults(2);

        //iii.发送查询，并封装结果

        /**
         * getResultList ： 直接将查询结果封装为list集合
         * getSingleResult : 得到唯一的结果集
         */
        List list = query.getResultList();

        for(Object obj : list) {
            System.out.println(obj);
        }

差不多敲完上面的代码后，基本就熟练了，入门上手应该是够了。

记录菌
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring Data JPA项目
06-18
课程以Spring Data JPA和Swagger2为主线，讲解如何使用JPA访问数据库,如何使用Swagger2为前端构建在线API文档
JPA快速入门初步（myeclipse）
06-29
JPA快速入门初步（myeclipse）
IDEA SpringBoot整合SpringData JPA（保姆级教程，超详细！！！）
最新发布
当觉得自己菜的时候，就应该静下心来学习
06-28 1678
本博客将详细介绍在IDEA中，如何整合SpringBoot与SpringData JPA，以实现数据库的增删改查操作。我将逐步从环境搭建到实际代码实现的完整流程，帮助读者更好地理解并掌握这一技术栈。JPA是Java Persistence API的缩写，它定义了Java对象如何映射到关系型数据库中的表，以及如何使用面向对象的方式来查询这些表。JPA是Java EE 5规范的一部分，并由EJB 3.0（Enterprise JavaBeans）实现。2. 创建SpringBoot项目。
JPA入门
热门推荐
一叶知秋
03-16 1万+
目录 JPA概述 JPA Spring Data JPA JPA注解 基础注解 Entity Table Id Enumerated Transient Column Temporal 联合主键注解 IdClass Embeddable和EmbeddedId注解 实体之间关联关系注解 OneToOne ManyToOne和OneToMany Repository JPA查询方式 DQM（定义查询方法） 使用实例 DMQ方法名中支持的关键字 支持分页和排序.
Spring Data JPA 五分钟快速入门和实践
weixin_45111030的博客
12-26 2388
Spring Data JPA（类似于Java Web 中的 DAO) 操作声明持久层的接口（Repository） 三个核心接口： CrudRepository PagingAndSortingRepository JpaRepository 相应解释： 该类提供基本的crud等接口； 该类提供基本分页，排序等接口； 作为前二者的子类，继承它们所有接口，在实际项目中，均为JapRepository或其子类进行基本的数据库操作； 概念图： 如何使用JPA： 引入相关JPA
搭建JPA项目
wb785074651的博客
06-21 486
本章讲的是简单的搭建SpringDataJPA项目，通过操作对象，然后对应的去操作数据库中的表。 环境搭建过程 1.创建maven工程 2.配置jpa文件 3.创建实体类 4.配置实体类和表，类中属性和表中字段的的映射关系 5.操作增删改查 首先搭建一个mave工程 然后在Resource下面创建一个META-INF文件夹下创建一个persistence.xml文件并进行配置 ​ <?xml version="1.0" encoding="UTF-8"?> <per
一、JPA快速入门
欲望以提升热忱 毅力以磨平高山
03-27 1386
一、关于JPA     关于JPA是什么，在这里不做解释，感兴趣的话可以参照：      http://blog.csdn.net/chjttony/article/details/6086298      http://www.cnblogs.com/holbrook/archive/2012/12/30/2839842.html 二、首先而且必要的事搭建JPA环境     1
IDEA+maven+SpringBoot+JPA+Thymeleaf实现Crud及分页
08-27
IDEA+maven+SpringBoot+JPA+Thymeleaf实现CRUD及分页 本文主要介绍了如何使用IDEA+maven+SpringBoot+JPA+Thymeleaf实现CRUD及分页的操作。下面是详细的实现步骤： 开发环境 在开始之前，我们需要准备好以下开发...
Spring Boot+Maven+Spring Data JPA+Layui实现销售培训考评系统
06-11
jdk8 + tomcat8 + mariaDB + IntelliJ IDEA + maven 项目技术(必填) springboot + spring data jpa + layui 数据库文件(可选) 链接：https://pan.baidu.com/s/1aLSSLfGBL1hhityifeyh6A 提取码：4zpr 依赖包文件...
spring+status2+hibarnate+maven+idea框架搭建及一些列方法
05-31
总结起来，"spring+status2+hibernate+maven+idea框架搭建及一些列方法"涉及到了Java Web开发的核心技术栈，通过这些技术的结合，可以构建出高效、可维护的Web应用。理解并熟练掌握这些技术，对于Java开发者来说至关...
IntelliJ IDEA下SpringBoot+Maven+JPA+Thymeleaf整合实现增删改查及分页入门项目实例.zip
07-16
这是一个基于Java技术栈的Web开发入门项目实例，主要利用IntelliJ IDEA作为集成开发环境，SpringBoot作为核心框架，Maven作为项目构建工具，JPA（Java Persistence API）作为持久层解决方案，以及Thymeleaf作为视...
IntelliJ IDEA 2021Maven+SpringBoot项目基本框架.7z
11-04
【标题】 IntelliJ IDEA 2021 Maven+SpringBoot项目基本框架 在现代Java开发中，IntelliJ IDEA是一款广泛使用的集成开发环境（IDE），它提供了丰富的功能和强大的工具，帮助开发者高效地构建应用程序。本资源是关于...
JPA（一）：JPA快速入门
Xuych的博客
08-01 675
一、JPA简介     JPA（Java Persistence API，中文名 java 持久化层 API）是 sum 公司制定的ORM框架的规范，是一组操作数据库的接口。Hibernate、TopLink（现已捐献给Eclipse社区，改名为EclipseLink）以及OpenJPA等ORM框架提供了JPA的实现。sum公司制定JPA ORM规范有两个原因：其一为了简化java对数据库的开发...
（一）JPA的快速入门
个人学习使用
09-21 1025
（一）JPA的快速入门
JPA框架：快速入门
大连赵哥的博客
01-05 520
JPA框架：快速入门
JPA学习笔记（2）——创建JPA项目
君君的专栏
08-13 9435
创建JPA项目1. 新建java工程其实也可以直接新建JPA工程，由于我这边创建JPA工程会有点问题，所以我创建java工程，效果是一样的。两者不同在于，JPA工程会帮我们创建jpa的配置文件，java工程则要我们手动创建如果是直接创建JPA工程，version请选择2.02.创建lib文件夹新建lib文件夹，加入jar包，并且添加到类路径下 3.新建配置文件在src下创建文件夹META-INF，
SpringData JPA 快速入门
爱码猿的博客
12-04 312
SpringData JPA 快速入门 SpringBoot 整合 SpringData-JPA 快速入门、 一 SpringBoot配置SpringData-JPA 1 引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependenc
SpringDataJPA快速入门
Java码农ing的博客
12-04 477
实现步骤 <dependencies> <!--jpa依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> </dependencies>
SpringData JPA快速入门
weixin_43859696的博客
11-06 210
SpringData Jpa快速入门SpringData JPA介绍SpringBoot整合SpringData JPA环境准备依赖引入完成springdata jpa的相关配置编写对应数据库的实体类创建Repository验证总结 SpringData JPA介绍 可以理解为JPA规范的再次封装抽象，底层还是使用了Hibernate的JPA技术实现，引用JPQL（Java Persistence Query Language）查询语言，属于Spring整个生态体系的一部分。随着Spring Boot和Sp
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

记录菌

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

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

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

打赏作者

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

抵扣说明：

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

余额充值