JPA简介与实战

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/noaman_wgs/article/details/78937452

一、什么是JPA

JPA:Java Persistence API,Java持久层API。是JDK 5.0注解或XML描述对象-关系表的映射关系,并将运行期的实体对象持久化到数据库中。

类似于JDBC,JPA是一组规范(接口),使应用程序以统一方式访问持久层。

  • 具体的实现: Hibernate
  • Toplink
  • 其他ORM框架

Alt text

JPA和Hibernate的关系
JPA 是规范: JPA 本质上就是一种 ORM 规范,不是ORM 框架 —— 因为 JPA 并未提供 ORM 实现,它只是制订了一些规范,提供了一些编程的 API 接口,但具体实现则由 ORM 厂商提供实现;
Hibernate 是实现: Hibernate 除了作为 ORM 框架之外,它也是一种 JPA 实现

JPA优势

  • 标准化:提供相同的 API,这保证了基于JPA 开发的企业应用能够经过少量的修改就能够在不同的 JPA 框架下运行;
  • 简单易用,集成方便:JPA 的主要目标之一就是提供更加简单的编程模型,在 JPA 框架下创建实体和创建 Java 类一样简单,只需要使用 javax.persistence.Entity 进行注释;JPA 的框架和接口也都非常简单;
  • 可媲美JDBC的查询能力:JPA的查询语言是面向对象的,JPA定义了独特的JPQL,而且能够支持批量更新和修改、JOIN、GROUP BY、HAVING 等通常只有 SQL 才能够提供的高级查询特性,甚至还能够支持子查询;
  • 支持面向对象的高级特性:JPA 中能够支持面向对象的高级特性,如类之间的继承、多态和类之间的复杂关系,最大限度的使用面向对象的模型。

二、JPA

1 JPA常用注解

JPA常用的注解有:

  • @Entity
  • @Basic
  • @Table
  • @Id
  • @GeneratedValue
  • @Column
  • @Transient
  • @Temporal

下面看看这些注解的具体含义。

(1)@Entity
Entity 标注用于实体类声明语句之前,指出该Java 类为实体类,将映射到指定的数据库表。如声明一个实体类 Student,它将映射到数据库中的 student表上。
如:

@Entity
public class Student {
    private int id;
    private String name;
    private int age;
     ....
 }

则Student类在数据库中会对应一个数据表:student。

(2)@Table
当实体类与其映射的数据库表名不同名时需要使用 @Table 标注说明,该标注与 @Entity 标注并列使用,置于实体类声明语句之前,可写于单独语句行,也可与声明语句同行。

  • @Table 标注的常用选项是 name,用于指明数据库的表名
  • @Table标注还有一个两个选项 catalog 和 schema 用于设置表所属的数据库目录或模式,通常为数据库名。
  • uniqueConstraints 选项用于设置约束条件,通常不须设置。
    如Student类映射数据库中的student_table表时,名字不同:
@Table(name = "student_table")
@Entity
public class Student {
    private int id;
    private String name;
    private int age;
     ....
 }

(3)@Id
@Id :用于声明一个实体类的属性映射为数据库的主键列。可置于属性的getter方法之前。
如下:属性id被设置为数据表中主键。

@Id
public int getId() {
   return id;
}

(4)@GeneratedValue
@GeneratedValue:设置主键的生成策略。
有如下策略:

  • IDENTITY:自增;
  • AUTO:JPA默认选择策略;
  • SEQUENCE:通过序列产生主键,通过 @SequenceGenerator 注解指定序列名,MySql 不支持这种方式;
  • TABLE:通过表产生主键,框架借由表模拟序列产生主键,使用该策略可以使应用更易于数据库移植。

MySQL常用自增:IDENTITY.

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public int getId() {
        return id;
    }

(5)@@Basic
@Basic:表示一个简单的属性到数据库表的字段的映射,对于没有任何标注的 getXxxx() 方法,默认即为@Basic。

(6)@Column
@Column:当实体的属性与其映射的数据库表的列不同名时需要使用@Column 标注说明。
常用属性:name,unique 、nullable、length 等。

(7)@Transient
@Transient:表示该属性并非一个到数据库表的字段的映射,ORM框架将忽略该属性;

