JPA 相关API

Posted 2020-10-22 BeforeYou

【Query 接口下的常用API】

【API 测试类:Test_QueryAPI.java】

  1 package org.zgf.jpa.entity;  
  2   
  3 import java.math.BigInteger;  
  4 import java.util.Calendar;  
  5 import java.util.Date;  
  6 import java.util.List;  
  7   
  8 import javax.persistence.Query;  
  9 import javax.persistence.TemporalType;  
 10   
 11 import org.junit.Test;  
 12 import org.zgf.jpa.enumer.Gender;  
 13 /** 
 14  * JPA 中sql 语句设置参数有两种形式，一种是命名参数，另一种是位置参数： 
 15  * 位置参数：执行效率高， 可读性差，可用于原生sql 和 JPQL 语句中， 格式《？+数字》，数字可任意指定  
 16  * 命名参数：执行效率低 ，可读性强，可用于原生sql 和 JPQL 语句中, 格式《：+ 名称》，名称自定义 
 17  *  
 18  * @Description: 测试Query接口的相关API 
 19  * @author zonggf 
 20  * @date 2015年11月4日-下午4:07:12 
 21  */  
 22 public class Test_QueryAPI extends BasicJPATest{  
 23       
 24     //2. Test API 1: 测试返回列表API  
 25     @Test  
 26     public void test_getResultList(){  
 27         String jpql = "from PersonEntity";  
 28         Query query = this.entityManager.createQuery(jpql);  
 29         List<PersonEntity> personEntityList = query.getResultList();  
 30         for (PersonEntity personEntity : personEntityList) {  
 31             System.out.println(personEntity);  
 32         }  
 33     }  
 34       
 35     //2. Test API 2: 使用query.getSingleResult（）方式时，必须保证查询的结果有且只有一个返回对象  
 36     @Test  
 37     public void test_getSingleResult(){  
 38         String jpql = "from PersonEntity personEntity where personEntity.id = 1";  
 39         Query query =  this.entityManager.createQuery(jpql);  
 40         PersonEntity personEntity = (PersonEntity) query.getSingleResult();  
 41         System.out.println(personEntity);  
 42     }  
 43       
 44     //2. Test API 2: 如果没有返回对象，则会抛出异常 NoResultException.class  
 45     @Test(expected=javax.persistence.NoResultException.class)  
 46     public void test_getSingleResult_Exception(){  
 47         String jpql = "from PersonEntity personEntity where personEntity.id = 100";  
 48         Query query =  this.entityManager.createQuery(jpql);  
 49         PersonEntity personEntity = (PersonEntity) query.getSingleResult();  
 50         System.out.println(personEntity);  
 51     }  
 52       
 53     //2. Test API 2: 如果有多个返回对象，则会抛出异常 NonUniqueResultException.class  
 54     @Test(expected=javax.persistence.NonUniqueResultException.class)  
 55     public void test_getSingleResult_Exception_(){  
 56         String jpql = "from PersonEntity";  
 57         Query query =  this.entityManager.createQuery(jpql);  
 58         PersonEntity personEntity = (PersonEntity) query.getSingleResult();  
 59         System.out.println(personEntity);  
 60     }  
 61       
 62       
 63     //3. Test API 3: 测试位置参数使用方法  
 64     @Test  
 65     public void test_setPositionParameter(){  
 66         String jpql = "from PersonEntity personEntity where personEntity.id = ?1";  
 67         Query query = this.entityManager.createQuery(jpql);  
 68         query.setParameter(1, 1);  
 69         PersonEntity personEntity = (PersonEntity) query.getSingleResult();  
 70         System.out.println(personEntity);  
 71           
 72     }  
 73       
 74     //3. Test API 3: 测试位置参数使用方法，参数类型为java.util.Date  
 75     @Test  
 76     public void test_setPositionParameter_date(){  
 77         String sql = "select count(*) from tb_person p where p.birthdayDate = ?2";  
 78         Query query = this.entityManager.createNativeQuery(sql);  
 79         query.setParameter(2,new Date(), TemporalType.DATE);  
 80         //注意此处返回的是BigInteger 类型， 不是Int类型  
 81         BigInteger count = (BigInteger) query.getSingleResult();  
 82         System.out.println("共有记录：" + count);  
 83     }  
 84       
 85     //3. Test API 3: 测试位置参数使用方法, 参数类型为 java.util.Calendar;  
 86     @Test  
 87     public void test_setPositionParameter_calender(){  
 88         String sql = "select count(*) from tb_person p where p.birthdayDate = ?2";  
 89         Query query = this.entityManager.createNativeQuery(sql);  
 90         query.setParameter(2,Calendar.getInstance(), TemporalType.DATE);  
 91         //注意此处返回的是BigInteger 类型， 不是Int类型  
 92         BigInteger count = (BigInteger) query.getSingleResult();  
 93         System.out.println("共有记录：" + count);  
 94     }  
 95       
 96     //Test API 4: 测试命名参数：参数类型为普通参数  
 97     @Test  
 98     public void test_setNameParameter(){  
 99         String jpql = "from PersonEntity personEntity where personEntity.id = :id";  
100         Query query = this.entityManager.createQuery(jpql);  
101         query.setParameter("id", 1);  
102         PersonEntity personEntity = (PersonEntity) query.getSingleResult();  
103         System.out.println(personEntity);  
104     }  
105       
106     //Test API 4: 测试命名参数:参数类型为java.util.Date  
107     @Test  
108     public void test_setNameParameter_date(){  
109         String sql = "select count(*) from tb_person p where p.birthdayDate = :birthDate";  
110         Query query = this.entityManager.createNativeQuery(sql);  
111         query.setParameter("birthDate",new Date(), TemporalType.DATE);  
112         //注意此处返回的是BigInteger 类型， 不是Int类型  
113         BigInteger count = (BigInteger) query.getSingleResult();  
114         System.out.println("共有记录：" + count);  
115     }  
116       
117     //Test API 4: 测试命名参数:参数类型为java.util.Calendar  
118     @Test  
119     public void test_setNameParameter_calender(){  
120         String sql = "select count(*) from tb_person p where p.birthdayDate = :birthDate";  
121         Query query = this.entityManager.createNativeQuery(sql);  
122         query.setParameter("birthDate",Calendar.getInstance(), TemporalType.DATE);  
123         //注意此处返回的是BigInteger 类型， 不是Int类型  
124         BigInteger count = (BigInteger) query.getSingleResult();  
125         System.out.println("共有记录：" + count);  
126     }  
127       
128     //Test API 5: excuteUpdate 用于执行更新更新，删除语句或者DDL语句  
129     @Test  
130     public void test_excuteUpdate_clear(){  
131         String jpql = "delete PersonEntity";  
132         Query query = this.entityManager.createQuery(jpql);  
133         int deleteCnt = query.executeUpdate();  
134         System.out.println("共删除记录条数：" + deleteCnt);  
135     }  
136       
137     //Test API 5: excuteUpdate 执行DDL 语句删除表  
138     @Test  
139     public void test_excuteUpdate_drop(){  
140         String sql = "drop table tb_person";  
141         Query query = this.entityManager.createNativeQuery(sql);  
142         int cnt = query.executeUpdate();  
143         System.out.println("cnt:" + cnt);  
144     }  
145       
146     //Test API 6: 测试分页数据  
147     @Test  
148     public void test_page(){  
149         String jpql = "from PersonEntity";  
150         Query query = this.entityManager.createQuery(jpql);  
151         query.setFirstResult(10); //序号从0 开始  
152         query.setMaxResults(20);  
153         List<PersonEntity> personList = query.getResultList();  
154         System.out.println("count:" + personList.size());  
155         for (PersonEntity personEntity : personList) {  
156             System.out.println(personEntity);  
157         }  
158     }  
159       
160     //初始化100 条数据  
161     @Test  
162     public void test_savePerson(){  
163         Date date = new Date();  
164         for(int i=0; i<100;  i++){  
165             PersonEntity person = new PersonEntity();  
166             person.setName("zhangsan" + i);  
167             person.setAge(20);  
168             person.setBirthday(date);  
169             person.setBirthdayDate(date);  
170             person.setBirthdayTime(date);  
171             person.setEnglishScore(20.20);  
172             person.setMathScore(89.8f);  
173             person.setGender(Gender.BOY);  
174             person.setInfo("I am a good boy".getBytes());  
175             this.entityManager.persist(person);  
176         }  
177     }  
178       
179 }  

