三天快速入门Spring Data JPA之day01

最新推荐文章于 2024-08-25 21:18:14 发布
最新推荐文章于 2024-08-25 21:18:14 发布
阅读量328 收藏
点赞数
分类专栏： # spring data jpa 文章标签： jpa hibernate mysql java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xtho62/article/details/109187667
版权

文章目录


springdatajpa三天学习安排：
day1:orm思想和hibernate以及jpa的概述和jpa的基本操作
day2：springdatajpa的运行原理以及基本操作
day3：多表操作，复杂查询

第1章回顾JDBC

JDBC步骤：（连接前提导入驱动jar）
1.反射获取驱动
2.获得连接对象，get方法获取数据库连接（传参数=》数据库连接地址，用户名，密码）
3…创建Sql语句（利用占位符填充）
4.获取执行sql语句的对象Statement

1、执行静态SQL语句。通常通过Statement实例实现。
2、执行动态SQL语句。通常通过PreparedStatement实例实现。
3、执行数据库存储过程。通常通过CallableStatement实例实现。

5.执行SQL语句，接受返回结果

Statement接口提供了三种执行SQL语句的方法：
executeQuery 、executeUpdate和execute

6.处理结果（处理结果集）
7. 释放资源

具体实现可看如下博客：
https://blog.csdn.net/jungle_rao/article/details/81274720

写下来：操作繁琐，代码冗余，硬编码
后来抽取出DBUtils，代码冗余减少，但是依旧占位符以及硬编码
具体实现可看：
https://www.cnblogs.com/CQY1183344265/p/5854418.html