(8)@Temporal
@Temporal:在核心的 Java API 中并没有定义 Date 类型的精度(temporal precision). 而在数据库中,表示 Date 类型的数据有 DATE, TIME, 和 TIMESTAMP 三种精度(即单纯的日期,时间,或者两者 兼备). 在进行属性映射时可使用@Temporal注解来调整精度。

2 JPA常用API

JPA中用于创建实体管理器的相关API:

  • Persistence类;
  • EntityManagerFactory类;
  • EntityManager类;
  • EntityTransaction类。

JPA中用于CRUD的相关API:

  • EntityManager.find();
  • EntityManager.getReference();
  • EntityManager.persist();
  • EntityManager.remove();

下面来看看具体的用法。
在应用执行CRUD前后需要执行如下初始化和关闭资源操作:

//----------------初始化------------------
//获取EntityManagerFactory实例
EntityManagerFactory  entityManagerFactory = Persistence.createEntityManagerFactory("wgs-jpa");
//创建EntityManager 实例,EntityManager 是完成持久化操作的核心对象
EntityManager  entityManager = entityManagerFactory.createEntityManager();
//EntityTransaction:管理资源层实体管理器的事务操作
EntityTransaction  entityTransaction = entityManager.getTransaction();
entityTransaction.begin();

//----------------关闭资源------------------
entityTransaction.commit();
entityManager.close();
entityManagerFactory.close();

(1)Persistence类:
Persistence 类是用于获取 EntityManagerFactory 实例。该类包含一个名为 createEntityManagerFactory 的 静态方法 。

EntityManagerFactory  entityManagerFactory = Persistence.createEntityManagerFactory("wgs-jpa");

(2)EntityManagerFactory类:
EntityManagerFactory 接口主要用来创建 EntityManager 实例。该接口约定了如下4个方法:

  • createEntityManager():用于创建实体管理器对象实例;
  • createEntityManager(Map map):用于创建实体管理器对象实例的重载方法,Map 参数用于提供 EntityManager 的属性;
  • isOpen():检查 EntityManagerFactory 是否处于打开状态。实体管理器工厂创建后一直处于打开状态,除非调用close()方法将其关闭;
  • close():关闭 EntityManagerFactory EntityManagerFactory 关闭后将释放所有资源,isOpen()方法测试将返回 false,其它方法将不能调用,否则将导致IllegalStateException异常。

(3)EntityManager类
EntityManager 是完成持久化操作的核心对象。即将普通Java对象持久化保存到数据库当中,同时可以根据主键查找Entity Bean。

实体的状态:

  • 新建状态: 新创建的对象,尚未拥有持久性主键。
  • 持久化状态:已经拥有持久性主键并和持久化建立了上下文环境
  • 游离状态:拥有持久化主键,但是没有与持久化建立上下文环境
  • 删除状态: 拥有持久化主键,已经和持久化建立上下文环境,但是从数据库中删除。

(4)EntityTransaction类:
EntityTransaction 接口用来管理资源层实体管理器的事务操作。通过调用实体管理器的getTransaction方法 获得其实例。