【注意】

1.  JPA 中sql 语句设置参数有两种形式，一种是命名参数，另一种是位置参数：

     位置参数：执行效率高， 可读性差，可用于原生sql 和 JPQL 语句中， 格式《？+数字》，数字可任意指定 也可以不指定，直接用问号
     命名参数：执行效率低 ，可读性强，可用于原生sql 和 JPQL 语句中, 格式《：+ 名称》，名称自定义

2. query.getSigleResult(); 方法必须确保查询结果有且只有一个放回对象。

3. query.excuteUpdate();方法可用于执行更新，删除语句

 

其它涉及类PersonEntity, BasicJPATest 参看 下面

简单实体映射和EntityManagerAPI

【常用注解】

使用JPA 指定映射关系时，有两种方式，一种是使用xml 方式，另一种是注解方式，笔者推荐使用注解方式。在JPA 映射简单实体时，常用的注解如下：

@Entity：修饰实体类对象，表示该实体类对象进行数据库映射

@Table(name="***")：指定实体类对象映射的表名称

@Id： 指定主键

@GeneratedValue(strategy=GenerationType.AUTO)：指定主键生成方式，默认为Auto。

    IDENTITY：采用数据库 ID自增长的方式来自增主键字段，Oracle 不支持这种方式；
    AUTO： JPA自动选择合适的策略，是默认选项；
    SEQUENCE：通过序列产生主键，通过 @SequenceGenerator 注解指定序列名，mysql 不支持这种方式
    TABLE：通过表产生主键，框架借由表模拟序列产生主键，使用该策略可以使应用更易于数据库移植。