所以出现了ORM思想，对象关系映射(英语:(Object Relational Mapping）来解决以上的问题，具体实现大致为通过操控实体类和表的关系，实体类的属性和表的字段的关系形成一种关系完成映射。

典型代表Mybatis（ibatis）、Hibernate、Jpa
重点在于映射形成关联关系：无论是半自动的Mybatis还是全自动的Hibernate

第2章hibernate与JPA的概述

hibernate概述

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。性能比起Mybaits会差一点，擅长单表操作，多表相对复杂一点。

JPA概述

JPA的全称是Java Persistence API， 即Java 持久化API，是SUN公司推出的一套基于ORM的规范，内部是由一系列的接口和抽象类构成。

JPA通过JDK 5.0注解描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。

JPA的优势

  1. 标准化
    JPA 是 JCP 组织发布的 Java EE 标准之一，因此任何声称符合 JPA 标准的框架都遵循同样的架构，提供相同的访问API，这保证了基于JPA开发的企业应用能够经过少量的修改就能够在不同的JPA框架下运行。

  2. 容器级特性的支持
    JPA框架中支持大数据集、事务、并发等容器级事务，这使得 JPA 超越了简单持久化框架的局限，在企业应用发挥更大的作用。

  3. 简单方便
    JPA的主要目标之一就是提供更加简单的编程模型：在JPA框架下创建实体和创建Java 类一样简单，没有任何的约束和限制，只需要使用 javax.persistence.Entity进行注释，JPA的框架和接口也都非常简单，没有太多特别的规则和设计模式的要求，开发者可以很容易的掌握。JPA基于非侵入式原则设计，因此可以很容易的和其它框架或者容器集成

  4. 查询能力
    JPA的查询语言是面向对象而非面向数据库的，它以面向对象的自然语法构造查询语句，可以看成是Hibernate HQL的等价物。JPA定义了独特的JPQL（Java Persistence Query Language），JPQL是EJB QL的一种扩展，它是针对实体的一种查询语言，操作对象是实体，而不是关系数据库的表，而且能够支持批量更新和修改、JOIN、GROUP BY、HAVING 等通常只有 SQL 才能够提供的高级查询特性，甚至还能够支持子查询。

  5. 高级特性
    JPA 中能够支持面向对象的高级特性，如类之间的继承、多态和类之间的复杂关系，这样的支持能够让开发者最大限度的使用面向对象的模型设计企业应用，而不需要自行处理这些特性在关系数据库的持久化。

JPA与hibernate的关系

JPA规范本质上就是一种ORM规范，注意不是ORM框架——因为JPA并未提供ORM实现，它只是制订了一些规范，提供了一些编程的API接口，但具体实现则由服务厂商来提供实现。
在这里插入图片描述
JPA和Hibernate的关系就像JDBC和JDBC驱动的关系，JPA是规范，Hibernate除了作为ORM框架之外，它也是一种JPA实现。JPA怎么取代Hibernate呢？JDBC规范可以驱动底层数据库吗？答案是否定的，也就是说，如果使用JPA规范进行数据库操作，底层需要hibernate作为其实现类完成数据持久化工作，但并非只能使用hibernate。

第3章JPA的入门案例

案例实现步骤

1.数据库建库建表
2.建工程，可建maven工程导入坐标
3.需要配置jpa的核心配置文件

  • 位置：配置到类路径下的一个叫做 META-INF 的文件夹下
  • 命名：persistence.xml

4.编写实体类
5.配置实体类和表，类中属性和表中字段的映射关系
6.保存实体类对象到数据库中

环境准备

由于JPA是sun公司制定的API规范，所以我们不需要导入额外的JPA相关的jar包，只需要导入JPA的提供商的jar包。我们选择Hibernate作为JPA的提供商，所以需要导入Hibernate的相关jar包。

现在hibernate最新版本是5.8即大版本依旧是5版本：
所以我们可以使用5的任意版本的学习，我们以下为下载地址=》
https://sourceforge.net/projects/hibernate/files/hibernate-orm/5.0.7.Final/

在这里插入图片描述

所需导入jar包
在这里插入图片描述
1.在Mysql中建立一个jpa库用作本次学习的数据库，然后创建一个客户表
在这里插入图片描述
在这里插入图片描述
新建查询，执行以下sql脚本：

 /*创建客户表*/
    CREATE TABLE cst_customer (
      cust_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
      cust_name varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
      cust_source varchar(32) DEFAULT NULL COMMENT '客户信息来源',
      cust_industry varchar(32) DEFAULT NULL COMMENT '客户所属行业',
      cust_level varchar(32) DEFAULT NULL COMMENT '客户级别',
      cust_address varchar(128) DEFAULT NULL COMMENT '客户联系地址',
      cust_phone varchar(64) DEFAULT NULL COMMENT '客户联系电话',
      PRIMARY KEY (`cust_id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

在这里插入图片描述

2.创一个maven工程：new project=>maven然后直接next
在这里插入图片描述

使用maven工程导入坐标：锁定版本的pom依赖

<properties>
        <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>

         <!-- log日志 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <!-- Mysql and MariaDB -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
    </dependencies>

3.配置到类路径下(Maven工程默认是resources)的一个叫做 META-INF 的文件夹下,persistence.xml：
在这里插入图片描述
persistence.xml：（数据库名，url和密码改为自己的）

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
    http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd" version="2.0">
    <!--配置持久化单元
	persistence-unit name：持久化单元名称
		transaction-type：事务类型
		 	RESOURCE_LOCAL：本地事务管理
		 	JTA：分布式事务管理 -->
    <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
    <!--jpa的实现方式-->
    <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>

        <!--数据库信息-->
        <properties>
            <!-- 数据库驱动 -->
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
            <!-- 数据库地址 -->
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpa" />
            <!-- 数据库用户名 -->
            <property name="javax.persistence.jdbc.user" value="root" />
            <!-- 数据库密码 -->
            <property name="javax.persistence.jdbc.password" value="root3306" />
            <!--jpa提供者的可选配置：我们的JPA规范的提供者为hibernate，所以jpa的核心配置中兼容hibernate的配 -->
            <property name="hibernate.show_sql" value="true" />
            <property name="hibernate.format_sql" value="true" />
            <property name="hibernate.hbm2ddl.auto" value="create"/>
        </properties>

    <!--可选配置，配置jpa实现方式的配置信息-->

    </persistence-unit>
</persistence>

4.编写实体类
在这里插入图片描述

package com.tho.domain;

public class Customer {
    private Long custId;//客户主键
    private String custName;//客户名称
    private String custSource;//客户来源
    private String custIndustry;//客户所属行业
    private String custLevel;//客户级别
    private String custAddress;//客户地址
    private String custPhone;//客户电话

    public Long getCustId() {
        return custId;
    }
    public void setCustId(Long custId) {
        this.custId = custId;
    }
    public String getCustName() {
        return custName;
    }
    public void setCustName(String custName) {
        this.custName = custName;
    }
    public String getCustSource() {
        return custSource;
    }
    public void setCustSource(String custSource) {
        this.custSource = custSource;
    }
    public String getCustIndustry() {
        return custIndustry;
    }
    public void setCustIndustry(String custIndustry) {
        this.custIndustry = custIndustry;
    }
    public String getCustLevel() {
        return custLevel;
    }
    public void setCustLevel(String custLevel) {
        this.custLevel = custLevel;
    }
    public String getCustAddress() {
        return custAddress;
    }
    public void setCustAddress(String custAddress) {
        this.custAddress = custAddress;
    }
    public String getCustPhone() {
        return custPhone;
    }
    public void setCustPhone(String custPhone) {
        this.custPhone = custPhone;
    }
}

5.配置上实体类和表，类中属性和表中字段的映射关系

package com.tho.domain;
import javax.persistence.*;
/**
 *		* 所有的注解都是使用JPA的规范提供的注解，
 *		* 所以在导入注解包的时候，一定要导入javax.persistence下的
 */
@Entity //声明实体类
@Table(name="cst_customer") //建立实体类和表的映射关系
public class Customer {
    @Id//声明当前私有属性为主键
    @GeneratedValue(strategy= GenerationType.IDENTITY) //配置主键的生成策略
    @Column(name="cust_id") //指定和表中cust_id字段的映射关系
    private Long custId;

    @Column(name="cust_name") //指定和表中cust_name字段的映射关系
    private String custName;

    @Column(name="cust_source")//指定和表中cust_source字段的映射关系
    private String custSource;

    @Column(name="cust_industry")//指定和表中cust_industry字段的映射关系
    private String custIndustry;

    @Column(name="cust_level")//指定和表中cust_level字段的映射关系
    private String custLevel;

    @Column(name="cust_address")//指定和表中cust_address字段的映射关系
    private String custAddress;

    @Column(name="cust_phone")//指定和表中cust_phone字段的映射关系
    private String custPhone;

    public Long getCustId() {
        return custId;
    }
    public void setCustId(Long custId) {
        this.custId = custId;
    }
    public String getCustName() {
        return custName;
    }
    public void setCustName(String custName) {
        this.custName = custName;
    }
    public String getCustSource() {
        return custSource;
    }
    public void setCustSource(String custSource) {
        this.custSource = custSource;
    }
    public String getCustIndustry() {
        return custIndustry;
    }
    public void setCustIndustry(String custIndustry) {
        this.custIndustry = custIndustry;
    }
    public String getCustLevel() {
        return custLevel;
    }
    public void setCustLevel(String custLevel) {
        this.custLevel = custLevel;
    }
    public String getCustAddress() {
        return custAddress;
    }
    public void setCustAddress(String custAddress) {
        this.custAddress = custAddress;
    }
    public String getCustPhone() {
        return custPhone;
    }
    public void setCustPhone(String custPhone) {
        this.custPhone = custPhone;
    }
}

常用注解的说明

@Entity
作用：指定当前类是实体类。
@Table
作用：指定实体类和表之间的对应关系。
属性：
name：指定数据库表的名称
@Id
作用：指定当前字段是主键。
@GeneratedValue
作用：指定主键的生成方式。。
属性：
strategy ：指定主键生成策略。
@Column
作用：指定实体类属性和数据库表之间的对应关系
属性：
name：指定数据库表的列名称。
unique：是否唯一
nullable：是否可以为空
inserttable：是否可以插入
updateable：是否可以更新
columnDefinition: 定义建表时创建此列的DDL
secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字搭建开发环境[重点]

6.保存实体类对象到数据库中(使用单元测试，在实际开发中也应该先使用单元测试先，然后完成框架之间的整合)
在test根目录下创建com.tho.test包，再创建测试类JpaTest:

package com.tho.test;

import com.tho.domain.Customer;
import org.junit.Test;

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

public class JpaTest {
    /**
     * 测试jpa的保存：
     *      案例：保存一个客户到数据库中
     * Jpa操作的步骤：
     *      1.加载配置文件创建工厂（实体管理器工厂）对象
     *      2.通过实体管理器工厂获取实体管理器
     *      3.获取事务对象，开启事务
     *      4.完成增删改查操作
     *      5.提交事务（回滚事务）
     *      6.释放资源
     */
    @Test
    public void testSave(){
        // 1.加载配置文件创建工厂（实体管理器工厂）对象
        final EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
        // 2.通过实体管理器工厂获取实体管理器
        EntityManager em = factory.createEntityManager();
        // 3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();//开启事务
        // 4.完成增删改查操作，保存一个客户到我们的数据库里
        Customer customer = new Customer();
        customer.setCustName("calmtho");
        customer.setCustIndustry("IT");
        //保存操作
        em.persist(customer);
        // 5.提交事务（回滚事务）
        tx.commit();
        // 6.释放资源
        em.close();
        factory.close();
    }
}

debug看看：
在这里插入图片描述
在这里插入图片描述
入门案例成功，由于我们配置了create，所以会先删表再创表再插入，每次插入之前的数据都会没掉，可以试一下改成update:
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
显示sql ： false,true
自动创建数据库表： hibernate.hbm2ddl.auto
create :程序运行时创建表（如果有表，先删了再创建）
update : 程序运行时更新表（如果有表，不会创建表）
none : 不会创建表

第4章JPA中的主键生成策略

通过annotation（注解）来映射hibernate实体的,基于annotation的hibernate主键标识为@Id, 其生成规则由@GeneratedValue设定的.这里的@id和@GeneratedValue都是JPA的标准用法

JPA提供的四种标准用法为TABLE,SEQUENCE,IDENTITY,AUTO。

  1. IDENTITY:主键由数据库自动生成（主要是自动增长型）
 @Id  
 @GeneratedValue(strategy = GenerationType.IDENTITY) 
 private Long custId;
  1. SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列。
@Id  
@GeneratedValue(strategy=GenerationType.SEQUENCE,generator="payablemoney_seq")  
@SequenceGenerator(name="payablemoney_seq", sequenceName="seq_payment")  
private Long custId;

SEQUENCE源码

//@SequenceGenerator源码中的定义
    @Target({TYPE, METHOD, FIELD})   
    @Retention(RUNTIME)  
    public @interface SequenceGenerator {  
       //表示该表主键生成策略的名称，它被引用在@GeneratedValue中设置的“generator”值中
       String name();  
       //属性表示生成策略用到的数据库序列名称。
       String sequenceName() default "";  
       //表示主键初识值，默认为0
       int initialValue() default 0;  
       //表示每次主键值增加的大小，例如设置1，则表示每次插入新记录后自动加1，默认为50
       int allocationSize() default 50;  
    }
  1. AUTO：主键由程序控制（通过配置的数据库决定mysql就自增，oracle就序列化）
@Id  
@GeneratedValue(strategy = GenerationType.AUTO)  
private Long custId;
  1. TABLE：使用一个特定的数据库表格来保存主键
    如以下程序：
@Id  
@GeneratedValue(strategy = GenerationType.TABLE, generator="payablemoney_gen")  
@TableGenerator(name = "pk_gen",  
        table="tb_generator",  
        pkColumnName="gen_name",  
        valueColumnName="gen_value",  
        pkColumnValue="PAYABLEMOENY_PK",  
        allocationSize=1  
    ) 
private Long custId;


//@TableGenerator的定义：
    @Target({TYPE, METHOD, FIELD})   
    @Retention(RUNTIME)  
    public @interface TableGenerator {  
      //表示该表主键生成策略的名称，它被引用在@GeneratedValue中设置的“generator”值中
       String name();  
      //表示表生成策略所持久化的表名，例如，这里表使用的是数据库中的“tb_generator”。
      String table() default "";  
      //catalog和schema具体指定表所在的目录名或是数据库名
      String catalog() default "";  
      String schema() default "";  
      //属性的值表示在持久化表中，该主键生成策略所对应键值的名称。例如在“tb_generator”中将“gen_name”作为主键的键值
      String pkColumnName() default "";  
      //属性的值表示在持久化表中，该主键当前所生成的值，它的值将会随着每次创建累加。例如，在“tb_generator”中将“gen_value”作为主键的值 
      String valueColumnName() default "";  
      //属性的值表示在持久化表中，该生成策略所对应的主键。例如在“tb_generator”表中，将“gen_name”的值为“CUSTOMER_PK”。 
      String pkColumnValue() default "";  
      //表示主键初识值，默认为0。 
      int initialValue() default 0;  
      //表示每次主键值增加的大小，例如设置成1，则表示每次创建新记录后自动加1，默认为50。
      int allocationSize() default 50;  
      UniqueConstraint[] uniqueConstraints() default {};  
    } 

    //这里应用表tb_generator，定义为 ：
    CREATE TABLE  tb_generator (  
      id NUMBER NOT NULL,  
      gen_name VARCHAR2(255) NOT NULL,  
      gen_value NUMBER NOT NULL,  
      PRIMARY KEY(id)  
    )

由于我们使用的是Mysql，所以只能演示其中3种，而AUTO和IDENTITY相对Mysql来说是一样的，所以也不演示了，我们来演示以下TABLE的生成方式：
首先配置表：create，让JPA给我们生成表
然后主键策略配置为:TABLE
在这里插入图片描述
在这里插入图片描述debug运行：控制台生成的日志可看执行过程

Hibernate: 
    drop table if exists cst_customer
Hibernate: 
    drop table if exists hibernate_sequences
Hibernate: 
    create table cst_customer (
        cust_id bigint not null,
        cust_address varchar(255),
        cust_industry varchar(255),
        cust_level varchar(255),
        cust_name varchar(255),
        cust_phone varchar(255),
        cust_source varchar(255),
        primary key (cust_id)
    )
Hibernate: 
    create table hibernate_sequences (
        sequence_name varchar(255) not null,
        next_val bigint,
        primary key (sequence_name)
    )
Hibernate: 
    select
        tbl.next_val 
    from
        hibernate_sequences tbl 
    where
        tbl.sequence_name=? for update
            
Hibernate: 
    insert 
    into
        hibernate_sequences
        (sequence_name, next_val)  
    values
        (?,?)
Hibernate: 
    update
        hibernate_sequences 
    set
        next_val=?  
    where
        next_val=? 
        and sequence_name=?
Hibernate: 
    insert 
    into
        cst_customer
        (cust_address, cust_industry, cust_level, cust_name, cust_phone, cust_source, cust_id) 
    values
        (?, ?, ?, ?, ?, ?, ?)

在这里插入图片描述
在这里插入图片描述

第5章JPA的API介绍

    1.加载配置文件创建实体管理器工厂
		Persisitence：静态方法（根据持久化单元名称创建实体管理器工厂）
			createEntityMnagerFactory（持久化单元名称）
		作用：创建实体管理器工厂
		
  	2.根据实体管理器工厂，创建实体管理器
		EntityManagerFactory ：获取EntityManager对象
		方法：createEntityManager
		* 内部维护的很多的内容
			内部维护了数据库信息，
			维护了缓存信息
			维护了所有的实体管理器对象
			再创建EntityManagerFactory的过程中会根据配置创建数据库表
		* EntityManagerFactory的创建过程比较浪费资源
		特点：线程安全的对象
			多个线程访问同一个EntityManagerFactory不会有线程安全问题
		* 如何解决EntityManagerFactory的创建过程浪费资源（耗时）的问题？
		思路：创建一个公共的EntityManagerFactory的对象
		* 静态代码块的形式创建EntityManagerFactory
		
	3.创建事务对象，开启事务
		EntityManager对象：实体类管理器
			beginTransaction : 创建事务对象
			presist ： 保存
			merge  ： 更新
			remove ： 删除
			find/getRefrence ： 根据id查询
			
		Transaction 对象 ： 事务
			begin：开启事务
			commit：提交事务
			rollback：回滚

5.1Persistence对象

Persistence对象主要作用是用于获取EntityManagerFactory对象的 。通过调用该类的createEntityManagerFactory静态方法，根据配置文件中持久化单元名称创建EntityManagerFactory。

//1. 创建 EntitymanagerFactory
@Test
String unitName = "myJpa";
EntityManagerFactory factory= Persistence.createEntityManagerFactory(unitName);

5.2EntityManagerFactory

EntityManagerFactory 接口主要用来创建 EntityManager 实例

//创建实体管理类
EntityManager em = factory.createEntityManager();

由于EntityManagerFactory 是一个线程安全的对象（即多个线程访问同一个EntityManagerFactory 对象不会有线程安全问题)，并且EntityManagerFactory 的创建极其浪费资源，所以在使用JPA编程时，我们可以对EntityManagerFactory 的创建进行优化，只需要做到一个工程只存在一个EntityManagerFactory 即可

5.3EntityManager

在 JPA 规范中, EntityManager是完成持久化操作的核心对象。实体类作为普通 java对象，只有在调用 EntityManager将其持久化后才会变成持久化对象。EntityManager对象在一组实体类与底层数据源之间进行 O/R 映射的管理。它可以用来管理和更新 Entity Bean, 根椐主键查找 Entity Bean, 还可以通过JPQL语句查询实体。

我们可以通过调用EntityManager的方法完成获取事务，以及持久化数据库的操作

方法说明：

getTransaction : 获取事务对象
persist ： 保存操作
merge ： 更新操作
remove ： 删除操作
find/getReference ： 根据id查询

5.3EntityTransaction

在 JPA 规范中, EntityTransaction是完成事务操作的核心对象，对于EntityTransaction在我们的java代码中承接的功能比较简单

begin：开启事务
commit：提交事务
rollback：回滚事务

第6章抽取JPAUtil工具类实现增删改查

persist ： 保存
merge ： 更新
remove ： 删除
find/getRefrence ： 根据id查询

增加

在这里插入图片描述

package com.tho.utils;

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

/**
 * 解决实体管理器工厂的浪费资源和耗时问题
 *      通过静态代码块的形式，当程序第一次访问此工具类时，创建一个公共的实体管理器工厂对象
 *
 * 第一次访问getEntityManager方法,经过静态方法创建一个factory对象，再调用方法创建一个EntityManager对象
 * 第二次访问getEntityManager方法,直接通过一个已经创建好的factory对象，创建一个EntityManager对象
 */
public class JpaUtils {

    private static EntityManagerFactory factory;

    static {
        //1.加载配置文件，创建entityManagerFactory
        factory = Persistence.createEntityManagerFactory("myJpa");
    }

    public static EntityManager getEntityManager(){
        return  factory.createEntityManager();
    }
}

改造JpaTest测试：

package com.tho.test;

import com.tho.domain.Customer;
import com.tho.utils.JpaUtils;
import org.junit.Test;

import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;

public class JpaTest {
    /**
     * 测试jpa的保存：
     *      案例：保存一个客户到数据库中
     * Jpa操作的步骤：
     *      1.加载配置文件创建工厂（实体管理器工厂）对象
     *      2.通过实体管理器工厂获取实体管理器
     *      3.获取事务对象，开启事务
     *      4.完成增删改查操作
     *      5.提交事务（回滚事务）
     *      6.释放资源
     */
    @Test
    public void testSave(){
     /*   // 1.加载配置文件创建工厂（实体管理器工厂）对象
        final EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
        // 2.通过实体管理器工厂获取实体管理器
        EntityManager em = factory.createEntityManager();*/

        //使用工具类
        EntityManager em = JpaUtils.getEntityManager();

        // 3.获取事务对象，开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();//开启事务
        // 4.完成增删改查操作，保存一个客户到我们的数据库里
        Customer customer = new Customer();
        customer.setCustName("calmtho");
        customer.setCustIndustry("IT");
        customer.setCustPhone("13013013013");
        //保存操作
        em.persist(customer);
        // 5.提交事务（回滚事务）
        tx.commit();
        // 6.释放资源
        em.close();
        //改造后不关
        //factory.close();
    }
}

id改为自增策略，create方式生成表，运行测试。

在这里插入图片描述
在这里插入图片描述
tableid表还在，但实际并不依赖于table，只是因为没有映射关系，create并没有删出它，这不是这个案例重点，我专门多赋值了电话属性，就是为了做比较，显示我们的工具类使用成功。

根据id查

JpaTest加入下面代码，然后改为update方式：

	/**
     * 测试id查询功能
     */
    @Test
    public void testFind(){
        //通过工具类获取EntityManager对象
        EntityManager entityManager = JpaUtils.getEntityManager();
        //获取事务对象
        EntityTransaction transaction = entityManager.getTransaction();
        //开启事务
        transaction.begin();
        //查询操作
        Customer customer = entityManager.find(Customer.class, 1L);
        System.out.println(customer);
        //提交事务
        transaction.commit();
        //关闭资源
        entityManager.close();
    }

给Custom对象加入toString方法，debug运行：
在这里插入图片描述

延迟加载以及立即加载

JpaTest种，创建testReference，调用方法从find，改为getReference

	/**
     * 测试id查询功能
     */
    @Test
    public void testReference(){
        //通过工具类获取EntityManager对象
        EntityManager entityManager = JpaUtils.getEntityManager();
        //获取事务对象
        EntityTransaction transaction = entityManager.getTransaction();
        //开启事务
        transaction.begin();
        //查询操作
        Customer customer = entityManager.getReference(Customer.class, 1L);
        System.out.println(customer);
        //提交事务
        transaction.commit();
        //关闭资源
        entityManager.close();
    }

debug一下，看着结果和使用find很像！
在这里插入图片描述

debug打断点追踪：
find方法：

在这里插入图片描述在这里插入图片描述
是直接生成Customer对象

getReference方法：

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

debug一下，我们不难发现getReference生成的对象是一个动态代理对象,上面的图是其中几步。在getReference后并不会直接开启查询语句，并不是一个实际的Customer对象，而是在使用时才会真正去数据库查询。即使用getReference为延迟加载，也可称为懒加载。（特点为得到动态代理对象）

删除

删除用户前需要先查询到对象，才执行删除，这是面向对象的特征，而Mybatis则是可以where id=#{id}传入id进行删除。

	/**
     * 测试删除功能
     */
    @Test
    public void testDelete(){
        //通过工具类获取EntityManager对象
        EntityManager entityManager = JpaUtils.getEntityManager();
        //获取事务对象
        EntityTransaction transaction = entityManager.getTransaction();
        //开启事务
        transaction.begin();
        //先根据id查询，再删除
        Customer customer = entityManager.getReference(Customer.class, 1L);
        entityManager.remove(customer);
        //System.out.println(customer);
        //提交事务
        transaction.commit();
        //关闭资源
        entityManager.close();
    }

debug运行一下。
在这里插入图片描述
在这里插入图片描述

更新操作

由于还有更新操作，所以还是需要数据，可以运行至此的保存，可以手动建一条：
在这里插入图片描述
数据有了以后就开始写案例：

添加测试更新方法testUpdate()：

/**
     * 测试更新功能
     */
    @Test
    public void testUpdate(){
        //通过工具类获取EntityManager对象
        EntityManager entityManager = JpaUtils.getEntityManager();
        //获取事务对象
        EntityTransaction transaction = entityManager.getTransaction();
        //开启事务
        transaction.begin();
        //先根据id查询对象，给对象设置值，再更新
        Customer customer = entityManager.getReference(Customer.class, 1L);
        //给对象传值
        customer.setCustIndustry("IT");
        customer.setCustName("calm");
        customer.setCustPhone("12345");
        //使用实体管理类将对象更新
        entityManager.merge(customer);
        //System.out.println(customer);
        //提交事务
        transaction.commit();
        //关闭资源
        entityManager.close();
    }

在这里插入图片描述
在这里插入图片描述

第7章使用JPQL语句完成JPA的增删改查操作

jpql和sql的区别

sql：查询的是表和表中的字段
jpql：查询的是实体类和类中的属性

  • jpql和sql语句的语法相似,不同的是jpql是使用用面对对象的思想去操作，最大区别就是查询时候的区别。
接下来就通过jpql实现以下： 1.查询全部 2.分页查询 3.统计查询 4.条件查询
查询所有

先给数据库手动加多两条记录：
在这里插入图片描述
创JpqlTest类，上代码

package com.tho.test;

import com.tho.utils.JpaUtils;
import org.junit.Test;

import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import javax.persistence.Query;
import java.util.List;

/**
 *  jpql查询
 */
public class JpqlTest {
    /**
     *  查询全部：
     *      sql:    from com.tho.domain.Customer
     *      jpql:   select * from  cst_customer
     */
    @Test
    public void testFindAll(){
        //通过工具类获取EntityManager对象
        EntityManager em =JpaUtils.getEntityManager();
        //获取事务对象
        EntityTransaction tx = em.getTransaction();
        //开启事务
        tx.begin();
        //执行查询所有
        Query query = em.createQuery("from com.tho.domain.Customer");
        List list = query.getResultList();
        for (Object obj:list){
            System.out.println(obj);
        }
        //提交事务
        tx.commit();
        //关闭资源
        em.close();
    }
}

在这里插入图片描述
当然包名是可以省略的！！！直接from Customer也是可以的，前提是已经实体类和表已经做了映射。

排序查询

倒序查询所有：

 /**
     *  倒序查询全部：
     *      sql:   select * from  cst_customer order by cust_id desc
     *      jpql:    from com.tho.domain.Customer order by custId
     *
     */
    @Test
    public void testFindAllByDesc(){
        //通过工具类获取EntityManager对象
        EntityManager em =JpaUtils.getEntityManager();
        //获取事务对象
        EntityTransaction tx = em.getTransaction();
        //开启事务
        tx.begin();
        //执行查询所有
        String jpql="from com.tho.domain.Customer order by custId desc";
        Query query = em.createQuery(jpql);
        List list = query.getResultList();
        for (Object obj:list){
            System.out.println(obj);
        }
        //提交事务
        tx.commit();
        //关闭资源
        em.close();
    }

在这里插入图片描述

统计查询
/**
     *  统计查询：
     *      sql:   select count(cust_id) from  cst_customer order by cust_id desc
     *      jpql:  select count(custId)  from Customer
     *
     */
    @Test
    public void testcount(){
        //通过工具类获取EntityManager对象
        EntityManager em =JpaUtils.getEntityManager();
        //获取事务对象
        EntityTransaction tx = em.getTransaction();
        //开启事务
        tx.begin();
        //执行查询所有
        String jpql="select count(custId)  from Customer";
        Query query = em.createQuery(jpql);
        Object result = query.getSingleResult();
        System.out.println(result);
        //提交事务
        tx.commit();
        //关闭资源
        em.close();
    }

在这里插入图片描述

分页查询
/**
     *  分页查询：
     *      sql:   select * from cust_customer limit ?,?
     *      jpql:  form Customer
     *
     */
    @Test
    public void testPage(){
        //通过工具类获取EntityManager对象
        EntityManager em =JpaUtils.getEntityManager();
        //获取事务对象
        EntityTransaction tx = em.getTransaction();
        //开启事务
        tx.begin();
        //执行查询所有
        //i.根据jpql语句创建Query查询对象
        String jpql="from Customer";
        Query query = em.createQuery(jpql);
        //ii.参数赋值  --分页参数
        query.setFirstResult(0);
        query.setMaxResults(2);
        //iii.发送查询，并封装结果
        List list = query.getResultList();
        for (Object obj:list){
            System.out.println(obj);
        }
        //提交事务
        tx.commit();
        //关闭资源
        em.close();
    }

在这里插入图片描述

条件查询
 /**
     *  条件查询：查询名字为calmt开头的用户
     *      sql:   select * from cust_customer where cust_name like ?
     *      jpql:  from Customer where custName like ?
     *
     */
    @Test
    public void testLike(){
        //通过工具类获取EntityManager对象
        EntityManager em =JpaUtils.getEntityManager();
        //获取事务对象
        EntityTransaction tx = em.getTransaction();
        //开启事务
        tx.begin();
        //执行查询所有
        //i.根据jpql语句创建Query查询对象
        String jpql="from Customer where custName like ?";
        Query query = em.createQuery(jpql);
        //ii.参数赋值  --占位符参数
        query.setParameter(1,"calm%");
        //iii.发送查询，并封装结果
        /*
            getResultList封装成List
            getSingleResult：得到唯一结果集
         */
        List list = query.getResultList();
        for (Object obj:list){
            System.out.println(obj);
        }
        //提交事务
        tx.commit();
        //关闭资源
        em.close();
    }

在这里插入图片描述

撒花啦，第一天的学习已经学完啦！！加油噢。回顾一下jpa操作步骤：

获得EntityManager
通过EntityManager获得事务对象
事务对象开启事务
执行增删改查操作，一般先执行查询
如果不使用JPQL则用entityManager调用（persist，remove,merge,find/getRefrence）
而使用jpql创建query查询语句
看需求是否要给参数赋值，如占位符，分页参数等
发送查询，获取结果集getResultList/getSingleResult
根据类型处理，看看是否需要遍历
提交事务
捕获异常，回滚事务
关闭资源

上面案例演示遗忘了补抓异常，不过也不是主要的，补充个样例代码吧。

//统计查询
	@Test
	public void findCount() {
		EntityManager em = null;
		EntityTransaction tx = null;
		try {
			//获取实体管理对象
			em = JPAUtil.getEntityManager();
			//获取事务对象
			tx = em.getTransaction();
			tx.begin();
			// 查询全部客户
			// 1.创建query对象
			String jpql = "select count(custId) from Customer";
			Query query = em.createQuery(jpql);
			// 2.查询并得到返回结果
			Object count = query.getSingleResult(); // 得到集合返回类型
			System.out.println(count);
			tx.commit();
		} catch (Exception e) {
			// 回滚事务
			tx.rollback();
			e.printStackTrace();
		} finally {
			// 释放资源
			em.close();
		}
	}

感谢观看学习，本文综合多方资料，不一一细说，主要参考的还是某马的Spring Data Jpa以及自己的一部分总结整理。

calmtho
关注
专栏目录
spring-data-jpa快速入门
天青Azure的博客
08-05 210
最近通过源码的方式尝试去快速入门一个技术，虽然效率不快，但掌握的很牢固 一、JPA简介 JPA（Java Persistence API）java持久层api，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。Sun引入新的JPA ORM规范出于两个原因：其一，简化现有JavaEE和Java SE应用开发工作；其二，Sun希望整合ORM技术，实现天下归一。 二、spring data jpa的使用 2.1 安装 2.1.1 pom &l.
Day 04 -Spring Data JPA总结
hfghrth的博客
04-12 206
Spring data jpa ORM思想 ​ 主要目的： 操作实体类就相当于操作数据库表 ​ 建立两个映射关系： ​ 实体类和表的映射关系 ​ 实体类中属性和表中字段的映射关系 ​ 不在重点关注: sql语句 ​ 实现ORM框架： mybatis , hibernate JPA概述 ​ JPA的全称是Java Persistence API， 即Java 持久化API，是SUN公司推出的一套基于ORM的规范，内部是由一系列的接口和抽象类构成。 ​ JPA通过JDK 5.0注解描述对象－关系
SpringDataJPA - 1：快速入门
sunlibincn
08-08 110
以下内容均以localhost数据库sql_demo为例，表名：user_demo maven相关坐标 <properties> <spring.version>5.0.2.RELEASE</spring.version> <hibernate.version>5.0.7.Final</hibernate.version> <slf4j.version>1.6.6</slf
Spring Data JPA快速入门
a805814077的博客
02-24 719
Spring Data JPA入门，这一篇就够了
SpringData JPA快速入门
weixin_43859696的博客
11-06 282
SpringData Jpa快速入门SpringData JPA介绍SpringBoot整合SpringData JPA环境准备依赖引入完成springdata jpa的相关配置编写对应数据库的实体类创建Repository验证总结 SpringData JPA介绍 可以理解为JPA规范的再次封装抽象，底层还是使用了Hibernate的JPA技术实现，引用JPQL（Java Persistence Query Language）查询语言，属于Spring整个生态体系的一部分。随着Spring Boot和Sp
jpa 动态查询条件 数组_Spring data jpa 复杂动态查询方式总结
weixin_39716044的博客
12-22 1649
一.Spring data jpa 简介首先JPA是Java持久层API,由Sun公司开发,希望整合ORM技术，实现天下归一.诞生的缘由是为了整合第三方ORM框架，建立一种标准的方式，目前也是在按照这个方向发展，但是还没能完全实现。在ORM框架中，Hibernate是一支很大的部队，使用很广泛，也很方便，能力也很强，同时Hibernate也是和JPA整合的比较良好，我们可以认为JPA是标准，...
Spring data jpa oracle多条件查询和时间查询
shenxian1021的专栏
04-07 1696
自己菜是原罪，以前一直用php，对数据类型不太关心。现在刚开始学java，数据类型要求的极其严格，到处都是问题，难啊。 记录一下spring data jpa与oracle交互时，遇到的问题。 1、多条件查询，类似 select * from table where spid='1' and empno='110'; 直接上代码了： 定义一个getBySpidAndEmpno的方法，传进去两...
Spring Data JPA入门案例
平安
11-18 336
目录 1. Spring Data JPA介绍 2. Spring Data JPA与JPA规范，与hibernate的关系 3. 入门案例  3.1 创建工程导入依赖 3.2 配置spring和Spring Data JPA的配置文件 3.3 编写实体类和数据库表的映射关系 3.4 编写dao层接口 3.5 编写测试类 1. Spring Data JPA介绍        ...
jpa-day3-manytomany.zip
02-07
在这个“jpa-day3-manytomany.zip”压缩包中，我们很可能会找到一个关于如何在Spring Data JPA中处理多对多关系的示例或教程。下面，我们将深入探讨多对多关联的概念以及如何在实际应用中使用它。 首先，让我们理解...
SpringDataJPA--快速入门
qq_43404873的博客
12-07 153
Spring Data JPA 与 JPA和hibernate之间的关系 JPA是一套规范，内部是有接口和抽象类组成的。hibernate是一套成熟的ORM框架，而且Hibernate实现了JPA规范，所以也可以称hibernate为JPA的一种实现方式，我们使用JPA的API编程，意味着站在更高的角度上看待问题（面向接口编程） Spring Data JPA是Spring提供的一套对JPA操作更加高级的封装，是在JPA规范下的专门用来进行数据持久化的解决方案。 Spring Data JPA的快速入门
SpringDataJPA之快速入门
波波烤鸭的博客
05-18 2156
  Spring Data JPA：Spring Data JPA 是 spring data 项目下的一个模块。提供了一套基于 JPA标准操作数据库的简化方案。底层默认的是依赖 Hibernate JPA 来实现的。   Spring Data JPA 的技术特点：我们只需要定义接口并集成 Spring Data JPA 中所提供的接口就可以了。不需要编写接口实现类。 SpringDataJPA...
Spring Data JPA 极速入门
2401_84002371的博客
04-12 872
当Spring Data创建一个新的Repository实现时，它分析了所有由接口定义的方法，并试图从方法名称中自动生成查询。虽然这有一些局限性，但这是一种非常强大和优雅的方式，只需少量工作就可以定义新的自定义访问方法。我们可以看一个例子。如果实体有一个名字字段以及Java Bean标准的getter和setter方法，我们将在DAO接口中定义findByName方法。这将自动生成正确的查询：复制代码这是一个相对简单的例子。
Spring Data JPA 快速入门看这一篇就够了
java_leejin的博客
07-31 744
Spring Data JPA 是 Spring 基于 ORM 框架、JPA 规范的基础上封装的一套JPA应用框架，可使开发者用极简的代码即可实现对数据库的访问和操作。它提供了包括增删改查等在内的常用功能，且易于扩展！学习并使用 Spring Data JPA 可以极大提高开发效率！ Spring Data JPA 让我们解脱了DAO层的操作，基本上所有CRUD都可以依赖于它来实现,在实际的工作工...
最详细的Spring-data-jpa入门（一）
热门推荐
此成非彼诚博客
08-13 10万+
刚进公司，人生地不熟，偷偷藏着本《mybatis入土为安》，以为可以靠mybatis混的轻松点，谁知天有不测风云，大家用的是JPA。我这个小白没有听说过，全英文名叫，就是java持久化api，是SUN公司推出的一套基于的规范。持久化想必如雷贯耳，都0202年了，谁还不用个持久化框架啊，举起mybatis。ORM呢？全英文名为：对象关系映射，简单来说为了不用JDBC那一套原始方法来操作数据库，ORM框架横空出世（mybatis、hibernate等等）。...
spring boot(五)：spring data jpa的使用
weixin_33781606的博客
09-21 1464
在上篇文章springboot(二)：web综合开发中简单介绍了一下spring data jpa的基础性使用，这篇文章将更加全面的介绍spring data jpa 常见用法以及注意事项 使用spring data jpa 开发时，发现国内对spring boot jpa全面介绍的文章比较少案例也比较零碎，因此写文章总结一下。本人也正在翻译Spring Data JPA 参考指南,有兴趣的同学欢...
Spring Data Jpa系列教程（一）--------入门
一介那个书生的博客
03-09 3万+
大渣好，我是小小书生，现在开始，我们来学习船新的一门技术，SpringDataJpa,它是一个。。额。。（我百度一下）   JPA(Java Persistence API)是Sun官方提出的Java持久化规范。它为Java开发人员提供了一种对象/关联映射工具来管理Java应用中的关系数据。他的出现主要是为了简化现有的持久化开发工作和整合ORM技术，结束现在Hibernate，TopLink，...
【周一通勤电台】Spring Data JPA 极速入门
weixin_64922531的博客
01-04 216
Hello，大家好，这里是翊君@周一通勤电台频道。 0.阅读完本文你将会学会 如何在Spring项目中引入Spring Data JPA 本文一共约1800读时长大概等于一首黑眼豆豆的《Where Is The Love?》。 1. 概述 这篇文章将重点介绍如何在Spring项目中引入Spring Data JPA，并全面配置持久化层。 2.Spring Data生成的DAO–不再有DAO的实现 DAO层的设计中含有很多样板代码，它应该被简化。这种简化的好处有很多：减少我们需要定义和维护的组件数量；.
Web安全：SQL注入实战测试.（扫描 + 测试）
最新发布
网络安全领域___专研者.
08-25 1140
SQL注入就是 有些恶意用户在提交查询请求的过程中 将SQL语句插入到请求内容中，同时程序的本身对用户输入的内容过于相信，没有对用户插入的SQL语句进行任何的过滤，从而直接被SQL语句直接被服务端执行，导致数据库的原有信息泄露，篡改，甚至被删除等风险。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值