EntityManager相关API:

  • find (Class entityClass, Object primaryKey):返回指定的 OID
    对应的实体类对象,如果这个实体存在于当前的持久化环境,则返回一个被缓存的对象;否则会创建一个新的 Entity,
    并加载数据库中相关信息;若 OID 不存在于数据库中,则返回一个
    null。第一个参数为被查询的实体类类型,第二个参数为待查找实体的主键值;
  • getReference (Class entityClass,Object primaryKey):与find()方法类似,不同的是:如果缓存中不存在指定的 Entity, EntityManager 会创建一个 Entity 类的代理,但是不会立即加载数据库中的信息,只有第一次真正使用此 Entity 的属性才加载,所以如果此 OID 在数据库不存在,getReference() 不会返回 null 值, 而是抛出EntityNotFoundException;
  • persist (Object entity):用于将新创建的 Entity 纳入到 EntityManager 的管理。该方法执行后,传入 persist() 方法的 Entity 对象转换成持久化状态;
  • remove (Object entity):删除实例。如果实例是被管理的,即与数据库实体记录关联,则同时会删除关联的数据库记录;
  • merge (T entity):merge() 用于处理 Entity 的同步。即数据库的插入和更新操作;
  • flush ():同步持久上下文环境,即将持久上下文环境的所有未保存实体的状态信息保存到数据库中;
  • setFlushMode (FlushModeType flushMode):设置持久上下文环境的Flush模式。参数可以取2个枚举
    FlushModeType.AUTO 为自动更新数据库实体,
    FlushModeType.COMMIT 为直到提交事务时才更新数据库记录;
  • getFlushMode ():获取持久上下文环境的Flush模式。返回FlushModeType类的枚举值;
  • refresh (Object entity):用数据库实体记录的值更新实体对象的状态,即更新实例的属性值;
  • clear ():清除持久上下文环境,断开所有关联的实体。如果这时还有未提交的更新则会被撤消;
  • contains (Object entity):判断一个实例是否属于当前持久上下文环境管理的实体;
  • isOpen ():判断当前的实体管理器是否是打开状态;
  • getTransaction ():返回资源层的事务对象。EntityTransaction实例可以用于开始和提交多个事务;
  • close ():关闭实体管理器。之后若调用实体管理器实例的方法或其派生的查询对象的方法都将抛出 IllegalstateException 异常,除了getTransaction 和 isOpen方法(返回 false)。不过,当与实体管理器关联的事务处于活动状态时,调用 close 方法后持久上下文将仍处于被管理状态,直到事务完成。
  • createQuery (String qlString):创建一个查询对象;
  • createNamedQuery (String name):根据命名的查询语句块创建查询对象。参数为命名的查询语句;
  • createNativeQuery (String sqlString):使用标准 SQL语句创建查询对象。参数为标准SQL语句字符串;
  • createNativeQuery (String sqls, String resultSetMapping):使用标准SQL语句创建查询对象,并指定返回结果集 Map的 名称。

EntityTransaction相关API:

  • begin ():用于启动一个事务,此后的多个数据库操作将作为整体被提交或撤消。若这时事务已启动则会抛出
    IllegalStateException 异常;
  • commit ():用于提交当前事务。即将事务启动以后的所有数据库更新操作持久化至数据库中;
  • rollback ():撤消(回滚)当前事务。即撤消事务启动后的所有数据库更新操作,从而不对数据库产生影响;
  • setRollbackOnly ():使当前事务只能被撤消;
  • getRollbackOnly ():查看当前事务是否设置了只能撤消标志;
  • isActive ():查看当前事务是否是活动的。如果返回true则不能调用begin方法,否则将抛出 IllegalStateException 异常;如果返回 false 则不能调用 commit、rollback、setRollbackOnly 及 getRollbackOnly 方法,否则将抛出 IllegalStateException 异常。

三、应用JPA的CRUD实战

下面看看如何使用JPA来完成项目中的CRUD。

(1)创建 persistence.xml, 在这个文件中配置持久化单元:

  • 需要指定跟哪个数据库进行交互;
  • 需要指定 JPA 使用哪个持久化的框架以及配置该框架的基本属性;

(2)创建实体类

  • 使用 annotation 来描述实体类跟数据库表之间的映射关系.

(3)使用 JPA API 完成数据增加、删除、修改和查询操作

  • 创建 EntityManagerFactory ;
  • 创建 EntityManager

上述3个步骤是实战中需要去实现的3个步骤,下面看看如何在Intellij IDEA中创建JPA项目。

(1)创建JPA项目:
Alt text

(2)lib下加入所需要的jar包:
主要是Hibernate required下的所有jar包;Hibernate jpa的jar包;Mysql驱动包。
Alt text

(3)配置persistence.xml文件:

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
    <!--
    name:用于定义持久化单元的名字,必选;
    transaction-type:指定JPA的事务处理策略
        RESOURCE_LOCAL:默认值,数据库级别的事务,只能针对一种数据库,不支持分布式事务。
        JTA:支持分布式事务
    -->
    <persistence-unit name="wgs-jpa" transaction-type="RESOURCE_LOCAL">
        <!--
        配置使用什么 ORM 产品来作为 JPA 的实现
        1. 实际上配置的是  javax.persistence.spi.PersistenceProvider 接口的实现类
        2. 若 JPA 项目中只有一个 JPA 的实现产品, 则也可以不配置该节点.
        -->
        <provider>org.hibernate.ejb.HibernatePersistence</provider>
        <!-- 添加持久化类 -->
        <class>com.wgs.jpademo.Student</class>

        <properties>
            <!-- 连接数据库的基本信息 -->
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql:///jpa"/>
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="920614"/>


            <!-- 配置 JPA 实现产品的基本属性. 配置 hibernate 的基本属性 -->
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.format_sql" value="true"/>
            <property name="hbm2ddl.auto" value="update"/>
        </properties>
    </persistence-unit>