@Column(name="s_name",length=20,unique=true,nullable=false, insertable=true, updatable=true)：修饰属性， 指定列名称和相关限制

@Enumerated(EnumType.STRING)：修饰枚举类属性，

                      EnumType.STRING： 指定数据库中存储的是字符串类型, 

                       EnumTypee.ORDINAL:指定数据库 存储的类型为枚举的索引(0,1,2,3...)

@Temporal(TemporalType.TIME)：修饰日期类型：

                       TemporalType.DATE: 指定映射数据库中的DATE 类型，只存储日期

                       TemporalType.TIME: 指定映射数据库 中的TIME类型， 只存储时间

                       TemporalType.TIMESTAMP:指定映射数据库中的TIMESTAMP类型

@Transient：指定不映射的属性

@Lob：修饰 byte[] 数组，二进制文件

@Basic(fetch=FetchType.LAZY) ： 默认注解，如果字段不添加任何注解，则默认添加了此注解。可以通过fetch 属性指定大数据字段延时加载，目前在Hibernate中并未能实现，或许是Hibernate的一个bug。

@NamedQueries({ 
@NamedQuery(name="***",query="*** hql ***"),
@NamedQuery(name="***",query="*** hql ***")
})： 命名查询注解，指定命名查询语句，query字段只能写JPQL 查询语句，不能写普通的sql 语句。

