javaWeb核心技术05--JPA、ORM、hibernate

最新推荐文章于 2024-03-19 11:05:47 发布
最新推荐文章于 2024-03-19 11:05:47 发布
阅读量134 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34536604/article/details/106997822
版权

ORM思想

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

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

  • 主要目的：操作实体类就相当于操作数据库表

  • 建立两个映射关系：

    • 实体类和表的映射关系
    • 实体类中属性和表中字段的映射关系

  • 不再重点关注：sql语句

  • 实现了ORM思想的框架：Mybatis（ibatis）、Hibernate、Jpa

hibernate与JPA的概述

hibernate概述

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

JPA概述

  • JPA的全称是Java Persistence API， 即Java 持久化API，是SUN公司推出的一套基于ORM的规范，内部是由一系列的接口和抽象类构成。
  • JPA通过JDK 5.0注解描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。

JPA的优势

标准化

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

容器级特性的支持

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

简单方便

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

查询能力

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

高级特性

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

JPA与hibernate的关系

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

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

JPA的入门案例

需求

  • 实现的功能是保存一个客户到数据库的客户表中。

开发包介绍

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

搭建开发环境

导入jar包

  • 对于JPA操作，只需要从hibernate提供的资料中找到我们需要的jar导入到工程中即可。
  • 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>

配置JPA的核心配置文件

  • 在java工程的src路径下resources下创建一个名为META-INF的文件夹，在此文件夹下创建一个名为persistence.xml的配置文件
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
    <!--需要配置persistence-unit节点
        持久化单元：
            name：持久化单元名称
            transaction-type：事务管理的方式
                    JTA：分布式事务管理
                    RESOURCE_LOCAL：本地事务管理
    -->
    <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
        <!--jpa的实现方式 -->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>

        <!--可选配置：配置jpa实现方的配置信息-->
        <properties>
            <!-- 数据库信息
                用户名，javax.persistence.jdbc.user
                密码，  javax.persistence.jdbc.password
                驱动，  javax.persistence.jdbc.driver
                数据库地址   javax.persistence.jdbc.url
            -->
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="111111"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql:///jpa"/>

            <!--配置jpa实现方(hibernate)的配置信息
                显示sql           ：   false|true
                自动创建数据库表    ：  hibernate.hbm2ddl.auto
                        create      : 程序运行时创建数据库表（如果有表，先删除表再创建）
                        update      ：程序运行时创建表（如果有表，不会创建表）
                        none        ：不会创建表

            -->
            <property name="hibernate.show_sql" value="true" />
            <property name="hibernate.hbm2ddl.auto" value="update" />
        </properties>
    </persistence-unit>
</persistence>

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

创建客户的数据库表

/*创建客户表*/
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;"

创建客户的实体类

public class Customer implements Serializable {
    
	private Long custId;
	private String custName;
	private String custSource;
	private String custIndustry;
	private String custLevel;
	private String custAddress;
	private String custPhone;
	//getter和setter
}

编写实体类和数据库表的映射配置

在实体类上使用JPA注解的形式配置映射关系

/**
 * 客户的实体类
 *      配置映射关系
 *   1.实体类和表的映射关系
 *      @Entity:声明实体类
 *      @Table : 配置实体类和表的映射关系
 *          name : 配置数据库表的名称
 *   2.实体类中属性和表中字段的映射关系
 * 所有的注解都是使用JPA的规范提供的注解，
 * 所以在导入注解包的时候，一定要导入javax.persistence下的
 */
@Entity
@Table(name = "cst_customer")
public class Customer {