</persistence>

(4)编写实体类:Studnet.java

package com.wgs.jpademo;

import javax.persistence.*;

/**
 * @author GenshenWang.nomico
 * @date 2017/12/29.
 */
@Entity
public class Student {
    private int id;
    private String name;
    private int age;


    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


    @Override
    public String toString() {
        return "Student's name : " + name +", age:" + age;
    }
}

(5)MySQL要创建对应的表:
Alt text

(6)CRUD测试: JPATest.java

package com.wgs.jpademo;


import org.junit.After;
import org.junit.Before;
import org.junit.Test;

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


/**
 * @author GenshenWang.nomico
 * @date 2017/12/29.
 */

public class JPSTest {
    private EntityManagerFactory entityManagerFactory;
    private EntityManager entityManager;
    private EntityTransaction entityTransaction;

    @Before
    public void init(){
        //获取EntityManagerFactory实例
        entityManagerFactory = Persistence.createEntityManagerFactory("wgs-jpa");
        //创建EntityManager 实例,EntityManager 是完成持久化操作的核心对象
        entityManager = entityManagerFactory.createEntityManager();
        //EntityTransaction:管理资源层实体管理器的事务操作
        entityTransaction = entityManager.getTransaction();
        entityTransaction.begin();
    }

    @After
    public void destroy(){
        entityTransaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }

    /**
     * 删除:
     */
    @Test
    public void remove(){
        Student student = entityManager.find(Student.class, 5);
        entityManager.remove(student);
    }

    /**
     * 更改:
     */
    @Test
    public void testUpdate(){
        Student student = entityManager.find(Student.class, 4);
        student.setName("wgs");
    }
    /**
     * 增:将对象持久化保存到数据库
     * 注意:此处实体类的主键id设置为自增:strategy = GenerationType.IDENTITY
     *       数据库中的id一定也要设置为自增,否则持久化时就会抛PersistenceException异常
     */
    @Test
    public void testSave(){
        Student student = new Student();
        student.setAge(55);
        student.setName("dd");
        System.out.println(student.getId());
        entityManager.persist(student);
    }
    /**
     * 查找2:EntityManager.getReference(Entity.class, id),
     * 类似于hibernate的load方法,延迟加载,没有查到数据时返回异常;
     */
    @Test
    public void testFind2(){
        Student student = entityManager.getReference(Student.class, 11);
        System.out.println("-------------------------------------");
        System.out.println(student);
    }

    /**
     * 查找:EntityManager.find(Entity.class, id),
     * 类似于hibernate的get方法,没有查到数据时返回null;
     */
    @Test
    public void testFind() {
        Student student = entityManager.find(Student.class, 1);
        System.out.println("-------------------------------------");
        System.out.println(student);
    }


}

注意:
(1)在testFind(),testSave(),testUpdate(),testRemove()方法前后都要加上对EntityManager、EntityTransaction的操作,即:
操作前

        //获取EntityManagerFactory实例
        entityManagerFactory = Persistence.createEntityManagerFactory("wgs-jpa");
        //创建EntityManager 实例,EntityManager 是完成持久化操作的核心对象
        entityManager = entityManagerFactory.createEntityManager();
        //EntityTransaction:管理资源层实体管理器的事务操作
        entityTransaction = entityManager.getTransaction();
        entityTransaction.begin();

CRUD后:

entityTransaction.commit();
entityManager.close();
entityManagerFactory.close();

这些操作都被封装到init()和destroy()方法中,并通过Junit中的 @Before和@After注解,使得在每次执行CRUD前后都会执行这些初始化和关闭逻辑,实际操作中需要注意初始化和关闭;

(2)在执行增删改的时候,可能会抛出PersistenceException异常:

javax.persistence.PersistenceException: org.hibernate.PersistentObjectException: detached entity passed to persist: com.wgs.jpa.Student 

原因在于:
在实体类Student.java中设置了id为主键并且自增:

@Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public int getId() {
        return id;
    }

若数据库中的id列没有对应设置为自增,则会抛出此异常:
Alt text

即实体类和数据库的设置要对应一致。
如果设置了主键自增,实体类在保存对象时设置了主键值,也会报错:

Student tStudent=new Student(1, "aa", 11);//此时会报错,不能设置sid

四、JPQL简介与实战

JPQL:即 Java Persistence Query Language 的简称。

JPQL 是一种和 SQL 非常类似的中间性和对象化查询语言,可执行select 语句、update 语句或delete语句,通过 Query 接口封装执行。

1 Query接口

javax.persistence.Query: Query接口封装了执行数据库查询的相关方法。调用 EntityManager 的 createQuery、create NamedQuery 及 createNativeQuery 方法可以获得查询对象,进而可调用 Query 接口的相关方法来执行查询操作。

Query接口主要方法:

  • int executeUpdate():用于执行update或delete语句。
  • List getResultList():用于执行select语句并返回结果集实体列表。
    Object getSingleResult():用于执行只返回单个结果实体的select语句。
  • Query setFirstResult(int startPosition):用于设置从哪个实体记录开始返回查询结果。
  • Query setMaxResults(int maxResult):用于设置返回结果实体的最大数。与setFirstResult结合使用可实现分页查询。
  • Query setFlushMode(FlushModeType flushMode) :设置查询对象的Flush模式。
    参数可以取2个枚举值:FlushModeType.AUTO 为自动更新数据库记录,FlushMode Type.COMMIT 为直到提交事务时才更新数据库记录。
  • setHint(String hintName, Object value) :设置与查询对象相关的特定供应商参数或提示信息。参数名及其取值需要参考特定 JPA 实现库提供商的文档。如果第二个参数无效将抛出IllegalArgumentException异常。
  • setParameter(int position, Object value) :为查询语句的指定位置参数赋值。Position 指定参数序号,value 为赋给参数的值。
  • setParameter(int position, Date d, TemporalType type) :为查询语句的指定位置参数赋 Date 值。Position 指定参数序号,value 为赋给参数的值,temporalType 取 TemporalType 的枚举常量,包括 DATE、TIME 及 TIMESTAMP 三个,,用于将 Java 的 Date 型值临时转换为数据库支持的日期时间类型(java.sql.Date、java.sql.Time及java.sql.Timestamp)。
  • setParameter(int position, Calendar c, TemporalType type) :为查询语句的指定位置参数赋 Calenda r值。position 指定参数序号,value 为赋给参数的值,temporalType 的含义及取舍同前。
  • setParameter(String name, Object value) :为查询语句的指定名称参数赋值。
  • setParameter(String name, Date d, TemporalType type) :为查询语句的指定名称参数赋 Date 值。用法同前。
  • setParameter(String name, Calendar c, TemporalType type) :为查询语句的指定名称参数设置Calendar值。name为参数名,其它同前。该方法调用时如果参数位置或参数名不正确,或者所赋的参数值类型不匹配,将抛出 IllegalArgumentException 异常。

2 Query查询

应用JPQL的查询:主要使用Query接口。

    public void testJPQL(){
        String jpql = "FROM Student s WHERE s.age > ?1";
        Query query = entityManager.createQuery(jpql);
        //索引从1开始    
        query.setParameter(1, 11);

        //获取所有符合条件的结果
        List<Student> studentList = query.getResultList();
        System.out.println(studentList.size());
    }

注:在String jpql = "FROM Student s WHERE s.age > ?1";语句中,以前的写法是:

String jpql = "FROM Student s WHERE s.age > ?";
Query query = entityManager.createQuery(jpql);
//索引从1开始
query.setParameter(1, 11);

这样写编译会出现错误,Hibernate在4.1之后对查询占位符做了改进,不然会出现编译错误:

改进方法一:JPA占位符的方式:

String jpql = "FROM Student s WHERE s.age > ?1 and s.name=?2";
Query query = entityManager.createQuery(jpql);
//索引从1开始
query.setParameter(1, 11);
query.setParameter(2, "aaa");

改进方法二:将占位符处数字改成具体的名字

String jpql = "FROM Student s WHERE s.age > :age0 and s.name=:name0";
Query query = entityManager.createQuery(jpql);
//索引从1开始
query.setParameter("age0", 11);
query.setParameter("name0", "aaa");

