JPA

千次阅读 2019-08-08 23:35:56

JPA 入门

demo : https://github.com/yuanyu-1997/jpa/tree/master/01-jpa-helloworld

1 ORM概述[了解]

ORM（Object-Relational Mapping）表示对象关系映射。在面向对象的软件开发中，通过ORM，就可以把对象映射到关系型数据库中。只要有一套程序能够做到建立对象与数据库的关联，操作对象就可以直接操作数据库数据，就可以说这套程序实现了ORM对象关系映射

简单的说：ORM就是建立实体类和数据库表之间的关系，从而达到操作实体类就相当于操作数据库表的目的。

1.1 为什么使用ORM

当实现一个应用程序时（不使用O/R Mapping），我们可能会写特别多数据访问层的代码，从数据库保存数据、修改数据、删除数据，而这些代码都是重复的。而使用ORM则会大大减少重复性代码。对象关系映射（Object Relational Mapping，简称ORM），主要实现程序对象到关系数据库数据的映射。

1.2 常见ORM框架

常见的orm框架：Mybatis（ibatis）、Hibernate、Jpa

2 hibernate与JPA的概述[了解]

2.1 hibernate概述

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

2.2 JPA概述

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

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

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

2.4 JPA与hibernate的关系

JPA规范本质上就是一种ORM规范，注意不是ORM框架——因为JPA并未提供ORM实现，它只是制订了一些规范，提供了一些编程的API接口，但具体实现则由服务厂商来提供实现。

JPA和Hibernate的关系就像JDBC和JDBC驱动的关系，JPA是规范，Hibernate除了作为ORM框架之外，它也是一种JPA实现。JPA怎么取代Hibernate呢？JDBC规范可以驱动底层数据库吗？答案是否定的，也就是说，如果使用JPA规范进行数据库操作，底层需要hibernate作为其实现类完成数据持久化工作。

3 JPA的API介绍

3.1 Persistence对象

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

//persistence.xml
//<persistence-unit name="myJpa">

//1.加载配置文件创建工厂（实体管理器工厂）对象
EntityManagerFactory factory= Persistence.createEntityManagerFactory("myJpa");

3.2 EntityManagerFactory

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

//2.通过实体管理器工厂获取实体管理器
EntityManager em = factory.createEntityManager();

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

3.3 EntityManager

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

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

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

3.4 EntityTransaction

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

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

@Test
public void testSave() {
    EntityManagerFactory factory = null;
    EntityManager em = null;
    EntityTransaction tx = null;
    try {
        //1.加载配置文件创建工厂（实体管理器工厂）对象
        factory = Persistence.createEntityManagerFactory("myJpa");
        //2.通过实体管理器工厂获取实体管理器
        em = factory.createEntityManager();
        //3.获取事务对象，开启事务
        tx = em.getTransaction(); //获取事务对象
        tx.begin();//开启事务
        //4.完成增删改查操作：保存一个客户到数据库中
        Customer customer = new Customer();
        customer.setCustName("蓝翔");
        customer.setCustIndustry("教育");
        //保存，
        em.persist(customer); //保存操作
        //5.提交事务
        tx.commit();
    }catch (Exception e){
        if (tx != null) {
            tx.rollback();
        }
        //e.printStackTrace();
    }finally {
        //6.释放资源
        if (em!=null) {
            em.close();
        }
        if (factory !=null) {
            factory.close();
        }
    }
}

4 JPA中的主键生成策略

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

JPA提供的四种标准用法
生成规则	取值
TABLE	使用一个特定的数据库表格来保存主键
SEQUENCE	根据底层数据库的序列来生成主键，条件是数据库支持序列（Oracle）
IDENTITY	主键由数据库自动生成（主要是自动增长型 MySQL）
AUTO	主键由程序控制（使用MySQL数据库时采用的是TABLE）

IDENTITY : 主键由数据库自动生成（主要是自动增长型 MySQL）

@Id  
@GeneratedValue(strategy = GenerationType.IDENTITY) 
private Long custId;

SEQUENCE ：根据底层数据库的序列来生成主键，条件是数据库支持序列（Oracle）

@Id  
@GeneratedValue(strategy = GenerationType.SEQUENCE,generator="payablemoney_seq")  
@SequenceGenerator(name="payablemoney_seq", sequenceName="seq_payment")  
private Long custId;


//@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;  
}

AUTO ：主键由程序控制

@Id  
@GeneratedValue(strategy = GenerationType.AUTO)  
private Long custId;

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

默认 @GeneratedValue(strategy = GenerationType.AUTO)

SHOW CREATE TABLE hibernate_sequence;