    /**
     * @Id：声明主键的配置
     * @GeneratedValue:配置主键的生成策略
     *      strategy
     *          GenerationType.IDENTITY ：自增，mysql
     *                 * 底层数据库必须支持自动增长（底层数据库支持的自动增长方式，对id自增）
     *          GenerationType.SEQUENCE : 序列，oracle
     *                  * 底层数据库必须支持序列
     *          GenerationType.TABLE : jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键自增
     *          GenerationType.AUTO ： 由程序自动的帮助我们选择主键生成策略
     * @Column:配置属性和字段的映射关系
     *      name：数据库表中字段的名称
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "cust_id")
    private Long custId; //客户的主键

    @Column(name = "cust_name")
    private String custName;//客户名称

    @Column(name="cust_source")
    private String custSource;//客户来源

    @Column(name="cust_level")
    private String custLevel;//客户级别

    @Column(name="cust_industry")
    private String custIndustry;//客户所属行业

    @Column(name="cust_phone")
    private String custPhone;//客户的联系方式

    @Column(name="cust_address")
    private String custAddress;//客户地址
    
    //getter setter...

常用注解的说明

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

CRUD操作以及JPA的API介绍

JPA的API介绍

Persistence对象

  • Persistence对象主要作用是用于获取EntityManagerFactory对象的 。通过调用该类的createEntityManagerFactory静态方法，根据配置文件中持久化单元名称创建EntityManagerFactory。
"//1. 创建 EntitymanagerFactory
@Test
String unitName = "myJpa";
EntityManagerFactory factory= Persistence.createEntityManagerFactory(unitName);"

EntityManagerFactory

  • EntityManagerFactory 接口主要用来创建 EntityManager 实例
"//创建实体管理类
EntityManager em = factory.createEntityManager();"
  • 抽取jpaUtils工具类
/**
 * 解决实体管理器工厂的浪费资源和耗时问题
 *      通过静态代码块的形式，当程序第一次访问此工具类时，创建一个公共的实体管理器工厂对象
 *
 * 第一次访问getEntityManager方法：经过静态代码块创建一个factory对象，再调用方法创建一个EntityManager对象
 * 第二次方法getEntityManager方法：直接通过一个已经创建好的factory对象，创建EntityManager对象
 */
public class JpaUtils {

    private static EntityManagerFactory factory;

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

    /**
     * 获取EntityManager对象
     */
    public static EntityManager getEntityManager() {
       return factory.createEntityManager();
    }
}

EntityManager

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

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

EntityTransaction

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

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

CRUD操作

实现保存操作 persist

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

    }

根据id查询用户

  • 立即加载 find
/**
 * 根据id查询客户
 *  使用find方法查询：
 *      1.查询的对象就是当前客户对象本身
 *      2.在调用find方法的时候，就会发送sql语句查询数据库
 *  立即加载
 */
@Test
public  void testFind() {
    //1.通过工具类获取entityManager
    EntityManager entityManager = JpaUtils.getEntityManager();
    //2.开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();
    //3.增删改查 -- 根据id查询客户
    /**
     * find : 根据id查询数据
     *      class：查询数据的结果需要包装的实体类类型的字节码
     *      id：查询的主键的取值
     */
    Customer customer = entityManager.find(Customer.class, 1l);
   // System.out.print(customer);
    //4.提交事务
    tx.commit();
    //5.释放资源
    entityManager.close();
}
  • 延迟加载 getRefrence
/**
 * 根据id查询客户
 *      getReference方法
 *          1.获取的对象是一个动态代理对象
 *          2.调用getReference方法不会立即发送sql语句查询数据库
 *              * 当调用查询结果对象的时候，才会发送查询的sql语句：什么时候用，什么时候发送sql语句查询数据库
 *
 * 延迟加载（懒加载）
 *      * 得到的是一个动态代理对象
 *      * 什么时候用，什么使用才会查询
 */
@Test
public  void testReference() {
    //1.通过工具类获取entityManager
    EntityManager entityManager = JpaUtils.getEntityManager();
    //2.开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();
    //3.增删改查 -- 根据id查询客户
    /**
     * getReference : 根据id查询数据
     *      class：查询数据的结果需要包装的实体类类型的字节码
     *      id：查询的主键的取值
     */
    Customer customer = entityManager.getReference(Customer.class, 1l);
    System.out.print(customer);
    //4.提交事务
    tx.commit();
    //5.释放资源
    entityManager.close();
}

删除 remove

/**
 * 删除
 */
