提供了编程的基础技术教程

zl程序教程

您现在的位置是：首页 >  其他

当前栏目

JPA入门和相关操作

入门 操作 相关 jpa
2023-06-13 09:11:07 时间

相关概述

ORM概述

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

简单的说：ORM就是建立实体类和数据库表之间的关系，从而达到操作实体类就相当于操作数据库表的目的。 - 主要目的：操作实体类就相当于操作数据库表 - 建立两个映射关系： 实体类和表的映射关系 实体类中属性和表中字段的映射关系 - 不再重点关注：sql语句

  • 实现了ORM思想的框架：mybatis，hibernate

hibernate与JPA的概述

hibernate概述

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

JPA概述

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

JPA的优势

  • 标准化
  • 容器级特性的支持
  • 简单方便
  • 查询能力
  • 高级特性

JPA与hibernate的关系

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

JPA的入门案例

搭建环境的过程

1. 创建maven工程导入坐标

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

2. 需要配置jpa的核心配置文件

  • 位置：配置到类路径下的一个叫做 META-INF 的文件夹下
  • 命名：persistence.xml
<?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">
    <!--配置持久化单元
            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="root" />

            <!--jpa提供者的可选配置：我们的JPA规范的提供者为hibernate，所以jpa的核心配置中兼容hibernate的配 -->
            <!--配置jpa实现方(hibernate)的配置信息
              显示sql:false|true
                 自动创建数据库表:hibernate.hbm2ddl.auto
                 create:程序运行时创建数据库表(如果有表，先删除表再创建)
                 update:程序运行时创建表(如果有表，不会创建表)
                 none:不会创建表
            -->
            <property name="hibernate.show_sql" value="true" />
            <property name="hibernate.format_sql" value="true" />
            <property name="hibernate.hbm2ddl.auto" value="update" />
        </properties>
    </persistence-unit>
</persistence>

3. 创建客户的数据库表和客户的实体类

  • 创建客户的数据库表
 /*创建客户表*/
    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;
  • 编写客户的实体类
package cn.kt.domain;/*
 *Created by tao on 2020-05-01.
 */

import javax.persistence.*;
import java.io.Serializable;

/**
 * * 所有的注解都是使用JPA的规范提供的注解，
 * * 所以在导入注解包的时候，一定要导入javax.persistence下的
 */
@Entity //声明实体类
@Table(name = "cst_customer") //建立实体类和表的映射关系
public class Customer implements Serializable {

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

    @Override
    public String toString() {
        return "Customer{" +
                "custId=" + custId +
                ", custName='" + custName + '\'' +
                ", custSource='" + custSource + '\'' +
                ", custIndustry='" + custIndustry + '\'' +
                ", custLevel='" + custLevel + '\'' +
                ", custAddress='" + custAddress + '\'' +
                ", custPhone='" + custPhone + '\'' +
                '}';
    }
}

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

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

5. 保存客户到数据库中

实现保存操作

package cn.kt.test;/*
 *Created by tao on 2020-05-01.
 */

import cn.kt.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 {

    @Test
    public void test() {
        /**
         * 创建实体管理类工厂，借助Persistence的静态方法获取
         *      其中传递的参数为持久化单元名称，需要jpa配置文件中指定
         */
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
        //1. 创建实体管理类
        EntityManager em = factory.createEntityManager();
        //2. 获取事务对象
        EntityTransaction tx = em.getTransaction();
        //3. 开启事务
        tx.begin();
        Customer c = new Customer();
        c.setCustName("Nick");
        c.setCustAddress("江西赣州");
        //4. 保存操作
        em.persist(c);
        //5. 提交事务
        tx.commit();
        //6. 释放资源
        em.close();
        factory.close();
    }

}

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;


    //@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：主键由程序控制 用法：
    @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底层自动增长。GenerationType.IDENTITY Oracle使用最多是底层序列化增长：GenerationType.SEQUENCE

jpa操作的操作步骤

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：回滚

4.增删改查操作 5.提交事务 6.释放资源

