jpa 订阅
JPA是Java Persistence API的简称,中文名Java持久层API,是JDK 5.0注解或XML描述对象-关系表的映射关系,并将运行期的实体对象持久化到数据库中。 [1]  Sun引入新的JPA ORM规范出于两个原因:其一,简化现有Java EE和Java SE应用开发工作;其二,Sun希望整合ORM技术,实现天下归一。 展开全文
JPA是Java Persistence API的简称,中文名Java持久层API,是JDK 5.0注解或XML描述对象-关系表的映射关系,并将运行期的实体对象持久化到数据库中。 [1]  Sun引入新的JPA ORM规范出于两个原因:其一,简化现有Java EE和Java SE应用开发工作;其二,Sun希望整合ORM技术,实现天下归一。
信息
外文名
Java Persistence API
领    域
IT,编程
类    别
专业术语
中文名
Java 持久层 API
语    言
Java
JPA起源
JPA由EJB 3.0软件专家组开发,作为JSR-220实现的一部分。但它又不限于EJB 3.0,你可以在Web应用、甚至桌面应用中使用。JPA的宗旨是为POJO提供持久化标准规范,由此可见,经过这几年的实践探索,能够脱离容器独立运行,方便开发和测试的理念已经深入人心了。Hibernate3.2+、TopLink 10.1.3以及OpenJPA都提供了JPA的实现。JPA的总体思想和现有Hibernate、TopLink、JDO等ORM框架大体一致。总的来说,JPA包括以下3方面的技术:ORM映射元数据JPA支持XML和JDK5.0注解两种元数据的形式,元数据描述对象和表之间的映射关系,框架据此将实体对象持久化到数据库表中;API用来操作实体对象,执行CRUD操作,框架在后台替代我们完成所有的事情,开发者从繁琐的JDBC和SQL代码中解脱出来。查询语言这是持久化操作中很重要的一个方面,通过面向对象而非面向数据库的查询语言查询数据,避免程序的SQL语句紧密耦合。
收起全文
精华内容
下载资源
问答
  • 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 的主要实现有HibernateEclipseLink 和OpenJPA 等,这也意味着我们只要使用JPA 来开发,无论是哪一个开发方式都是一样的。

    内容

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

    JPA提供的技术:

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

    实体生命周期

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

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

    1. persist, 将新创建的或已删除的实体转变为Managed状态,数据存入数据库。
    2. remove,删除受控实体
    3. 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
    ClassTable@Entity@Table(name=“tablename”)
    propertycolumn@Column(name = “columnname”)
    propertyprimary key@Id@GeneratedValue 详见ID生成策略
    propertyNONE@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 => 构造条件 => 查询

    参考:

    展开全文
  • 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中有哪些关键字:

    KeywordSampleJPQL snippet
    AndfindByLastnameAndFirstname… where x.lastname = ?1 and
    OrfindByLastnameOrFirstname… where x.lastname = ?1 or x.firstname = ?2
    Is,EqualsfindByFirstnameIs,findByFirstnameEquals… where x.firstname = ?1
    BetweenfindByStartDateBetween… where x.startDate between ?1 and ?2
    LessThanfindByAgeLessThan… where x.age < ?1
    LessThanEqualfindByAgeLessThanEqual… where x.age ⇐ ?1
    GreaterThanfindByAgeGreaterThan… where x.age > ?1
    GreaterThanEqualfindByAgeGreaterThanEqual… where x.age >= ?1
    AfterfindByStartDateAfter… where x.startDate > ?1
    BeforefindByStartDateBefore… where x.startDate < ?1
    IsNullfindByAgeIsNull… where x.age is null
    IsNotNull,NotNullfindByAge(Is)NotNull… where x.age not null
    LikefindByFirstnameLike… where x.firstname like ?1
    NotLikefindByFirstnameNotLike… where x.firstname not like ?1
    StartingWithfindByFirstnameStartingWith… where x.firstname like ?1 (parameter bound with appended %)
    EndingWithfindByFirstnameEndingWith… where x.firstname like ?1 (parameter bound with prepended %)
    ContainingfindByFirstnameContaining… where x.firstname like ?1 (parameter bound wrapped in %)
    OrderByfindByAgeOrderByLastnameDesc… where x.age = ?1 order by x.lastname desc
    NotfindByLastnameNot… where x.lastname <> ?1
    InfindByAgeIn(Collection ages)… where x.age in ?1
    NotInfindByAgeNotIn(Collection age)… where x.age not in ?1
    TRUEfindByActiveTrue()… where x.active = true
    FALSEfindByActiveFalse()… where x.active = false
    IgnoreCasefindByFirstnameIgnoreCase… where UPPER(x.firstame) = UPPER(?1)
    ……

    以上就是jpa的简单实用和介绍。

    展开全文
  • JPA(一):十分钟入门 JPA

    万次阅读 多人点赞 2018-09-29 22:01:20
    一.JPA的概念 为了节省时间,更加具体的解释我们就略过吧。 二.在IDEA中使用JPA 2.1.添加JAP依赖 添加相关的maven依赖 &lt;properties&gt; &lt;project.build.sourceEncoding&gt;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思维导图

    展开全文
  • SpringDataJpaJpaRepository增删改查

    万次阅读 多人点赞 2017-11-17 08:32:19
    Jpa查询 1. JpaRepository简单查询 基本查询也分为两种,一种是spring data默认已经实现,一种是根据查询的方法来自动解析成SQL。 预先生成方法 spring data jpa 默认预先生成了一些基本的CURD的方法,例如...
  • 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 开发
  • Apache OpenJPA-自述文件 前言 感谢您下载此版本的Apache OpenJPA。 Apache OpenJPA是Java Persistence API规范的实现。 执照 此存储库的内容已根据Apache License 2.0 许可 更多信息 可以在openjpa-project子目录...
  • 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
  • 电子商务_JPA JPA专家课程
  • 包括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
  • jpa笔记

    万次阅读 2020-09-05 10:25:25
    继承JpaRepository接口(SpringDataJPA提供的简单数据操作接口) 继承JpaSpecificationExecutor接口 (SpringDataJPA提供的复杂查询接口) 【2】自定义sql ##@Query是用来配置自定义SQL的注解,后面参数nativeQuery...
  • 开机jpa Spring Boot整合JPA
  • 浅谈JPA优缺点

    万次阅读 2019-11-13 23:31:26
    一.JPA的理解 JPA的总体思想和现有hibernate、TopLink,JDO等ORM框架大体一致。总的来说,JPA包括以下3方面的技术: ORM映射元数据,JPA支持XML和JDK 5.0注解两种元数据的形式,元数据描述对象和表之间的映射关系...
  • JPA JAPJPA JAPJPA JAPJPA JAPJPA JAPJPA JAPJPA JAPJPA JAPJPA JAPJPA JAP
  • 弹簧数据JPA 弹簧数据-jpa
  • JPA教程:JPA概述、JPA实体生命周期、JPA实体映射关系、JPA查询语言
  • SpringBootJPA Spring Boot JPA WEB MYSQL
  • 这些示例正在使用实现JPA规范的Hibernate供应商。 - jpa-sample-01: + Simple examples of CRUD in JPA + Demo QUERY and TYPEDQUERY + Configuration of JPA using Hibernate Provider - jpa-sample-02: + ...
  • 项目:JPA:Java和JPA:Persista seus objetos com和JPA2 e Hibernate
  • 1、使用Specification+JPA不作封装的时候每次都要挨个判断属性,很是麻烦 以下对生成Specification做一个封装 /** * 生成全属性条件查询通用Specification * * @param tableMap 属性参数 * @param clazz 要查询...
  • JpaRepository:belajar menggunakan JPA存储库

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 162,624
精华内容 65,049
关键字:

jpa