JDBC步骤：（连接前提导入驱动jar） 1.反射获取驱动 2.获得连接对象，get方法获取数据库连接（传参数=》数据库连接地址，用户名，密码） 3…创建Sql语句（利用占位符填充） 4.获取执行sql语句的对象Statement
1、执行静态SQL语句。通常通过Statement实例实现。 2、执行动态SQL语句。通常通过PreparedStatement实例实现。 3、执行数据库存储过程。通常通过CallableStatement实例实现。
5.执行SQL语句，接受返回结果
Statement接口提供了三种执行SQL语句的方法： executeQuery 、executeUpdate和execute
6.处理结果（处理结果集） 7. 释放资源
具体实现可看如下博客： https://blog.csdn.net/jungle_rao/article/details/81274720
写下来：操作繁琐，代码冗余，硬编码 后来抽取出DBUtils，代码冗余减少，但是依旧占位符以及硬编码 具体实现可看： https://www.cnblogs.com/CQY1183344265/p/5854418.html
所以出现了ORM思想，对象关系映射(英语:(Object Relational Mapping）来解决以上的问题，具体实现大致为通过操控实体类和表的关系，实体类的属性和表的字段的关系形成一种关系完成映射。
典型代表Mybatis（ibatis）、Hibernate、Jpa 重点在于映射形成关联关系：无论是半自动的Mybatis还是全自动的Hibernate
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。性能比起Mybaits会差一点，擅长单表操作，多表相对复杂一点。
JPA的全称是Java Persistence API， 即Java 持久化API，是SUN公司推出的一套基于ORM的规范，内部是由一系列的接口和抽象类构成。
JPA通过JDK 5.0注解描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。
标准化 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规范本质上就是一种ORM规范，注意不是ORM框架——因为JPA并未提供ORM实现，它只是制订了一些规范，提供了一些编程的API接口，但具体实现则由服务厂商来提供实现。 JPA和Hibernate的关系就像JDBC和JDBC驱动的关系，JPA是规范，Hibernate除了作为ORM框架之外，它也是一种JPA实现。JPA怎么取代Hibernate呢？JDBC规范可以驱动底层数据库吗？答案是否定的，也就是说，如果使用JPA规范进行数据库操作，底层需要hibernate作为其实现类完成数据持久化工作，但并非只能使用hibernate。
1.数据库建库建表 2.建工程，可建maven工程导入坐标 3.需要配置jpa的核心配置文件
位置：配置到类路径下的一个叫做 META-INF 的文件夹下命名：persistence.xml4.编写实体类 5.配置实体类和表，类中属性和表中字段的映射关系 6.保存实体类对象到数据库中
由于JPA是sun公司制定的API规范，所以我们不需要导入额外的JPA相关的jar包，只需要导入JPA的提供商的jar包。我们选择Hibernate作为JPA的提供商，所以需要导入Hibernate的相关jar包。
现在hibernate最新版本是5.8即大版本依旧是5版本： 所以我们可以使用5的任意版本的学习，我们以下为下载地址=》 https://sourceforge.net/projects/hibernate/files/hibernate-orm/5.0.7.Final/
所需导入jar包 1.在Mysql中建立一个jpa库用作本次学习的数据库，然后创建一个客户表 新建查询，执行以下sql脚本：
/*创建客户表*/ 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;2.创一个maven工程：new project=>maven然后直接next
使用maven工程导入坐标：锁定版本的pom依赖
<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>3.配置到类路径下(Maven工程默认是resources)的一个叫做 META-INF 的文件夹下,persistence.xml： persistence.xml：（数据库名，url和密码改为自己的）
<?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"> <!--配置持久化单元 persistence-unit 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="root3306" /> <!--jpa提供者的可选配置：我们的JPA规范的提供者为hibernate，所以jpa的核心配置中兼容hibernate的配 --> <property name="hibernate.show_sql" value="true" /> <property name="hibernate.format_sql" value="true" /> <property name="hibernate.hbm2ddl.auto" value="create"/> </properties> <!--可选配置，配置jpa实现方式的配置信息--> </persistence-unit> </persistence>4.编写实体类
package com.tho.domain; public class Customer { private Long custId;//客户主键 private String custName;//客户名称 private String custSource;//客户来源 private String custIndustry;//客户所属行业 private String custLevel;//客户级别 private String custAddress;//客户地址 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; } }5.配置上实体类和表，类中属性和表中字段的映射关系
package com.tho.domain; import javax.persistence.*; /** * * 所有的注解都是使用JPA的规范提供的注解， * * 所以在导入注解包的时候，一定要导入javax.persistence下的 */ @Entity //声明实体类 @Table(name="cst_customer") //建立实体类和表的映射关系 public class Customer { @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; } }常用注解的说明
@Entity 作用：指定当前类是实体类。 @Table 作用：指定实体类和表之间的对应关系。 属性： name：指定数据库表的名称 @Id 作用：指定当前字段是主键。 @GeneratedValue 作用：指定主键的生成方式。。 属性： strategy ：指定主键生成策略。 @Column 作用：指定实体类属性和数据库表之间的对应关系 属性： name：指定数据库表的列名称。 unique：是否唯一 nullable：是否可以为空 inserttable：是否可以插入 updateable：是否可以更新 columnDefinition: 定义建表时创建此列的DDL secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字搭建开发环境[重点]
6.保存实体类对象到数据库中(使用单元测试，在实际开发中也应该先使用单元测试先，然后完成框架之间的整合) 在test根目录下创建com.tho.test包，再创建测试类JpaTest:
package com.tho.test; import com.tho.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 { /** * 测试jpa的保存： * 案例：保存一个客户到数据库中 * Jpa操作的步骤： * 1.加载配置文件创建工厂（实体管理器工厂）对象 * 2.通过实体管理器工厂获取实体管理器 * 3.获取事务对象，开启事务 * 4.完成增删改查操作 * 5.提交事务（回滚事务） * 6.释放资源 */ @Test public void testSave(){ // 1.加载配置文件创建工厂（实体管理器工厂）对象 final EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa"); // 2.通过实体管理器工厂获取实体管理器 EntityManager em = factory.createEntityManager(); // 3.获取事务对象，开启事务 EntityTransaction tx = em.getTransaction(); tx.begin();//开启事务 // 4.完成增删改查操作，保存一个客户到我们的数据库里 Customer customer = new Customer(); customer.setCustName("calmtho"); customer.setCustIndustry("IT"); //保存操作 em.persist(customer); // 5.提交事务（回滚事务） tx.commit(); // 6.释放资源 em.close(); factory.close(); } }debug看看： 入门案例成功，由于我们配置了create，所以会先删表再创表再插入，每次插入之前的数据都会没掉，可以试一下改成update: 显示sql ： false,true 自动创建数据库表： hibernate.hbm2ddl.auto create :程序运行时创建表（如果有表，先删了再创建） update : 程序运行时更新表（如果有表，不会创建表） none : 不会创建表
通过annotation（注解）来映射hibernate实体的,基于annotation的hibernate主键标识为@Id, 其生成规则由@GeneratedValue设定的.这里的@id和@GeneratedValue都是JPA的标准用法
JPA提供的四种标准用法为TABLE,SEQUENCE,IDENTITY,AUTO。
IDENTITY:主键由数据库自动生成（主要是自动增长型） @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long custId; SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列。 @Id @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="payablemoney_seq") @SequenceGenerator(name="payablemoney_seq", sequenceName="seq_payment") private Long custId;SEQUENCE源码
//@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：主键由程序控制（通过配置的数据库决定mysql就自增，oracle就序列化） @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) )由于我们使用的是Mysql，所以只能演示其中3种，而AUTO和IDENTITY相对Mysql来说是一样的，所以也不演示了，我们来演示以下TABLE的生成方式： 首先配置表：create，让JPA给我们生成表 然后主键策略配置为:TABLE debug运行：控制台生成的日志可看执行过程
Hibernate: drop table if exists cst_customer Hibernate: drop table if exists hibernate_sequences Hibernate: create table cst_customer ( cust_id bigint not null, cust_address varchar(255), cust_industry varchar(255), cust_level varchar(255), cust_name varchar(255), cust_phone varchar(255), cust_source varchar(255), primary key (cust_id) ) Hibernate: create table hibernate_sequences ( sequence_name varchar(255) not null, next_val bigint, primary key (sequence_name) ) Hibernate: select tbl.next_val from hibernate_sequences tbl where tbl.sequence_name=? for update Hibernate: insert into hibernate_sequences (sequence_name, next_val) values (?,?) Hibernate: update hibernate_sequences set next_val=? where next_val=? and sequence_name=? Hibernate: insert into cst_customer (cust_address, cust_industry, cust_level, cust_name, cust_phone, cust_source, cust_id) values (?, ?, ?, ?, ?, ?, ?)
Persistence对象主要作用是用于获取EntityManagerFactory对象的 。通过调用该类的createEntityManagerFactory静态方法，根据配置文件中持久化单元名称创建EntityManagerFactory。
//1. 创建 EntitymanagerFactory @Test String unitName = "myJpa"; EntityManagerFactory factory= Persistence.createEntityManagerFactory(unitName);EntityManagerFactory 接口主要用来创建 EntityManager 实例
//创建实体管理类 EntityManager em = factory.createEntityManager();由于EntityManagerFactory 是一个线程安全的对象（即多个线程访问同一个EntityManagerFactory 对象不会有线程安全问题)，并且EntityManagerFactory 的创建极其浪费资源，所以在使用JPA编程时，我们可以对EntityManagerFactory 的创建进行优化，只需要做到一个工程只存在一个EntityManagerFactory 即可
在 JPA 规范中, EntityManager是完成持久化操作的核心对象。实体类作为普通 java对象，只有在调用 EntityManager将其持久化后才会变成持久化对象。EntityManager对象在一组实体类与底层数据源之间进行 O/R 映射的管理。它可以用来管理和更新 Entity Bean, 根椐主键查找 Entity Bean, 还可以通过JPQL语句查询实体。
我们可以通过调用EntityManager的方法完成获取事务，以及持久化数据库的操作
方法说明：
getTransaction : 获取事务对象 persist ： 保存操作 merge ： 更新操作 remove ： 删除操作 find/getReference ： 根据id查询在 JPA 规范中, EntityTransaction是完成事务操作的核心对象，对于EntityTransaction在我们的java代码中承接的功能比较简单
begin：开启事务 commit：提交事务 rollback：回滚事务persist ： 保存 merge ： 更新 remove ： 删除 find/getRefrence ： 根据id查询
改造JpaTest测试：
package com.tho.test; import com.tho.domain.Customer; import com.tho.utils.JpaUtils; import org.junit.Test; import javax.persistence.EntityManager; import javax.persistence.EntityTransaction; public class JpaTest { /** * 测试jpa的保存： * 案例：保存一个客户到数据库中 * Jpa操作的步骤： * 1.加载配置文件创建工厂（实体管理器工厂）对象 * 2.通过实体管理器工厂获取实体管理器 * 3.获取事务对象，开启事务 * 4.完成增删改查操作 * 5.提交事务（回滚事务） * 6.释放资源 */ @Test public void testSave(){ /* // 1.加载配置文件创建工厂（实体管理器工厂）对象 final 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("calmtho"); customer.setCustIndustry("IT"); customer.setCustPhone("13013013013"); //保存操作 em.persist(customer); // 5.提交事务（回滚事务） tx.commit(); // 6.释放资源 em.close(); //改造后不关 //factory.close(); } }id改为自增策略，create方式生成表，运行测试。
tableid表还在，但实际并不依赖于table，只是因为没有映射关系，create并没有删出它，这不是这个案例重点，我专门多赋值了电话属性，就是为了做比较，显示我们的工具类使用成功。
JpaTest加入下面代码，然后改为update方式：
/** * 测试id查询功能 */ @Test public void testFind(){ //通过工具类获取EntityManager对象 EntityManager entityManager = JpaUtils.getEntityManager(); //获取事务对象 EntityTransaction transaction = entityManager.getTransaction(); //开启事务 transaction.begin(); //查询操作 Customer customer = entityManager.find(Customer.class, 1L); System.out.println(customer); //提交事务 transaction.commit(); //关闭资源 entityManager.close(); }给Custom对象加入toString方法，debug运行：
JpaTest种，创建testReference，调用方法从find，改为getReference
/** * 测试id查询功能 */ @Test public void testReference(){ //通过工具类获取EntityManager对象 EntityManager entityManager = JpaUtils.getEntityManager(); //获取事务对象 EntityTransaction transaction = entityManager.getTransaction(); //开启事务 transaction.begin(); //查询操作 Customer customer = entityManager.getReference(Customer.class, 1L); System.out.println(customer); //提交事务 transaction.commit(); //关闭资源 entityManager.close(); }debug一下，看着结果和使用find很像！
是直接生成Customer对象
debug一下，我们不难发现getReference生成的对象是一个动态代理对象,上面的图是其中几步。在getReference后并不会直接开启查询语句，并不是一个实际的Customer对象，而是在使用时才会真正去数据库查询。即使用getReference为延迟加载，也可称为懒加载。（特点为得到动态代理对象）
删除用户前需要先查询到对象，才执行删除，这是面向对象的特征，而Mybatis则是可以where id=#{id}传入id进行删除。
/** * 测试删除功能 */ @Test public void testDelete(){ //通过工具类获取EntityManager对象 EntityManager entityManager = JpaUtils.getEntityManager(); //获取事务对象 EntityTransaction transaction = entityManager.getTransaction(); //开启事务 transaction.begin(); //先根据id查询，再删除 Customer customer = entityManager.getReference(Customer.class, 1L); entityManager.remove(customer); //System.out.println(customer); //提交事务 transaction.commit(); //关闭资源 entityManager.close(); }debug运行一下。
由于还有更新操作，所以还是需要数据，可以运行至此的保存，可以手动建一条： 数据有了以后就开始写案例：
添加测试更新方法testUpdate()： /** * 测试更新功能 */ @Test public void testUpdate(){ //通过工具类获取EntityManager对象 EntityManager entityManager = JpaUtils.getEntityManager(); //获取事务对象 EntityTransaction transaction = entityManager.getTransaction(); //开启事务 transaction.begin(); //先根据id查询对象，给对象设置值，再更新 Customer customer = entityManager.getReference(Customer.class, 1L); //给对象传值 customer.setCustIndustry("IT"); customer.setCustName("calm"); customer.setCustPhone("12345"); //使用实体管理类将对象更新 entityManager.merge(customer); //System.out.println(customer); //提交事务 transaction.commit(); //关闭资源 entityManager.close(); }
sql：查询的是表和表中的字段 jpql：查询的是实体类和类中的属性
jpql和sql语句的语法相似,不同的是jpql是使用用面对对象的思想去操作，最大区别就是查询时候的区别。先给数据库手动加多两条记录： 创JpqlTest类，上代码
package com.tho.test; import com.tho.utils.JpaUtils; import org.junit.Test; import javax.persistence.EntityManager; import javax.persistence.EntityTransaction; import javax.persistence.Query; import java.util.List; /** * jpql查询 */ public class JpqlTest { /** * 查询全部： * sql: from com.tho.domain.Customer * jpql: select * from cst_customer */ @Test public void testFindAll(){ //通过工具类获取EntityManager对象 EntityManager em =JpaUtils.getEntityManager(); //获取事务对象 EntityTransaction tx = em.getTransaction(); //开启事务 tx.begin(); //执行查询所有 Query query = em.createQuery("from com.tho.domain.Customer"); List list = query.getResultList(); for (Object obj:list){ System.out.println(obj); } //提交事务 tx.commit(); //关闭资源 em.close(); } }当然包名是可以省略的！！！直接from Customer也是可以的，前提是已经实体类和表已经做了映射。
倒序查询所有：
/** * 倒序查询全部： * sql: select * from cst_customer order by cust_id desc * jpql: from com.tho.domain.Customer order by custId * */ @Test public void testFindAllByDesc(){ //通过工具类获取EntityManager对象 EntityManager em =JpaUtils.getEntityManager(); //获取事务对象 EntityTransaction tx = em.getTransaction(); //开启事务 tx.begin(); //执行查询所有 String jpql="from com.tho.domain.Customer order by custId desc"; Query query = em.createQuery(jpql); List list = query.getResultList(); for (Object obj:list){ System.out.println(obj); } //提交事务 tx.commit(); //关闭资源 em.close(); }撒花啦，第一天的学习已经学完啦！！加油噢。回顾一下jpa操作步骤：
获得EntityManager 通过EntityManager获得事务对象 事务对象开启事务 执行增删改查操作，一般先执行查询 如果不使用JPQL则用entityManager调用（persist，remove,merge,find/getRefrence） 而使用jpql创建query查询语句 看需求是否要给参数赋值，如占位符，分页参数等 发送查询，获取结果集getResultList/getSingleResult 根据类型处理，看看是否需要遍历 提交事务 捕获异常，回滚事务 关闭资源
上面案例演示遗忘了补抓异常，不过也不是主要的，补充个样例代码吧。
//统计查询 @Test public void findCount() { EntityManager em = null; EntityTransaction tx = null; try { //获取实体管理对象 em = JPAUtil.getEntityManager(); //获取事务对象 tx = em.getTransaction(); tx.begin(); // 查询全部客户 // 1.创建query对象 String jpql = "select count(custId) from Customer"; Query query = em.createQuery(jpql); // 2.查询并得到返回结果 Object count = query.getSingleResult(); // 得到集合返回类型 System.out.println(count); tx.commit(); } catch (Exception e) { // 回滚事务 tx.rollback(); e.printStackTrace(); } finally { // 释放资源 em.close(); } }感谢观看学习，本文综合多方资料，不一一细说，主要参考的还是某马的Spring Data Jpa以及自己的一部分总结整理。