【简单实体对象：PersonEntity.java】

  1 package org.zgf.jpa.entity;  
  2   
  3 import java.util.Date;  
  4   
  5 import javax.persistence.Basic;  
  6 import javax.persistence.Column;  
  7 import javax.persistence.Entity;  
  8 import javax.persistence.EnumType;  
  9 import javax.persistence.Enumerated;  
 10 import javax.persistence.FetchType;  
 11 import javax.persistence.GeneratedValue;  
 12 import javax.persistence.GenerationType;  
 13 import javax.persistence.Id;  
 14 import javax.persistence.Lob;  
 15 import javax.persistence.NamedQueries;  
 16 import javax.persistence.NamedQuery;  
 17 import javax.persistence.Table;  
 18 import javax.persistence.Temporal;  
 19 import javax.persistence.TemporalType;  
 20 import javax.persistence.Transient;  
 21   
 22 import org.zgf.jpa.enumer.Gender;  
 23   
 24   
 25   
 26 @Table(name="tb_person")  
 27 @Entity  
 28 @NamedQueries({ //命名查询注解：只能写JPQL 语句  
 29     @NamedQuery(name="queryAllByJpql",query="from PersonEntity personEntity"),  
 30     @NamedQuery(name="queryByName",query="from PersonEntity personEntity where personEntity.name = :name")  
 31 })  
 32 public class PersonEntity {  
 33       
 34     /** 
 35      * 测试主键生成策略  
 36      * GenerationType.AUTO: 根据数据库的默认规则来生成主键 
 37      * GenerationType.IDENTITY:数据库自增(mysql 适用，Oracle不适用）                                                                                                         
 38      * GenerationType.SEQUENCE:序列生成方式，（Oracle适用，mysql 不适用） 
 39      */  
 40     @Id  
 41     @GeneratedValue(strategy=GenerationType.AUTO)  
 42     private Integer id;  
 43       
 44     /*** 
 45      * 数据库字段限制：  
 46      * Column可以指定数据库 字段的名称 ，长度，唯一性，是否可以为空,是否可以插入，是否可以更新 
 47      */  
 48     @Column(name="s_name",length=20,unique=true,nullable=false, insertable=true, updatable=true)  
 49     private String name;  
 50     private int age;  
 51       
 52     /** 
 53      * 枚举类型： 
 54      * EnumType.STRING： 指定数据库中存储的是字符串类型 
 55      * EnumTypee.ORDINAL:指定数据库 存储的类型为枚举的索引 
 56      */  
 57     @Enumerated(EnumType.STRING)  
 58     private Gender gender;  
 59       
 60     private Double englishScore;  
 61     private Float mathScore;  
 62       
 63     /** 
 64      * 日期类型： TimeStamp 会根据当地的时间做自动转换 
 65      * TemporalType.DATE: 指定映射数据库中的DATE 类型，只存储日期 
 66      * TemporalType.TIME: 指定映射数据库 中的TIME类型， 只存储时间 
 67      * TemporalType.TIMESTAMP:指定映射数据库中的TIMESTAMP类型 
 68      */  
 69     @Temporal(TemporalType.TIME)  
 70     private Date birthdayTime;  
 71     @Temporal(TemporalType.DATE)  
 72     private Date birthdayDate;  
 73     @Temporal(TemporalType.TIMESTAMP)  
 74     private Date birthday;  
 75       
 76     @Lob  //大数据文件  
 77     @Basic(fetch=FetchType.LAZY, optional=true)  //延迟加载为true,貌似是Hibernate的一个bug，并不能实现延迟加载  
 78     private byte[] info;  
 79       
 80     @Transient  //不映射 此字段  
 81     private String transientProperty;  
 82   
 83     public Integer getId() {  
 84         return id;  
 85     }  
 86   
 87     public void setId(Integer id) {  
 88         this.id = id;  
 89     }  
 90   
 91     public String getName() {  
 92         return name;  
 93     }  
 94   
 95     public void setName(String name) {  
 96         this.name = name;  
 97     }  
 98   
 99     public int getAge() {  
100         return age;  
101     }  
102   
103     public void setAge(int age) {  
104         this.age = age;  
105     }  
106   
107     public Gender getGender() {  
108         return gender;  
109     }  
110   
111     public void setGender(Gender gender) {  
112         this.gender = gender;  
113     }  
114   
115     public Double getEnglishScore() {  
116         return englishScore;  
117     }  
118   
119     public void setEnglishScore(Double englishScore) {  
120         this.englishScore = englishScore;  
121     }  
122   
123     public Float getMathScore() {  
124         return mathScore;  
125     }  
126   
127     public void setMathScore(Float mathScore) {  
128         this.mathScore = mathScore;  
129     }  
130   
131     public Date getBirthdayTime() {  
132         return birthdayTime;  
133     }  
134   
135     public void setBirthdayTime(Date birthdayTime) {  
136         this.birthdayTime = birthdayTime;  
137     }  
138   
139     public Date getBirthdayDate() {  
140         return birthdayDate;  
141     }  
142   
143     public void setBirthdayDate(Date birthdayDate) {  
144         this.birthdayDate = birthdayDate;  
145     }  
146   
147     public Date getBirthday() {  
148         return birthday;  
149     }  
150   
151     public void setBirthday(Date birthday) {  
152         this.birthday = birthday;  
153     }  
154   
155     public byte[] getInfo() {  
156         return info;  
157     }  
158   
159     public void setInfo(byte[] info) {  
160         this.info = info;  
161     }  
162   
163     public String getTransientProperty() {  
164         return transientProperty;  
165     }  
166   
167     public void setTransientProperty(String transientProperty) {  
168         this.transientProperty = transientProperty;  
169     }  175       
176 }  