增删改查测试

  1. JavaBean封装还是上面那个customer
  2. JPAUtil（工具类）
package cn.kt.util;/*
 *Created by tao on 2020-05-02.
 */

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

public class JPAUtil {
    /*
     * 解决尸体管理器工厂的浪费资源和耗时问题
     * 通过静态代码块，当程序第一次访问时此工具类，创建一个公共的尸体管理器工厂对象
     * 以后访问时，直接以创建的factory对象，创建EntityManager对象
     */
    private static EntityManagerFactory factory;

    static {
        factory = Persistence.createEntityManagerFactory("myJpa");
    }

    /*
     *获取EntityManager对象
     */
    public static EntityManager getEntityManager() {
        return factory.createEntityManager();
    }
}
  1. 测试类(增删改查)
package cn.kt.test;/*
 *Created by tao on 2020-05-01.
 */

import cn.kt.domain.Customer;
import cn.kt.util.JPAUtil;
import org.junit.Test;

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

public class JpaTest {

    @Test
    public void test() {
        /**
         * 创建实体管理类工厂，借助Persistence的静态方法获取
         *      其中传递的参数为持久化单元名称，需要jpa配置文件中指定
         */
//        EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
//        //1. 创建实体管理类
//        EntityManager em = factory.createEntityManager();
//        //2. 获取事务对象
        EntityManager em = JPAUtil.getEntityManager();
        //3. 开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        Customer c = new Customer();
        c.setCustName("Nick");
        c.setCustAddress("江西赣州");
        //4. 保存操作
        em.persist(c);
        //5. 提交事务
        tx.commit();
        //6. 释放资源
        em.close();
//        factory.close();
    }
    /*
    * 根据id查询客户
    *  立即加载
    * */
    @Test
    public void testFind(){
        //1.实体管理类
        EntityManager em = JPAUtil.getEntityManager();
        //2. 开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.增删改查
        /*
        *find:根据id查询对象
        *   class：查询数据结果需要包装的实体类类型和字节码
        *   id：查询主键的取值
        */
        Customer customer = em.find(Customer.class, 1l);
        System.out.println(customer);
        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }
    /*
     * 根据id查询客户（一般用这种查询）
     * getReference方法：
     *  不会立即发送sql语句查询数据库，什么时候用什么时候发送sql语句查询数据库
     *
     * 延迟加载：（懒加载）
     *      * 得到的是一个动态代理对象
     *      * 什么时候用什么时候查询
     */
    @Test
    public void testGetReference(){
        //1.实体管理类
        EntityManager em = JPAUtil.getEntityManager();
        //2. 开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.增删改查
        /*
         *find:根据id查询对象
         *   class：查询数据结果需要包装的实体类类型和字节码
         *   id：查询主键的取值
         */
        Customer customer = em.getReference(Customer.class, 1l);
        System.out.println(customer);
        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }

    /*
    *删除客户案例
    *   remove方法里的参数是Object对象
    *   所有要先用find方法id查询出要删除的对象
    *   然后再删除
    */
    @Test
    public void testRemove(){
        //1.实体管理类
        EntityManager em = JPAUtil.getEntityManager();
        //2. 开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.增删改查  --删除客户
        //3.1根据id查询客户
        Customer customer = em.find(Customer.class, 1l);
        //3.2调用remove方法删除客户
        em.remove(customer);
        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }

    /*
     *更新客户案例
     */
    @Test
    public void testMerge(){
        //1.实体管理类
        EntityManager em = JPAUtil.getEntityManager();
        //2. 开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.增删改查  --删除客户
        //3.1根据id查询客户
        Customer customer = em.find(Customer.class, 3l);
        //3.2重新set用户对象
        customer.setCustName("左眼会陪右眼哭");
        //3.3更新客户，merge方法
        em.merge(customer);
        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }

}

JPA中的复杂查询

JPQL全称Java Persistence Query Language 基于首次在EJB2.0中引入的EJB查询语言(EJB QL),Java持久化查询语言(JPQL)是一种可移植的查询语言，旨在以面向对象表达式语言的表达式，将SQL语法和简单查询语义绑定在一起·使用这种语言编写的查询是可移植的，可以被编译成所有主流数据库服务器上的SQL。