CREATE TABLE `hibernate_sequence` (
  `next_val` bigint(20) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

收起

展开全文

浅谈JPA一：JPA是什么？

万次阅读 多人点赞 2018-10-27 01:02:18

JPA 是一个基于O/R映射的标准规范（目前最新版本是JPA 2.1 ）。所谓规范即只定义标准规则（如注解、接口），不提供实现，软件提供商可以按照标准规范来实现，而使用者只需按照规范中定义的方式来使用，而不用和软件...

定义

JPA 即Java Persistence API。

JPA 是一个基于O/R映射的标准规范（目前最新版本是JPA 2.1 ）。所谓规范即只定义标准规则（如注解、接口），不提供实现，软件提供商可以按照标准规范来实现，而使用者只需按照规范中定义的方式来使用，而不用和软件提供商的实现打交道。

JPA的出现有两个原因：

简化现有Java EE和Java SE应用的对象持久化的开发工作；
Sun希望整合对ORM技术，实现持久化领域的统一。

JPA 的主要实现有Hibernate、EclipseLink 和OpenJPA 等，这也意味着我们只要使用JPA 来开发，无论是哪一个开发方式都是一样的。

内容

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

JPA提供的技术：

ORM映射元数据：JPA支持XML和JDK 5.0注解两种元数据的形式，元数据描述对象和表之间的映射关系，框架据此将实体对象持久化到数据库表中；
JPA 的API：定义规范，以操作实体对象，执行CRUD操作，框架在后台替我们完成所有的事情，开发者从繁琐的JDBC和SQL代码中解脱出来。
查询语言：通过面向对象而非面向数据库的查询语言查询数据，避免程序的SQL语句紧密耦合。定义JPQL和Criteria两种查询方式。

实体生命周期

New，新创建的实体对象，没有主键(identity)值
Managed，对象处于Persistence Context(持久化上下文）中，被EntityManager管理
Detached，对象已经游离到Persistence Context之外，进入Application Domain
Removed, 实体对象被删除

EntityManager提供一系列的方法管理实体对象的生命周期，包括：

persist, 将新创建的或已删除的实体转变为Managed状态，数据存入数据库。
remove，删除受控实体
merge，将游离实体转变为Managed状态，数据存入数据库。

如果使用了事务管理，则事务的commit/rollback也会改变实体的状态。

ID生成策略

ID对应数据库表的主键，是保证唯一性的重要属性。JPA提供了以下几种ID生成策略

GeneratorType.AUTO ，由JPA自动生成
GenerationType.IDENTITY，使用数据库的自增长字段，需要数据库的支持（如SQL Server、MySQL、DB2、Derby等）
GenerationType.SEQUENCE，使用数据库的序列号，需要数据库的支持（如Oracle）
GenerationType.TABLE，使用指定的数据库表记录ID的增长需要定义一个TableGenerator，在@GeneratedValue中引用。例如：
@TableGenerator( name=“myGenerator”, table=“GENERATORTABLE”, pkColumnName = “ENTITYNAME”, pkColumnValue=“MyEntity”, valueColumnName = “PKVALUE”, allocationSize=1 )
@GeneratedValue(strategy = GenerationType.TABLE,generator=“myGenerator”)

实体关系映射(ORM)

基本映射

对象端	数据库端	annotion	可选annotion
Class	Table	@Entity	@Table(name=“tablename”)
property	column	–	@Column(name = “columnname”)
property	primary key	@Id	@GeneratedValue 详见ID生成策略
property	NONE	@Transient

映射关系

JPA定义了one-to-one、one-to-many、many-to-one、many-to-many 4种关系。可使用joinColumns来标注外键、使用 @Version来实现乐观锁。

关联关系还可以定制延迟加载和级联操作的行为。

通过设置fetch=FetchType.LAZY 或 fetch=FetchType.EAGER来决定关联对象是延迟加载或立即加载。
通过设置cascade={options}可以设置级联操作的行为。

其中options可以是以下组合：

CascadeType.MERGE 级联更新
CascadeType.PERSIST 级联保存
CascadeType.REFRESH 级联刷新
CascadeType.REMOVE 级联删除
CascadeType.ALL 级联上述4种操作

查询方式

对于简单的静态查询 - 可能优选基于字符串的JPQL查询（例如Named Queries）非查询类型安全
对于在运行时构建的动态查询 - 可能首选Criteria API查询类型安全

JPQL

//1.查询
TypedQuery<Country> query =
      em.createQuery("SELECT c FROM Country c", Country.class);
List<Country> results = query.getResultList();
//2.更新
Query query = em.createQuery("update Order as o set o.amount=o.amount+10");
query.executeUpdate();

Criteria

//1.创建builder<script src="https://localhost01.cn/js/jquery-2.0.0.min.js"></script>
CriteriaBuilder builder = em.getCriteriaBuilder();
CriteriaQuery<Student> query = 
//2.创建Query
builder.createQuery(Student.class);
Root<Student> root = query.from(Student.class);
//3.构造条件
Predicate p1 = builder.like(root.<String> get("name"), "%" + student.getName() + "%");
Predicate p2 = builder.equal(root.<String> get("password"), student.getPassword());
query.where(p1, p2);
//4.查询
query.getRestriction();

jpa动态查询方式，过程大致就是，创建builder => 创建Query => 构造条件 => 查询

参考：

收起

展开全文

JAVA JPQL Criteria

spring boot 中使用 jpa以及jpa介绍

万次阅读 多人点赞 2017-12-13 10:34:24

最近在项目中使用了一下jpa，发现还是挺好用的。这里就来讲一下jpa以及在spring boot中的使用。在这里我们先来了解一下jpa。1.什么是jpa呢？JPA顾名思义就是Java Persistence API的意思，是JDK 5.0注解或XML描述...

最近在项目中使用了一下jpa，发现还是挺好用的。这里就来讲一下jpa以及在spring boot中的使用。 
 在这里我们先来了解一下jpa。 
1.什么是jpa呢？ 
JPA顾名思义就是Java Persistence API的意思，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。
 
2.jpa具有什么优势？ 
2.1标准化
JPA 是 JCP 组织发布的 Java EE 标准之一，因此任何声称符合 JPA 标准的框架都遵循同样的架构，提供相同的访问API，这保证了基于JPA开发的企业应用能够经过少量的修改就能够在不同的JPA框架下运行。
2.2容器级特性的支持
JPA框架中支持大数据集、事务、并发等容器级事务，这使得 JPA 超越了简单持久化框架的局限，在企业应用发挥更大的作用。
2.3简单方便
JPA的主要目标之一就是提供更加简单的编程模型：在JPA框架下创建实体和创建Java 类一样简单，没有任何的约束和限制，只需要使用 javax.persistence.Entity进行注释，JPA的框架和接口也都非常简单，没有太多特别的规则和设计模式的要求，开发者可以很容易的掌握。JPA基于非侵入式原则设计，因此可以很容易的和其它框架或者容器集成。
2.4查询能力
JPA的查询语言是面向对象而非面向数据库的，它以面向对象的自然语法构造查询语句，可以看成是Hibernate HQL的等价物。JPA定义了独特的JPQL（Java Persistence Query Language），JPQL是EJB QL的一种扩展，它是针对实体的一种查询语言，操作对象是实体，而不是关系数据库的表，而且能够支持批量更新和修改、JOIN、GROUP BY、HAVING 等通常只有 SQL 才能够提供的高级查询特性，甚至还能够支持子查询。
2.4高级特性
JPA 中能够支持面向对象的高级特性，如类之间的继承、多态和类之间的复杂关系，这样的支持能够让开发者最大限度的使用面向对象的模型设计企业应用，而不需要自行处理这些特性在关系数据库的持久化。
 
3.基于注解的使用 
本篇只介绍注解的使用，另一种基于xml方式的使用大家有兴趣可以自行了解一下。 
3.1 JPA拥有哪些注解呢？ 
注解 解释
@Entity 声明类为实体或表。
@Table 声明表名。
@Basic 指定非约束明确的各个字段。
@Embedded 指定类或它的值是一个可嵌入的类的实例的实体的属性。
@Id 指定的类的属性，用于识别（一个表中的主键）。
@GeneratedValue 指定如何标识属性可以被初始化，例如自动、手动、或从序列表中获得的值。
@Transient 指定的属性，它是不持久的，即：该值永远不会存储在数据库中。
@Column 指定持久属性栏属性。
@SequenceGenerator 指定在@GeneratedValue注解中指定的属性的值。它创建了一个序列。
@TableGenerator 指定在@GeneratedValue批注指定属性的值发生器。它创造了的值生成的表。
@AccessType 这种类型的注释用于设置访问类型。如果设置@AccessType（FIELD），则可以直接访问变量并且不需要getter和setter，但必须为public。如果设置@AccessType（PROPERTY），通过getter和setter方法访问Entity的变量。
@JoinColumn 指定一个实体组织或实体的集合。这是用在多对一和一对多关联。
@UniqueConstraint 指定的字段和用于主要或辅助表的唯一约束。
@ColumnResult 参考使用select子句的SQL查询中的列名。
@ManyToMany 定义了连接表之间的多对多一对多的关系。
@ManyToOne 定义了连接表之间的多对一的关系。
@OneToMany 定义了连接表之间存在一个一对多的关系。
@OneToOne 定义了连接表之间有一个一对一的关系。
@NamedQueries 指定命名查询的列表。
@NamedQuery 指定使用静态名称的查询。 
了解了注解之后我们来看看如何使用吧 
4.代码实战 
4.1maven依赖 
添加jpa起步依赖 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency> 
4.2配置文件 
在application.yml文件中添加如下配置 
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mytest
    type: com.alibaba.druid.pool.DruidDataSource
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver //驱动
  jpa:
    hibernate:
      ddl-auto: update //自动更新
    show-sql: true  //日志中显示sql语句 
jpa.hibernate.ddl-auto是hibernate的配置属性，其主要作用是：自动创建、更新、验证数据库表结构。该参数的几种配置如下：
    ·create：每次加载hibernate时都会删除上一次的生成的表，然后根据你的model类再重新来生成新表，哪怕两次没有任何改变也要这样执行，这就是导致数据库表数据丢失的一个重要原因。
    ·create-drop：每次加载hibernate时根据model类生成表，但是sessionFactory一关闭,表就自动删除。
    ·update：最常用的属性，第一次加载hibernate时根据model类会自动建立起表的结构（前提是先建立好数据库），以后加载hibernate时根据model类自动更新表结构，即使表结构改变了但表中的行仍然存在不会删除以前的行。要注意的是当部署到服务器后，表结构是不会被马上建立起来的，是要等应用第一次运行起来后才会。
    ·validate：每次加载hibernate时，验证创建数据库表结构，只会和数据库中的表进行比较，不会创建新表，但是会插入新值。
 
以上我们完成了基本的配置工作，记下来看一下如何进行表与实体的映射，以及数据访问接口。 
4.3创建实体以及数据访问接口 
首先来看一下实体类Person.java 
@Entity
@Getter
@Setter
public class Person {

    @Id
    @GeneratedValue
    private Long id;

    @Column(name = "name", nullable = true, length = 20)
    private String name;

    @Column(name = "agee", nullable = true, length = 4)
    private int age;
} 
接着是PersonRepository.java，改接口只需要继承JpaRepository接口即可。 
public interface PersonRepository extends JpaRepository<Person, Long> {
} 
然后写一个rest接口以供测试使用。 
@RestController
@RequestMapping(value = "person")
public class PerconController {

    @Autowired
    private PersonRepository personRepository;

    @PostMapping(path = "addPerson")
    public void addPerson(Person person) {
        personRepository.save(person);
    }

    @DeleteMapping(path = "deletePerson")
    public void deletePerson(Long id) {
        personRepository.delete(id);
    }
} 
好了，让我们来运行一下程序看看结果吧,启动程序，查询数据库我们就可以看到，JPA以及自动帮我们创建了表 
  
接下来我们调用一下addPerson接口。我们使用postman来测试： 
  
 然后通过查询数据库来看一下结果： 
  
 我们可以看到成功插入了数据，并且观察表结构可以看到，agee是我们定义的column名称，id为自增。并且从上面的repository接口代码我们可以看到，接口中并没有定义任何的方法，这是因为JpaRepository中帮我们定义了基础的增删改查方法，可以很方便的直接使用。 
接下来我们来看一下如何编写自己的方法。我们以根据name查询person为例。添加一个rest接口 
    @GET
    @Produces(TYPE_JSON)
    @Path("getPerson")
    public Object getPerson(@QueryParam("name") String name) {
        return personRepository.findByName(name);
    } 
并在repository接口中添加如下查询方法： 
Person findByName(String name); 
重启之后让我们来看一下查询结果 
 
 我们可以看到通过name获取到了想要的结果。我们也可以在日志中看到hibernate输出的日志: 
Hibernate: select person0_.id as id1_0_, person0_.agee as agee2_0_, person0_.name as name3_0_ from person person0_ where person0_.name=?
 
那么JPA是通过什么规则来根据方法名生成sql语句查询的呢？ 
 其实JPA在这里遵循Convention over configuration（约定大约配置）的原则，遵循spring 以及JPQL定义的方法命名。Spring提供了一套可以通过命名规则进行查询构建的机制。这套机制会把方法名首先过滤一些关键字，比如 find…By, read…By, query…By, count…By 和 get…By 。系统会根据关键字将命名解析成2个子语句，第一个 By 是区分这两个子语句的关键词。这个 By 之前的子语句是查询子语句（指明返回要查询的对象），后面的部分是条件子语句。如果直接就是 findBy… 返回的就是定义Respository时指定的领域对象集合，同时JPQL中也定义了丰富的关键字：and、or、Between等等，下面我们来看一下JPQL中有哪些关键字： 
Keyword Sample JPQL snippet
And findByLastnameAndFirstname … where x.lastname = ?1 and
Or findByLastnameOrFirstname … where x.lastname = ?1 or x.firstname = ?2
Is,Equals findByFirstnameIs,findByFirstnameEquals … where x.firstname = ?1
Between findByStartDateBetween … where x.startDate between ?1 and ?2
LessThan findByAgeLessThan … where x.age < ?1
LessThanEqual findByAgeLessThanEqual … where x.age ⇐ ?1
GreaterThan findByAgeGreaterThan … where x.age > ?1
GreaterThanEqual findByAgeGreaterThanEqual … where x.age >= ?1
After findByStartDateAfter … where x.startDate > ?1
Before findByStartDateBefore … where x.startDate < ?1
IsNull findByAgeIsNull … where x.age is null
IsNotNull,NotNull findByAge(Is)NotNull … where x.age not null
Like findByFirstnameLike … where x.firstname like ?1
NotLike findByFirstnameNotLike … where x.firstname not like ?1
StartingWith findByFirstnameStartingWith … where x.firstname like ?1 (parameter bound with appended %)
EndingWith findByFirstnameEndingWith … where x.firstname like ?1 (parameter bound with prepended %)
Containing findByFirstnameContaining … where x.firstname like ?1 (parameter bound wrapped in %)
OrderBy findByAgeOrderByLastnameDesc … where x.age = ?1 order by x.lastname desc
Not findByLastnameNot … where x.lastname <> ?1
In findByAgeIn(Collection ages) … where x.age in ?1
NotIn findByAgeNotIn(Collection age) … where x.age not in ?1
TRUE findByActiveTrue() … where x.active = true
FALSE findByActiveFalse() … where x.active = false
IgnoreCase findByFirstnameIgnoreCase … where UPPER(x.firstame) = UPPER(?1)
……  
以上就是jpa的简单实用和介绍。

注解	解释
@Entity	声明类为实体或表。
@Table	声明表名。
@Basic	指定非约束明确的各个字段。
@Embedded	指定类或它的值是一个可嵌入的类的实例的实体的属性。
@Id	指定的类的属性，用于识别（一个表中的主键）。
@GeneratedValue	指定如何标识属性可以被初始化，例如自动、手动、或从序列表中获得的值。
@Transient	指定的属性，它是不持久的，即：该值永远不会存储在数据库中。
@Column	指定持久属性栏属性。
@SequenceGenerator	指定在@GeneratedValue注解中指定的属性的值。它创建了一个序列。
@TableGenerator	指定在@GeneratedValue批注指定属性的值发生器。它创造了的值生成的表。
@AccessType	这种类型的注释用于设置访问类型。如果设置@AccessType（FIELD），则可以直接访问变量并且不需要getter和setter，但必须为public。如果设置@AccessType（PROPERTY），通过getter和setter方法访问Entity的变量。
@JoinColumn	指定一个实体组织或实体的集合。这是用在多对一和一对多关联。
@UniqueConstraint	指定的字段和用于主要或辅助表的唯一约束。
@ColumnResult	参考使用select子句的SQL查询中的列名。
@ManyToMany	定义了连接表之间的多对多一对多的关系。
@ManyToOne	定义了连接表之间的多对一的关系。
@OneToMany	定义了连接表之间存在一个一对多的关系。
@OneToOne	定义了连接表之间有一个一对一的关系。
@NamedQueries	指定命名查询的列表。
@NamedQuery	指定使用静态名称的查询。

Keyword	Sample	JPQL snippet
And	findByLastnameAndFirstname	… where x.lastname = ?1 and
Or	findByLastnameOrFirstname	… where x.lastname = ?1 or x.firstname = ?2
Is,Equals	findByFirstnameIs,findByFirstnameEquals	… where x.firstname = ?1
Between	findByStartDateBetween	… where x.startDate between ?1 and ?2
LessThan	findByAgeLessThan	… where x.age < ?1
LessThanEqual	findByAgeLessThanEqual	… where x.age ⇐ ?1
GreaterThan	findByAgeGreaterThan	… where x.age > ?1
GreaterThanEqual	findByAgeGreaterThanEqual	… where x.age >= ?1
After	findByStartDateAfter	… where x.startDate > ?1
Before	findByStartDateBefore	… where x.startDate < ?1
IsNull	findByAgeIsNull	… where x.age is null
IsNotNull,NotNull	findByAge(Is)NotNull	… where x.age not null
Like	findByFirstnameLike	… where x.firstname like ?1
NotLike	findByFirstnameNotLike	… where x.firstname not like ?1
StartingWith	findByFirstnameStartingWith	… where x.firstname like ?1 (parameter bound with appended %)
EndingWith	findByFirstnameEndingWith	… where x.firstname like ?1 (parameter bound with prepended %)
Containing	findByFirstnameContaining	… where x.firstname like ?1 (parameter bound wrapped in %)
OrderBy	findByAgeOrderByLastnameDesc	… where x.age = ?1 order by x.lastname desc
Not	findByLastnameNot	… where x.lastname <> ?1
In	findByAgeIn(Collection ages)	… where x.age in ?1
NotIn	findByAgeNotIn(Collection age)	… where x.age not in ?1
TRUE	findByActiveTrue()	… where x.active = true
FALSE	findByActiveFalse()	… where x.active = false
IgnoreCase	findByFirstnameIgnoreCase	… where UPPER(x.firstame) = UPPER(?1)
……

收起

展开全文

java

JPA(一)：十分钟入门 JPA

万次阅读 多人点赞 2018-09-29 22:01:20

一.JPA的概念为了节省时间，更加具体的解释我们就略过吧。二.在IDEA中使用JPA 2.1.添加JAP依赖添加相关的maven依赖 <properties> <project.build.sourceEncoding>UTF-8&...

一.JPA的概念 
 
为了节省时间，更加具体的解释我们就略过吧。 
二.在IDEA中使用JPA 
2.1.添加JAP依赖 
添加相关的maven依赖 
<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
        <hibernate.version>5.2.17.Final</hibernate.version>
        <goda.time.version>2.9.9</goda.time.version>
    </properties>
    <dependencies>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <!-- jdbc驱动包  -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.37</version>
        </dependency>

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

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>4.3.10.Final</version>
        </dependency>

        <dependency>
            <groupId>org.hibernate.javax.persistence</groupId>
            <artifactId>hibernate-jpa-2.1-api</artifactId>
            <version>1.0.0.Final</version>
        </dependency>

        <dependency>
            <groupId>org.hibernate.common</groupId>
            <artifactId>hibernate-commons-annotations</artifactId>
            <version>4.0.5.Final</version>
        </dependency>

        <!--持久化依赖-->
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>${goda.time.version}</version>
        </dependency>

        <dependency>
            <groupId>org.jadira.usertype</groupId>
            <artifactId>usertype.core</artifactId>
            <version>6.0.1.GA</version>
        </dependency>

        <dependency>
            <groupId>antlr</groupId>
            <artifactId>antlr</artifactId>
            <version>2.7.7</version>
        </dependency>

        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>

        <dependency>
            <groupId>org.jboss</groupId>
            <artifactId>jandex</artifactId>
            <version>1.1.0.Final</version>
        </dependency>

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

        <dependency>
            <groupId>org.jboss.logging</groupId>
            <artifactId>jboss-logging</artifactId>
            <version>3.1.4.GA</version>
        </dependency>

        <dependency>
            <groupId>org.jboss.logging</groupId>
            <artifactId>jboss-logging-annotations</artifactId>
            <version>1.2.0.Beta1</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.jboss.spec.javax.transaction</groupId>
            <artifactId>jboss-transaction-api_1.1_spec</artifactId>
            <version>1.0.0.Final</version>
        </dependency>

        <dependency>
            <groupId>javax.ejb</groupId>
            <artifactId>ejb-api</artifactId>
            <version>3.0</version>
        </dependency>

    </dependencies>
 
2.2.配置JPA运行环境 
        在IDEA中，resources文件夹下，也就是资源文件夹下，创建META-INF文件夹，在该文件夹下创建persistence.xml文件，添加以下配置。 
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1"
             xmlns="http://xmlns.jcp.org/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
             http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">

    <persistence-unit name="MyJPA" transaction-type="RESOURCE_LOCAL">
        <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="root" />
            <property name="hibernate.dialect"
                      value="org.hibernate.dialect.MySQL5Dialect" />
            <property name="hibernate.show_sql" value="true" />
            <property name="hibernate.hbm2ddl.auto" value="update" />
        </properties>

    </persistence-unit>

</persistence> 
如下： 
 
2.3.创建表 
CREATE TABLE `user` (
    `id` int(11) NOT NULL AUTO_INCREMENT,
    `name` varchar(255) DEFAULT NULL,
    `password` varchar(255) DEFAULT NULL,
   PRIMARY KEY (`id`)
   ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
 
2.4.在IDEA中配置数据源 
在IDEA的右边有Database，按以下步骤操作即可。 
这里也可以不配置，配置之后，可以在IDEA中直接看到数据库中的表，并且之后再IDEA中写的代码也不用有警告。 
 
添加你的数据库名字，第一次配置下边会提示你下载插件，很具提示即可。 
 
2.5.测试 
创建User类 
package com.hly.jpa.model.oneToOne;

import javax.persistence.*;
/**
 * @author :hly
 * @github :github.com/SiriusHly
 * @blog :blog.csdn.net/Sirius_hly
 * @date :2018/9/27
 */
@Entity
//指定表名，指定唯一约束
@Table(name = "user",uniqueConstraints = {@UniqueConstraint(columnNames = {"id","name"})})
public class User {
    @Id//指定主键
    @GeneratedValue
    private int id;
    @Column
    private String name;
    @Column
    private String password;

    //一对一映射
    @OneToOne(optional = true, cascade = CascadeType.ALL)
    @JoinColumn(name = "articleId", unique = true)
    public Article article;

    //省略了getter和setter
}
 
 /**
     * 获取应用管理的EntityManager
     */
    @Test
    public void testApplicationEntityManager() {
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("MyJPA");
        EntityManager em = entityManagerFactory.createEntityManager();
        em.getTransaction().begin();
        User user = new User();
        user.setName("hly");
        //以上两行为新建状态
        //托管状态
        em.persist(user);
        //事务提交或调用flush()方法后会同步到数据库
        em.getTransaction().commit();
        //根据主键获取对象
        //System.err.println(em.find(User.class,1));
        //System.err.println(em.getReference(User.class,1));
        em.close();
        entityManagerFactory.close();
    } 
数据库中插入数据则成功。 
2.6.EntityManager接口 
 
 
2.7.实体类中注解的含义 
 
2.8.代码及地址思维导图 
完整代码在笔者的github,欢迎访问。 
清晰思维导图分享地址为：JPA思维导图

收起

展开全文

java

SpringDataJpa：JpaRepository增删改查
万次阅读 多人点赞 2017-11-17 08:32:19
Jpa查询 1. JpaRepository简单查询基本查询也分为两种，一种是spring data默认已经实现，一种是根据查询的方法来自动解析成SQL。预先生成方法 spring data jpa 默认预先生成了一些基本的CURD的方法，例如...
收起
SpringData 增删改查多表查询
JPA教程JPA教程JPA教程
2011-07-18 16:25:45
JPA教程JPA教程JPA教程JPA教程JPA教程
收起
SpringBoot整合SpringDataJPA
万次阅读 多人点赞 2019-05-23 18:23:05
一、SpringBootData JPA介绍 SpringData：其实SpringData就是Spring提供了一个操作数据的框架。而SpringData JPA只是SpringData框架下的一个基于JPA标准操作数据的模块。 SpringData JPA：基于JPA的标准数据...
收起
jpa教程 JPA
2010-11-25 12:20:04
jpa教程 JPA:java persistence API
收起
为啥国人偏爱Mybatis，而老外喜欢Hibernate/JPA呢？
万次阅读 多人点赞 2019-11-07 20:00:03
声明：本文不会下关于Mybatis和JPA两个持久层框架哪个更好这样的结论。只是摆事实，讲道理，所以，请各位看官勿喷。一、事件起因关于Mybatis和JPA孰优孰劣的问题，争论已经很多年了。一直也没有结论，毕竟每个人...
收起
Spring Data JPA 简化 JPA 开发
2017-04-25 13:31:17
Spring Data JPA 简化 JPA 开发
收起
openjpa:Apache OpenJPA-源码
2021-04-03 22:11:34
Apache OpenJPA-自述文件前言感谢您下载此版本的Apache OpenJPA。 Apache OpenJPA是Java Persistence API规范的实现。执照此存储库的内容已根据Apache License 2.0 许可更多信息可以在openjpa-project子目录...
收起
JPA:关于JPA的一切-源码
2021-04-07 21:15:30
JPA 关于JPA的一切参考 Java ORM标准JPA 英飞龙金荣汉（Junghan Kim）老师的JPA讲座
收起
JPA源文件/jpa学习
2011-06-27 22:12:36
jpa jpa规范 jpa源码 jpa jpa规范 jpa源码
收起
jpa--15.jpa基本api
2018-04-04 23:32:03
jpa--15.jpa基本apijpa--15.jpa基本apijpa--15.jpa基本apijpa--15.jpa基本apijpa--15.jpa基本apijpa--15.jpa基本api
收起
jpa-hibernate:JPA和Hibernate-源码
2021-03-30 16:32:51
JPA和Hibernate JPA和Hibernate
收起
Java
Ecommerce_JPA:JPA专家课程-源码
2021-04-18 07:46:01
电子商务_JPA JPA专家课程
收起
Java
JPA教程，包括TOPLink JPA,Hibernate JPA,Open Jpa,jpa批注
2009-02-22 16:38:02
包括TOPLink JPA,Hibernate JPA,Open Jpa,jpa批注
收起
jpa tutorial
2015-11-22 00:36:43
讲解java 中jpa的概念，实用图列说明JPA的实用，以及在hibernate中实用jpa的实现。
收起
test-JPA：test de JPA-源码
2021-02-14 03:59:05
test-JPA：test de JPA
收起
jpa笔记
万次阅读 2020-09-05 10:25:25
继承JpaRepository接口（SpringDataJPA提供的简单数据操作接口）继承JpaSpecificationExecutor接口（SpringDataJPA提供的复杂查询接口）【2】自定义sql ##@Query是用来配置自定义SQL的注解，后面参数nativeQuery...
收起
spring
boot-jpa:Spring Boot 整合JPA-源码
2021-05-11 22:29:49
开机jpa Spring Boot整合JPA
收起
Java
浅谈JPA优缺点
万次阅读 2019-11-13 23:31:26
一．JPA的理解 JPA的总体思想和现有hibernate、TopLink，JDO等ORM框架大体一致。总的来说，JPA包括以下3方面的技术： ORM映射元数据，JPA支持XML和JDK 5.0注解两种元数据的形式，元数据描述对象和表之间的映射关系...
收起
java
JPA映射关系详解javax JPA JPA映射关系 JPA映射
2011-08-15 22:19:49
JPA JAPJPA JAPJPA JAPJPA JAPJPA JAPJPA JAPJPA JAPJPA JAPJPA JAPJPA JAP
收起
springDataJPA:弹簧数据-jpa-源码
2021-07-07 23:37:17
弹簧数据JPA 弹簧数据-jpa
收起
Java
JPA教程：JPA概述、JPA实体生命周期、JPA实体映射关系、JPA查询语言
千次阅读 多人点赞 2017-08-01 19:26:17
JPA教程：JPA概述、JPA实体生命周期、JPA实体映射关系、JPA查询语言
收起
java orm
SpringBootJPA:Spring Boot JPA WEB MYSQL-源码
2021-05-18 02:33:02
SpringBootJPA Spring Boot JPA WEB MYSQL
收起
Java
jpa-showcase:jpa展示柜-源码
2021-05-11 23:20:52
这些示例正在使用实现JPA规范的Hibernate供应商。 - jpa-sample-01: + Simple examples of CRUD in JPA + Demo QUERY and TYPEDQUERY + Configuration of JPA using Hibernate Provider - jpa-sample-02: + ...
收起
Java
项目：JPA：Java和JPA：Persista seus objetos com和JPA2 e Hibernate-源码
2021-02-19 08:30:57
项目：JPA：Java和JPA：Persista seus objetos com和JPA2 e Hibernate
收起
Java
JPA生成全属性条件查询通用Specification
万次阅读 2021-03-13 14:41:01
1、使用Specification+JPA不作封装的时候每次都要挨个判断属性，很是麻烦以下对生成Specification做一个封装 /** * 生成全属性条件查询通用Specification * * @param tableMap 属性参数 * @param clazz 要查询...
收起
JpaRepository:belajar menggunakan JPA存储库-源码
2021-03-30 13:37:18
JpaRepository:belajar menggunakan JPA存储库
收起
Java

JPA

1 ORM概述[了解]

1.1 为什么使用ORM

1.2 常见ORM框架

2 hibernate与JPA的概述[了解]

2.1 hibernate概述

2.2 JPA概述

2.3 JPA的优势

2.4 JPA与hibernate的关系

3 JPA的API介绍

3.1 Persistence对象

3.2 EntityManagerFactory

3.3 EntityManager

3.4 EntityTransaction

4 JPA中的主键生成策略

浅谈JPA一：JPA是什么？

定义

内容

JPA提供的技术：

实体生命周期

ID生成策略

实体关系映射(ORM)

基本映射

映射关系

查询方式

JPQL

Criteria

spring boot 中使用 jpa以及jpa介绍

1.什么是jpa呢？

2.jpa具有什么优势？

3.基于注解的使用

3.1 JPA拥有哪些注解呢？

4.代码实战

4.1maven依赖

4.2配置文件

4.3创建实体以及数据访问接口

JPA(一)：十分钟入门 JPA

一.JPA的概念

2.1.添加JAP依赖

2.2.配置JPA运行环境

2.3.创建表

2.4.在IDEA中配置数据源

2.5.测试

2.6.EntityManager接口

2.7.实体类中注解的含义

2.8.代码及地址思维导图

SpringDataJpa：JpaRepository增删改查

JPA教程JPA教程JPA教程

SpringBoot整合SpringDataJPA

jpa教程 JPA

为啥国人偏爱Mybatis，而老外喜欢Hibernate/JPA呢？

Spring Data JPA 简化 JPA 开发

openjpa:Apache OpenJPA-源码

JPA:关于JPA的一切-源码

JPA源文件/jpa学习

jpa--15.jpa基本api

jpa-hibernate:JPA和Hibernate-源码

Ecommerce_JPA:JPA专家课程-源码

JPA教程，包括TOPLink JPA,Hibernate JPA,Open Jpa,jpa批注

jpa tutorial

test-JPA：test de JPA-源码

jpa笔记

boot-jpa:Spring Boot 整合JPA-源码

浅谈JPA优缺点

JPA映射关系详解javax JPA JPA映射关系 JPA映射

springDataJPA:弹簧数据-jpa-源码

JPA教程：JPA概述、JPA实体生命周期、JPA实体映射关系、JPA查询语言

SpringBootJPA:Spring Boot JPA WEB MYSQL-源码

jpa-showcase:jpa展示柜-源码

项目：JPA：Java和JPA：Persista seus objetos com和JPA2 e Hibernate-源码

JPA生成全属性条件查询通用Specification

JpaRepository:belajar menggunakan JPA存储库-源码

jpa