@Test
public void testRemove() {
	// 定义对象
	EntityManager em = null;
	EntityTransaction tx = null;
	try {
		// 获取实体管理对象
		em = JPAUtil.getEntityManager();
		// 获取事务对象
		tx = em.getTransaction();
		// 开启事务
		tx.begin();
		// 执行操作
		Customer c1 = em.find(Customer.class, 6L);
		em.remove(c1);
		// 提交事务
		tx.commit();
	} catch (Exception e) {
		// 回滚事务
		tx.rollback();
		e.printStackTrace();
	} finally {
		// 释放资源
		em.close();
	}
}

跟新 merge

/**
 * 更新客户的操作
 *      merge(Object)
 */
@Test
public  void testUpdate() {
    //1.通过工具类获取entityManager
    EntityManager entityManager = JpaUtils.getEntityManager();
    //2.开启事务
    EntityTransaction tx = entityManager.getTransaction();
    tx.begin();
    //3.增删改查 -- 更新操作

    //i 查询客户
    Customer customer = entityManager.find(Customer.class,1l);
    //ii 更新客户
    customer.setCustIndustry("教育01");
    entityManager.merge(customer);

    //4.提交事务
    tx.commit();
    //5.释放资源
    entityManager.close();
}

操作步骤总结

加载配置文件创建实体管理器工厂

  • Persisitence：静态方法（根据持久化单元名称创建实体管理器工厂）
    • createEntityMnagerFactory（持久化单元名称）
    • 用：创建实体管理器工厂

根据实体管理器工厂，创建实体管理器

  • EntityManagerFactory ：获取EntityManager对象
  • 方法：createEntityManager
  • 内部维护的很多的内容
    • 内部维护了数据库信息，
    • 维护了缓存信息
    • 维护了所有的实体管理器对象
    • 再创建EntityManagerFactory的过程中会根据配置创建数据库表

EntityManagerFactory的创建过程比较浪费资源

  • 特点：线程安全的对象
  • 多个线程访问同一个EntityManagerFactory不会有线程安全问题
  • 如何解决EntityManagerFactory的创建过程浪费资源（耗时）的问题？
    • 思路：创建一个公共的EntityManagerFactory的对象
    • 静态代码块的形式创建EntityManagerFactory

创建事务对象，开启事务

  • EntityManager对象：实体类管理器

    • beginTransaction : 创建事务对象
    • presist ： 保存
    • merge ： 更新
    • remove ： 删除
    • find/getRefrence ： 根据id查询

  • Transaction 对象 ： 事务

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

增删改查操作 提交事务 释放资源

JPA中的主键生成策略

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

JPA提供的四种标准用法

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

JPA中的复杂查询

JPQL

  • 全称Java Persistence Query Language
  • 基于首次在EJB2.0中引入的EJB查询语言(EJB QL),Java持久化查询语言(JPQL)是一种可移植的查询语言，旨在以面向对象表达式语言的表达式，将SQL语法和简单查询语义绑定在一起·使用这种语言编写的查询是可移植的，可以被编译成所有主流数据库服务器上的SQL。
  • 其特征与原生SQL语句类似，并且完全面向对象，通过类名和属性访问，而不是表名和表的属性。

查询全部

//查询所有客户
@Test
public void findAll() {
	EntityManager em = null;
	EntityTransaction tx = null;
	try {
		//获取实体管理对象
		em = JPAUtil.getEntityManager();
		//获取事务对象
		tx = em.getTransaction();
		tx.begin();
		// 创建query对象
		String jpql = "from Customer";
		Query query = em.createQuery(jpql);
		// 查询并得到返回结果
		List list = query.getResultList(); // 得到集合返回类型
		for (Object object : list) {
			System.out.println(object);
		}
		tx.commit();
	} catch (Exception e) {
		// 回滚事务
		tx.rollback();
		e.printStackTrace();
	} finally {
		// 释放资源
		em.close();
	}
}

排序查询