3 JPA实战

(1)实体类Student:

package com.wgs.jpademo;

import javax.persistence.*;

/**
 * @author GenshenWang.nomico
 * @date 2017/12/29.
 */
@NamedQuery(name = "wgsNamedQuery", query="FROM Student s WHERE s.age = ?1")
@Entity
public class Student {
    private int id;
    private String name;
    private int age;


    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student's name : " + name +", age:" + age;
    }
}

(2)数据表设计
Alt text

(3)测试

package com.wgs.jpademo;

import org.hibernate.ejb.QueryHints;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import javax.persistence.*;
import java.util.List;

/**
 * @author GenshenWang.nomico
 * @date 2017/12/29.
 */
public class JPQLTest {

    private EntityManagerFactory entityManagerFactory;
    private EntityManager entityManager;
    private EntityTransaction entityTransaction;

    /* ------------------------------------初始化和关闭--------------------------------------*/
    @Before
    public void init(){
        entityManagerFactory = Persistence.createEntityManagerFactory("wgs-jpa");
        entityManager = entityManagerFactory.createEntityManager();
        entityTransaction = entityManager.getTransaction();
        entityTransaction.begin();
    }

    @After
    public void destroy(){
        entityTransaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }



    /* ------------------------------------JPQL 查询--------------------------------------*/
    @Test
    public void testJPQL(){
        String jpql = "FROM Student s WHERE s.age > ?1";
        Query query = entityManager.createQuery(jpql);
        //索引从1开始
        query.setParameter(1, 11);

        //获取所有符合条件的结果
        List<Student> studentList = query.getResultList();
        System.out.println(studentList.size());
    }

    //获取单个符合条件的结果
    @Test
    public void testSingleJPQL(){
        String jpql = "FROM Student s WHERE s.age = ?1";
        Query query = entityManager.createQuery(jpql);
        //索引从1开始
        query.setParameter(1, 11);

        Student student = (Student) query.getSingleResult();
        System.out.println(student.getName());
    }

    //获取部分符合条件的对象,使用new Student(s.name, s.age)。
    @Test
    public void testPartlyProperties(){
        String jpql = "SELECT new Student(s.name, s.age) FROM Student s WHERE s.id > ?1";
        List result = entityManager.createQuery(jpql).setParameter(1, 3).getResultList();

        System.out.println(result);
    }


    //实体类上必须有对应的NamedQuery注解:@NamedQuery(name = "wgsNamedQuery", query="FROM Student s WHERE s.age = ?")
    @Test
    public void testNamedQuery(){
        Query query = entityManager.createNamedQuery("wgsNamedQuery");
        query.setParameter(1, 33);
        Student student = (Student) query.getSingleResult();
        System.out.println(student.getName());
    }


    //使用原始SQL语句查询
    @Test
    public void testNativeQuery(){
        String sql = "SELECT name FROM Student where id = ?1";
        Query query =  entityManager.createQuery(sql);
        query.setParameter(1, 3);
        Object result =  query.getSingleResult();
        System.out.println(result);
    }

    //排序
    @Test
    public void testOrderBy(){
        String jpql = "FROM Student s WHERE s.age > ?1 ORDER BY s.age DESC";
        Query query = entityManager.createQuery(jpql).setHint(QueryHints.HINT_CACHEABLE, true);

        query.setParameter(1, 30);
        List<Student> students = query.getResultList();
        System.out.println(students.size());
    }

    /* ------------------------------------JPQL Delete--------------------------------------*/
    @Test
    public void testDelete(){
        String jpql = "DELETE FROM Student s WHERE s.age > ?1";
        Query query = entityManager.createQuery(jpql).setParameter(1, 50);
        query.executeUpdate();

    }

    /* ------------------------------------JPQL Update--------------------------------------*/
     @Test
     public void testExecuteUpdate(){
         String jpql = "UPDATE Student s SET s.name = ?1 WHERE s.id = ?2";
         Query query = entityManager.createQuery(jpql).setParameter(1, "YYY").setParameter(2, 4);
         query.executeUpdate();
     }



}

JPA与Spring Data使用才会发挥出更大魔力,下节将会学习JPA与Spring Data的整合。

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页