【EntityManger 常用API 使用方法：Test_PersonEntity.java】

  1 package org.zgf.jpa.entity;  
  2   
  3 import java.util.ArrayList;  
  4 import java.util.Date;  
  5 import java.util.List;  
  6   
  7 import javax.persistence.Query;  
  8   
  9 import org.junit.Test;  
 10 import org.zgf.jpa.enumer.Gender;  
 11 /** 
 12  * @Description: 主要测试EntityManager类提供的常用接口 
 13  * @author zonggf 
 14  * @date 2015年11月4日-下午3:38:14 
 15  */  
 16 public class Test_PersonEntity extends BasicJPATest {  
 17       
 18     private PersonEntity getPersonEntity(){  
 19         Date date = new Date();  
 20         PersonEntity person = new PersonEntity();  
 21         person.setName("zhangsan");  
 22         person.setAge(20);  
 23         person.setBirthday(date);  
 24         person.setBirthdayDate(date);  
 25         person.setBirthdayTime(date);  
 26         person.setEnglishScore(20.20);  
 27         person.setMathScore(89.8f);  
 28         person.setGender(Gender.BOY);  
 29         StringBuffer sb = new StringBuffer();  
 30         for(int i=0; i<100;i++){  
 31             sb.append("heladn asndsk nasfjgnas nsd gaksn a sdnkg asdn asndk asnd  ansf asd n  asngjka s");  
 32         }  
 33         person.setInfo(sb.toString().getBytes());  
 34         return person;  
 35     }  
 36       
 37     //Test API 1： 测试persiste  
 38     @Test  
 39     public void test_persist(){  
 40         PersonEntity personEntity = getPersonEntity();  
 41         this.entityManager.persist(personEntity);  
 42     }  
 43       
 44     //Test API 2：测试remove接口  
 45     @Test  
 46     public void test_remove_right(){  
 47         //正确删除方式，必须先从数据库中查询，然后再进行删除，而且查询结果不能为空  
 48         PersonEntity personEntity = new PersonEntity();  
 49         personEntity.setId(3);  
 50         personEntity = this.entityManager.find(PersonEntity.class, personEntity.getId());  
 51         if(null != personEntity){  
 52             this.entityManager.remove(personEntity);;  
 53         }  
 54     }  
 55       
 56     //Test API 2：测试remove接口  
 57     @Test(expected=java.lang.IllegalArgumentException.class)  
 58     public void test_remove_wrong(){  
 59         //如果是自己创建的实体 对象，使用remove方式的时候，将会报错  
 60         PersonEntity personEntity = getPersonEntity();  
 61         personEntity.setId(3);  
 62         this.entityManager.remove(personEntity);;  
 63     }  
 64       
 65     //Test API 3：测试mege 接口  
 66     @Test  
 67     public void test_merge(){  
 68         //先根据主键进行查询，然后根据主键进行更新  
 69         PersonEntity personEntity = getPersonEntity();  
 70         personEntity.setId(7);  
 71         personEntity.setName("zhangsan_merge" + 172);  
 72         this.entityManager.merge(personEntity);  
 73     }  
 74       
 75     //Test API 4：测试find 接口  
 76     @Test  
 77     public void test_find(){  
 78         //find 方法，是根据主键进行查询的，所以传的参数必须是主键  
 79         int id = 5;  
 80         PersonEntity person = this.entityManager.find(PersonEntity.class, id);  
 81         System.out.println(person);  
 82     }  
 83       
 84       
 85     //Test API 5：测试createQuery(String jpql)接口  
 86     @Test  
 87     public void test_createQuery_String(){  
 88         String jpql = "from PersonEntity personEntity";  
 89         Query query = this.entityManager.createQuery(jpql);  
 90         List<PersonEntity> personList = query.getResultList();  
 91         for (PersonEntity personEntity : personList) {  
 92             System.out.println(personEntity);  
 93         }  
 94     }  
 95       
 96     //Test API 6：测试命名查询  
 97     @Test  
 98     public void test_namedQuery_jpql(){  
 99         String namedQueryName = "queryByName";  
100         Query query = this.entityManager.createNamedQuery(namedQueryName);  
101         //设置命名参数  
102         query.setParameter("name", "zhangsan");  
103         PersonEntity person = (PersonEntity) query.getSingleResult();  
104         System.out.println(person);  
105     }  
106       
107     //Test API 7：测试createNativeQuery(String sql)接口  
108     @Test  
109     public void test_sqlQuery(){  
110         List<PersonEntity> personList = new ArrayList<>();  
111         String sql = "select p.id, p.s_name, p.age from tb_person p";  
112         Query query = this.entityManager.createNativeQuery(sql);  
113         List list = query.getResultList();  
114         for(int i=0;i<list.size(); i++){  
115             PersonEntity person = new PersonEntity();  
116             Object[] objectArray = (Object[]) list.get(i);  
117             person.setId((Integer)objectArray[0]);  
118             person.setName((String)objectArray[1]);  
119             person.setAge((Integer)objectArray[2]);  
120             personList.add(person);  
121         }  
122         for(PersonEntity personEntity: personList){  
123             System.out.println(personEntity);  
124         }  
125     }  
126 }  

