JPA 简单实体映射和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 语句。

【JPA 常用API】

JPA 简单实体映射和EntityManagerAPI

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

package org.zgf.jpa.entity;

import java.util.Date;

import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Lob;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.persistence.Transient;

import org.zgf.jpa.enumer.Gender;

@Table(name="tb_person")
@Entity
@NamedQueries({ //命名查询注解：只能写JPQL 语句
   @NamedQuery(name="queryAllByJpql",query="from PersonEntity personEntity"),
   @NamedQuery(name="queryByName",query="from PersonEntity personEntity where personEntity.name = :name")
})
public class PersonEntity {

   /**
   * 测试主键生成策略
   * GenerationType.AUTO: 根据数据库的默认规则来生成主键
   * GenerationType.IDENTITY:数据库自增(mysql 适用，Oracle不适用）
   * GenerationType.SEQUENCE:序列生成方式，（Oracle适用，mysql 不适用）
   */
   @Id
   @GeneratedValue(strategy=GenerationType.AUTO)
   private Integer id;

   /***
   * 数据库字段限制：
   * Column可以指定数据库字段的名称，长度，唯一性，是否可以为空,是否可以插入，是否可以更新
   */
   @Column(name="s_name",length=20,unique=true,nullable=false, insertable=true, updatable=true)
   private String name;
   private int age;

   /**
   * 枚举类型：
   * EnumType.STRING：指定数据库中存储的是字符串类型
   * EnumTypee.ORDINAL:指定数据库存储的类型为枚举的索引
   */
   @Enumerated(EnumType.STRING)
   private Gender gender;

   private Double englishScore;
   private Float mathScore;

   /**
   * 日期类型： TimeStamp 会根据当地的时间做自动转换
   * TemporalType.DATE: 指定映射数据库中的DATE 类型，只存储日期
   * TemporalType.TIME: 指定映射数据库中的TIME类型，只存储时间
   * TemporalType.TIMESTAMP:指定映射数据库中的TIMESTAMP类型
   */
   @Temporal(TemporalType.TIME)
   private Date birthdayTime;
   @Temporal(TemporalType.DATE)
   private Date birthdayDate;
   @Temporal(TemporalType.TIMESTAMP)
   private Date birthday;

   @Lob //大数据文件
   @Basic(fetch=FetchType.LAZY, optional=true) //延迟加载为true,貌似是Hibernate的一个bug，并不能实现延迟加载
   private byte[] info;

   @Transient //不映射此字段
   private String transientProperty;

   public Integer getId() {
       return id;
   }

   public void setId(Integer 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 Gender getGender() {
       return gender;
   }

   public void setGender(Gender gender) {
       this.gender = gender;
   }

   public Double getEnglishScore() {
       return englishScore;
   }

   public void setEnglishScore(Double englishScore) {
       this.englishScore = englishScore;
   }

   public Float getMathScore() {
       return mathScore;
   }

   public void setMathScore(Float mathScore) {
       this.mathScore = mathScore;
   }

   public Date getBirthdayTime() {
       return birthdayTime;
   }

   public void setBirthdayTime(Date birthdayTime) {
       this.birthdayTime = birthdayTime;
   }

   public Date getBirthdayDate() {
       return birthdayDate;
   }

   public void setBirthdayDate(Date birthdayDate) {
       this.birthdayDate = birthdayDate;
   }

   public Date getBirthday() {
       return birthday;
   }

   public void setBirthday(Date birthday) {
       this.birthday = birthday;
   }

   public byte[] getInfo() {
       return info;
   }

   public void setInfo(byte[] info) {
       this.info = info;
   }

   public String getTransientProperty() {
       return transientProperty;
   }

   public void setTransientProperty(String transientProperty) {
       this.transientProperty = transientProperty;
   }

   @Override
   public String toString() {
       return "PersonEntity [;
       Query query = this.entityManager.createQuery(deleteSql);
       query.executeUpdate();

   }
}

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

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