其特征与原生SQL语句类似，并且完全面向对象，通过类名和属性访问，而不是表名和表的属性。

jpql查询

1.查询全部 2.分页查询 3.统计查询 4.条件查询 5.排序

测试代码

package cn.kt.test;/*
 *Created by tao on 2020-05-02.
 */

import cn.kt.util.JPAUtil;
import org.junit.Test;

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

public class jpqlTest {
    //查询所有客户
    /*
    *sql:select * from customer
    *jpql:from cn.kt.domain.Customer
    */
    @Test
    public void findAll(){
        //1. 获取getEntityManager对象
        EntityManager em = JPAUtil.getEntityManager();
        //2. 开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.查询全部
        // 创建query对象
        String jpql = "from Customer";
        Query query = em.createQuery(jpql);
        //发送查询，并且封装结果集
        List resultList =   query.getResultList();
        for (Object o : resultList) {
            System.out.println(o.toString());
        }
        //4. 提交事务
        tx.commit();
        //5. 释放资源
        em.close();
    }

    //倒序查询所有客户
    /*
     *sql:select * from customer order by id desc;
     *jpql:from cn.kt.domain.Customer order by custId desc
     */
    @Test
    public void testOrder(){
        //1. 获取getEntityManager对象
        EntityManager em = JPAUtil.getEntityManager();
        //2. 开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.查询全部
        // 创建query对象
        String jpql = "from cn.kt.domain.Customer order by custId desc";
        Query query = em.createQuery(jpql);
        //发送查询，并且封装结果集
        List resultList =   query.getResultList();
        for (Object o : resultList) {
            System.out.println(o.toString());
        }
        //4. 提交事务
        tx.commit();
        //5. 释放资源
        em.close();
    }

    //查询客户的总数
    /*
     *sql:select count(*) from customer;
     *jpql:sselect count(*) from Customer
     */
    @Test
    public void testCount(){
        //1. 获取getEntityManager对象
        EntityManager em = JPAUtil.getEntityManager();
        //2. 开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.查询全部
        // 创建query对象
        String jpql = "select count(*) from Customer";
        Query query = em.createQuery(jpql);
        //发送查询，并且封装结果集
        Object singleResult = query.getSingleResult();
        System.out.println(singleResult);
        //4. 提交事务
        tx.commit();
        //5. 释放资源
        em.close();
    }

    //分页查询
    /*
     *sql:select * from customer limit ?,?;
     *jpql:from Customer
     */
    @Test
    public void testPaged(){
        //1. 获取getEntityManager对象
        EntityManager em = JPAUtil.getEntityManager();
        //2. 开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.查询全部
        // 3.1创建query对象
        String jpql = "from Customer";
        Query query = em.createQuery(jpql);
        //3.2对参数赋值，分页参数
        //3.2.1起始索引
        query.setFirstResult(0);
        //3.2.2每页查询的条数
        query.setMaxResults(2);
        //发送查询，并且封装结果集
        List resultList =   query.getResultList();
        for (Object o : resultList) {
            System.out.println(o.toString());
        }
        //4. 提交事务
        tx.commit();
        //5. 释放资源
        em.close();
    }

    //条件查询
    /*
     *sql:select * from customer where cust_name like "%***%;
     *jpql:from Customer where custName like "%***%
     */
    @Test
    public void testCondition(){
        //1. 获取getEntityManager对象
        EntityManager em = JPAUtil.getEntityManager();
        //2. 开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.查询全部
        // 3.1创建query对象
        String jpql = "from Customer where custName like ?";
        Query query = em.createQuery(jpql);
        //3.2对参数赋值，占位符参数
        query.setParameter(1,"%索隆%");
        //发送查询，并且封装结果集
        List resultList =   query.getResultList();
        for (Object o : resultList) {
            System.out.println(o.toString());
        }
        //4. 提交事务
        tx.commit();
        //5. 释放资源
        em.close();
    }

}

相关文章