/**
 * 排序查询： 倒序查询全部客户（根据id倒序）
 *      sql：SELECT * FROM cst_customer ORDER BY cust_id DESC
 *      jpql：from Customer order by custId desc 
 *
 * 进行jpql查询
 *      1.创建query查询对象
 *      2.对参数进行赋值
 *      3.查询，并得到返回结果
 */
@Test
public void testOrders() {
    //1.获取entityManager对象
    EntityManager em = JpaUtils.getEntityManager();
    //2.开启事务
    EntityTransaction tx = em.getTransaction();
    tx.begin();
    //3.查询全部
    String jpql = "from Customer order by custId desc";
    Query query = em.createQuery(jpql);//创建Query查询对象，query对象才是执行jqpl的对象

    //发送查询，并封装结果集
    List list = query.getResultList();

    for (Object obj : list) {
        System.out.println(obj);
    }

    //4.提交事务
    tx.commit();
    //5.释放资源
    em.close();
}

统计总数

/**
 * 使用jpql查询，统计客户的总数
 *      sql：SELECT COUNT(cust_id) FROM cst_customer
 *      jpql：select count(custId) from Customer
 */
@Test
public void testCount() {
    //1.获取entityManager对象
    EntityManager em = JpaUtils.getEntityManager();
    //2.开启事务
    EntityTransaction tx = em.getTransaction();
    tx.begin();
    //3.查询全部
    //i.根据jpql语句创建Query查询对象
    String jpql = "select count(custId) from Customer";
    Query query = em.createQuery(jpql);
    //ii.对参数赋值
    //iii.发送查询，并封装结果

    /**
     * getResultList ： 直接将查询结果封装为list集合
     * getSingleResult : 得到唯一的结果集
     */
    Object result = query.getSingleResult();

    System.out.println(result);

    //4.提交事务
    tx.commit();
    //5.释放资源
    em.close();
}

分页查询

/**
 * 分页查询
 *      sql：select * from cst_customer limit 0,2
 *      jqpl : from Customer
 */
@Test
public void testPaged() {
    //1.获取entityManager对象
    EntityManager em = JpaUtils.getEntityManager();
    //2.开启事务
    EntityTransaction tx = em.getTransaction();
    tx.begin();
    //3.查询全部
    //i.根据jpql语句创建Query查询对象
    String jpql = "from Customer";
    Query query = em.createQuery(jpql);
    //ii.对参数赋值 -- 分页参数
    //起始索引
    query.setFirstResult(0);
    //每页查询的条数
    query.setMaxResults(2);

    //iii.发送查询，并封装结果

    /**
     * getResultList ： 直接将查询结果封装为list集合
     * getSingleResult : 得到唯一的结果集
     */
    List list = query.getResultList();

    for(Object obj : list) {
        System.out.println(obj);
    }

    //4.提交事务
    tx.commit();
    //5.释放资源
    em.close();
}

条件查询

/**
 * 条件查询
 *     案例：查询客户名称以‘播客’开头的客户
 *          sql：SELECT * FROM cst_customer WHERE cust_name LIKE  ?
 *          jpql : from Customer where custName like ?
 */