【辅助类：Gender.java】

 1 package org.zgf.jpa.enumer;  
 2 /** 
 3  * @Description: 枚举类，映射到数据库中的是BOY 而不是"男" 
 4  * @author zonggf 
 5  * @date 2015年11月4日-下午3:39:36 
 6  */  
 7 public enum Gender {  
 8   
 9     BOY("男"),GIRL("女");  
10       
11     private String gender;  
12       
13     Gender(String gender){  
14         this.gender = gender;  
15     }  
16       
17     public static Gender getGender(String gender){  
18         Gender[] genderEnumers = Gender.values();  
19         for (Gender genderEnumer : genderEnumers) {  
20             if(null != gender){  
21                 if(gender.equals(genderEnumer.toString())){  
22                     return genderEnumer;  
23                 }  
24             }  
25         }  
26         return null;  
27     }  
28       
29     @Override  
30     public String toString() {  
31         return this.gender;  
32     }  
33 }  

【辅助类：BasicJPATest.java】

 1 package org.zgf.jpa.entity;  
 2   
 3   
 4 import javax.persistence.EntityManager;  
 5 import javax.persistence.EntityManagerFactory;  
 6 import javax.persistence.Persistence;  
 7 import javax.persistence.Query;  
 8   
 9 import org.junit.After;  
10 import org.junit.Before;  
11 import org.junit.Test;  
12 /** 
13  * 这是一个JPA 的测试类，  该类的功能如下： 
14  * 1. 在每个测试方法之前调用setup 方法，开启事务并获取entityManager 对象。 
15  * 2. 在每个测试方法之后调用teardown 方法， 提交事务，并关闭entityManager 对象 
16  * @author Silence 
17  */  
18 public abstract class BasicJPATest {  
19     protected EntityManagerFactory entityManagerFactory;  
20     protected EntityManager entityManager;  
21           
22     //子类的每个测试方法之前都会调用  
23     @Before  
24     public void setup(){  
25         this.entityManagerFactory = Persistence.createEntityManagerFactory("myJPA");  
26         this.entityManager = this.entityManagerFactory.createEntityManager();  
27         this.entityManager.getTransaction().begin();  
28     }  
29       
30     //子类的每个测试方法之后都会调用  
31     @After  
32     public void tearDown(){  
33         try{  
34             this.entityManager.getTransaction().commit();  
35         }catch(Exception ex){  
36             System.out.println("提交事务等阶段出现了错误哦");  
37         }finally{  
38             this.entityManager.close();  
39             this.entityManagerFactory.close();  
40         }  
41           
42     }  
43       
44     @Test  
45     public void testCreateTables(){  
46         System.out.println("数据库表创建成功。。。");  
47     }  
48       
49     public void recoverData(){  
50         //清空表  
51         String deleteSql = "delete Person";  
52         Query query = this.entityManager.createQuery(deleteSql);  
53         query.executeUpdate();  
54           
55     }  
56 }  

【注意】

1. @Basic(fetch=FetchType.LAZY) 注解在Hibernate 中不能实现，貌似是Hibernate 的一个bug

2. @Enumerated(EnumType.STRING) 注解映射的是枚举类的Key ，不是value