@Test
public void testCondition() {
    //1.获取entityManager对象
    EntityManager em = JpaUtils.getEntityManager();
    //2.开启事务
    EntityTransaction tx = em.getTransaction();
    tx.begin();
    //3.查询全部
    //i.根据jpql语句创建Query查询对象
    String jpql = "from Customer where custName like ? ";
    Query query = em.createQuery(jpql);
    //ii.对参数赋值 -- 占位符参数
    //第一个参数：占位符的索引位置（从1开始），第二个参数：取值
    query.setParameter(1,"播客%");

    //iii.发送查询，并封装结果

    /**
     * getResultList ： 直接将查询结果封装为list集合
     * getSingleResult : 得到唯一的结果集
     */
    List list = query.getResultList();

    for(Object obj : list) {
        System.out.println(obj);
    }

    //4.提交事务
    tx.commit();
    //5.释放资源
    em.close();
}
程序学者
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JPA - Hibernate
qq_33753147的博客
09-20 455
JPA - Hibernate
Hibernate JPA
weixin_42248522的博客
11-12 242
一.JPA 1.添加依赖 //hibernate实体管理者，对接JPA规范的管理员 这是hibernate为了迎合JPA的规范做出来的。 compile group: 'org.hibernate', name: 'hibernate-entitymanager', version: '4.3.9.Final' 2.定义实体类 3.定义配置文件 必须要说明一点，配置文件的名字需要固定，必须叫：persistence.xml , 而且也必须放在 META-INF下面，不能直接放在resource下面。需
Spring Data JPA基本使用及部分原理(核心概念)
01-20
https://lufficc.com/blog/spring-boot-jpa-basic Repository Bean 是如何创建的 bugs 1.jpa使用时未开启事务爆错 解决方法： 在 调用jpa的语句上标识@Transactional 2 jpa自定义查询时 大概意思就是说 对于带有命名参数的查询，您需要使用提供方法参数的名称 使用@param查询方法参数 是java8以上的一个标志， 解决方法：在 自定义的查询参数前面加@Param 如 bug:JPA java.lang.IllegalStateException: For queries with named p
Spring+SpringData+JPA SpringMVC+Redis +Solr 个人博客
03-22
博客（BIG）系统是企业营销信息化的解决方案，它将企业市场管理、销售管理、服务管理三个领域应用三位一体化，帮助企业提升整体营销管理竞争力、提高销售工作效率、提高服务满意度顾客忠诚度。以满足企业不断丰厚的信息化需求和运营管理需求
day66 JavaWeb框架阶段——SpringDataJPA【01】ORM概述(JPA中的主键生成策略，编写实体类和数据库表的映射配置[重点]，使用JPA完成增删改查操作)
qq_38454176的博客
03-03 685
JPA第一天 今日源码： 链接：https://pan.baidu.com/s/1ZtXsykgwO_JzAl2xb3hunQ 提取码：e2rc 第1章 1.ORM概述[了解] ORM（Object-Relational Mapping） 表示对象关系映射。在面向对象的软件开发中，通过ORM，就可以把对象映射到关系型数据库中。只要有一套程序能够做到建立对象与数据库的关联，操作对象就可以直接操作数据...
SpringData JPA 快速入门案例详解
zp8126的专栏
03-19 1654
JPA（Java Persistence API）是 Java 持久层规范，定义了一些列 ORM 接口，它本身是不能直接使用的，因为接口需要实现才能使用，Hibernate 框架就是实现 JPA 规范的框架。
Spring Data JPA开发入门教程
fjk_tester的博客
05-04 1455
一、JPA概述 开篇立即进入正题，以下是最古老的数据库操作方式（应用程序直接连接数据库）: #mermaid-svg-V6DI5QB7oR2JM7z4 .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--mermaid-font-family);fill:#333;color:#333}#mermaid-svg-V6DI5QB7oR2JM7z4 .label text{fill:#333}#mermaid-svg-V6DI5
JavaWeb-Maven框架-黑马旅游网源码
01-11
JavaWeb涵盖了Servlet、JSP、JavaServer Pages (JSP)、JavaBeans (Javabeans)、Java Persistence API (JPA)、Hibernate、Spring框架等技术。在这个项目中，可能使用Servlet处理HTTP请求，JSP用于生成动态网页内容，...
通信仿真-JavaWeb-mast开发笔记
06-18
Java Persistence API (JPA) 和Hibernate是常用的ORM（对象关系映射）框架，它们允许开发者以面向对象的方式操作数据库，简化数据库访问的复杂性。 在通信仿真的具体实现上，可能会用到Socket编程。Java的Socket类...
Javaweb项目源码-编程爱好者博客地带.zip
05-23
JavaWeb是指使用Java技术来开发Web应用程序，它包含了Servlet、JSP（JavaServer Pages）、JSTL（JavaServer Pages Standard Tag Library）等核心组件。这些技术允许开发者创建动态、交互式的网页应用。 在本项目中...
hibernate开发核心5.2jar包 带mysql驱动
06-11
在这个压缩包中，包含的是用于开发的Hibernate核心库以及适用于MySQL数据库的驱动，同时整合了log4j日志框架，这些都是构建高效、稳定且可维护的JavaWeb应用的基础组件。 1. Hibernate 5.2：作为ORM框架的领导者，...
-javaweb人才招聘网站.zip
07-03
【标题】"-javaweb人才招聘网站.zip" 暗示了这个项目是一个基于Java Web技术构建的人才招聘平台。这种类型的系统通常涉及到用户注册、职位发布、简历投递、面试安排等一系列功能，旨在帮助企业和求职者进行有效的...
【spring 官方ORM框架】spring-data-jpa详细教程
追寻上飞的博客
07-11 1369
框架支持两种查询方法，其一是根据方法名派生，又叫做命名查询，无需写SQL语言；其二是使用注解，又称为注解查询。下表是命名查询支持的方法名及其对应的持久化查询语句。, ,,, , (参数后追加) (参数前追加 ) (参数封装在 内)参数支持数组和可变参数类型参数支持数组和可变参数类型？是占位符，解释后面的数字代表的参数，称为基于位置的参数。 2.2.2 like用法 %表示like表达式的占位符。 2.2.3 命名参数 默认使用基于位置的参数，也可以使用下述命名参数。这种方式写的太复杂，没有基于位置的好用。
Spring Data JPA详细使用教程
子月生的博客
09-03 1874
Spring Data JPA详细使用教程 简介 Spring Data提供了针对数据库（包括SQL和NOSQL）的整合方案，对Hibernate JPA、Jedis等工具的api进行高级的封装，为我们提供简单方便地操作接口。 Spring Data JPA 是Spring Data项目下的一个模块。整合了基于JPA的持久层框架（默认Hibernate JPA），并对API进行了封装，让我们可以更...
Spring Data JPA详解
JAVA_KX的博客
05-16 2759
Spring Data是持久层通用解决方案，支持关系型数据库 Oracle、MySQL、非关系型数据库NoSQL、Map-Reduce 框架、云基础数据服务 、搜索服务等。
Spring Data Jpa底层原理剖析、JPQL查询、方法命名规则查询
huangyh技术栈
12-23 5856
1.1 Spring Data Jpa底层原理解析  目标：知道它是怎么运行的？底层到底封装的是谁？、 明确一点：我们所使用的所有框架，底层大多数都使用了动态代理技术、反射技术来封装实现。  分析步骤： 我们只写了接口，但是没有写实现类，这个实现类就是Spring在运行的时候，注入的代理对象。 Spring怎么知道生成的那个dao的实现类？因为在配置文件中指定了dao接口所在的...
Spring Data JPA教程
YunWisdom
03-12 1336
Spring Data JPA教程 Spring Data JPA是Spring Data系列的一部分。Spring Data可以更轻松地创建使用新方法访问数据的Spring驱动应用程序，例如非关系数据库，地图缩减框架，云服务以及高级关系数据库支持。本文将讨论Spring Data JPA。我们还将研究Spring Data JPA示例应用程序。 目录[隐藏] 1Sprin...
spring Data Jpa 基本使用
z616026782的专栏
10-15 817
spring Data Jpa 基本使用 Spring Data JPA 基本使用 大体内容 一、 创建SpringDataJPA项目 1 导入依赖 2 配置数据源信息 3 编写Dao 4 user 5 编写测试代码 二、 Spring Data JPA 的接口继承结构 三、 Spring Data JPA 的运行原理 四、 Repository 接口 1 方法名称命名规则查询 2 基于@Query 注解的查询 2.1通过 JPQL 语句查询 2.2通过 SQL 语句查询
这是一个火车售票管理系统_train-tickets.zip
最新发布
08-25
这是一个火车售票管理系统_train-tickets
JavaWeb开发实战：Struts2.5+Hibernate3.1+Spring深度解析
在Hibernate3.1版本中，主要特性包括对象关系映射（ORM）、事务管理、二级缓存、查询语言（HQL）和 Criteria API。Hibernate通过XML或注解方式将Java对象映射到数据库表，从而避免了编写大量的SQL代码，提升了开发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值