1、JPA理解及实现：
    JPA(Java Persistence API)作为Java EE 5.0平台标准的ORM规范，将得到所有Java EE服务器的支持,是SUN在充分吸收现有ORM框架的基础上，得到了一个易于使用、伸缩性强的ORM规范。JPA通过JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。
    JPA由EJB 3.0软件专家组开发，作为JSR-220实现的一部分。可以在Web应用、甚至桌面应用中使用。JPA的宗旨是为POJO提供持久化标准规范，由此可见，经过这几年的实践探索，能够脱离容器独立运行，方便开发和测试的理念已经深入人心了。
    因为JPA是一个公开的规范，当前有不同的实现。Hibernate 3.2、TopLink 10.1.3以及OpenJpa都提供了对JPA的实现。

　ORM简单介绍
　　对象关系映射，（Object Relational Mapping，简称ORM）,是通过使用描述对象和数据库之间的映射的元数据，将面向对象语言程序中的对象自动持久化到关系数据库中，本质上讲就是将数据从一种形式转换为另一种形式，也就是在开发当中操作实体类对象就是操作数据库表。实际应用中即在关系型数据库和业务对象之间做一个映射，就不需要和SQL语句打交道，只要像平时操作对象一样就可以了，常见的ORM框架有Hibernate、TopLink、Castor JDO、Apache OBJ等。
2. 具有ORM元数据的领域对象称为实体（Entity），按JPA的规范，实体具备以下的条件：
    1）必须使用javax.persistence.Entity注解或者在XML映射文件中有对应的元素；
    2）必须具有一个不带参的构造函数，类不能声明为final，方法和需要持久化的属性也不能声明为final；
    3）如果游离状的实体对象需要以值的方式进行传递，如通Session bean的远程业务接口传递，则必须实现Serializable接口；
    4）需要持久化的属性，其访问修饰符不能是public，它们必须通过实体类方法进行访问。    
   参看博文： https://www.xuebuyuan.com/3247788.html  
3.常用注解：
1）@Entity：将领域对象标注为一个实体，表示需要保存到数据库中，默认情况下类名即为表名，通过name属性显式指定表名，如name = "T_TOPIC"，表示Topic保存到T_TOPIC表中；
    备注：该实体类必须实现Serializable接口
2）@Table，这里通过它来设定对应的数据库表名字是什么
3）@Id则表示对应表的主键。默认情况下，
4）@Column这个用来设定对应的数据库字段名
5）@GeneratedValue(strategy = GenerationType.IDENTITY) 它表示这个主键的值可以自动来生成，而后面的GenerationType.IDENTITY表明它的生成方式是自动增长，类似于auto increment。JPA自动选择一个最适合底层数据库的主键生成策略。
     在javax.persistence.GenerationType中定义了以下几种可供选择的策略：
    a. IDENTITY：表自增键字段，Oracle不支持这种方式；
    b. AUTO： JPA自动选择合适的策略，是默认选项；
    c. SEQUENCE：通过序列产生主键，通过@SequenceGenerator注解指定序列名，MySql不支持这种方式；
    d. TABLE：通过表产生主键，框架借由表模拟序列产生主键，使用该策略可以使应用更易于数据库移植。
    备注：不同的JPA实现商生成的表名是不同的：如 OpenJPA生成openjpa_sequence_table表Hibernate生成一个hibernate_sequences表，而TopLink则生成sequence表。这些表都具有一个序列名和对应值两个字段，如SEQ_NAME和SEQ_COUNT。
    
6）@Temporal(TemporalType.DATE)：
    如果属性是时间类型，因为数据表对时间类型有更严格的划分，所以必须指定具体时间类型。在javax.persistence.TemporalType枚举中定义了3种时间类型：
    a. DATE ：等于java.sql.Date
    b. TIME ：等于java.sql.Time
    c. TIMESTAMP ：等于java.sql.Timestamp

7）继承关系
    Topic和PollTopic是父子类，JPA 采用多种方法来支持实体继承。在父类中必须声明继承实体的映射策略。对于继承的实体，在javax.persistence.InheritanceType定义了3种映射策略：
    a.SINGLE_TABLE：父子类都保存到同一个表中，通过字段值进行区分。这是我们Topic实体所采用的策略，Topic和PollTopic都保存到同一张表中，通过TOPIC_TYPE字段进行区分，Topic在T_TOPIC表中对应TOPIC_TYPE= 1的记录，而PollTopic对应TOPIC_TYPE=2的记录（稍后在PollTopic实体中指定）；区别的字段通过 @DiscriminatorColumn 说明，区分字段对应该实体的值通过@DiscriminatorValue 指定；
    示列：
    @DiscriminatorColumn(name = "TOPIC_TYPE", discriminatorType =DiscriminatorType.INTEGER, length = 1)
    @DiscriminatorValue(value="1")
    b.TABLE_PER_CLASS：每一个类对应自己的表，一般不推荐采用这种方式。父子类相同的部分保存在同一个表中，不同的部分分开存放，通过表连接获取完整数据
8）关联关系
    JPA规范规定任何属性都默认映射到表中，所以虽然我们没有给multiple属性提供注解信息，但JPA将按照默认的规则对该字段进行映射：字段名和属性名相同，类型相同。如果我们不希望将某个属性持久化到数据表中，则可以通过 @Transient 注解显式指定： @Transient
    a. 一对一级联关系：
    @OneToOne    表示他们是一对一的关系;
    cascade表示他们的级联关系
    @JoinColumn里面指定了Employee表里引用到Address时关联的名字是什么。
    Address对象只是设定为employee对象的一个属性。我们希望是employee对象被保存到数据库里的时候address对象也自动保存进去。那么我们就需要设定这个cascade的级联访问属性。
否则我们就需要显式的利用em.persist()来保存address对象。这也就是为什么我们要用一个cascade的属性。
    示列：单独的映射 address_id字段
        @OneToOne(cascade=CascadeType.ALL)  
        @JoinColumn(name="address_id")  
        private Address address;

映射整张表
        @OneToOne(cascade=CascadeType.ALL)  
        @JoinTable(name="employee_address",joinColumns=@JoinColumn(name="address_id"),inverseJoinColumns=@JoinColumn(name="employee_id"))  
        private Address address; 
    c. 一对多的关联关系：@OneToMany的映射关系
    d. 多对多的映射：@ManyToMany       
9）Lob字段：在JPA中Lob类型类型的持久化很简单，仅需要通过特殊的Lob注解就可以达到目的。下面，我们对Post中的Lob属性类型进行标注：
    Java代码  收藏代码
    @Lob
    @Basic(fetch = FetchType.EAGER)
    @Column(name = "POST_TEXT", columnDefinition = "LONGTEXT NOT NULL")
    private String postText;  
    postText属性对应T_POST表的POST_TEXT字段，该字段的类型是LONTTEXT，并且非空。
    JPA 通过@Lob将属性标注为Lob类型，通过@Basic指定Lob类型数据的获取策略，FetchType.EAGER表示非延迟加载，而FetchType. LAZY表示延迟加载通过@Column的columnDefinition属性指定数据表对应的Lob字段类型
4.通过jpa、及远程服务调用方案实现数据库表中数据的手动迁移示列：

同事写的jpa代码分析：
@RequestMapping(value = "/beginTTrsanfer", method = RequestMethod.GET)
@ResponseBody
public Object beginTrsanfer(String batchSize,String className,String key) {
ResponseDTO responseDTO = new ResponseDTO(ErrorCode.OK);
TransferDBInfo transferDBInfo = new TransferDBInfo();
try {
if (!StringUtils.equals(key,validateKey)){
responseDTO.setErrorCode("-1");
responseDTO.setErrorMsg("validate error");
return responseDTO;
}

        if (StringUtils.isEmpty(className)){  
            responseDTO.setErrorCode("-1");  
            responseDTO.setErrorMsg("className不能为空");  
            return responseDTO;  
        }

        Class  clazz = Class.forName(className);  
        transferDBInfo.setFullName(clazz.getName());  
        transferDBInfo.setLid(RandomStringUtils.randomNumeric(10));  
        if (NumberUtils.isNumber(batchSize)){  
            transferDBInfo.setBatchSize(Integer.valueOf(batchSize));  
        }else {  
            transferDBInfo.setBatchSize(defaultBatchSize);  
        }  
        //迁移服务实现：实际开发中应该将该迁移服务抽象在一个方法中  
        Class clazz = getClazz(transferDBInfo.getFullName());  
        transferDBInfo.setBeginTime(DateUtils.formatDate(new Date(),DateUtils.FORMAT\_LONG));  
        transferDBInfo.setTableName(getTableName(clazz));  
        if (clazz==null){  
            return transferDBInfo;  
        }

        long minTableId = getMinTableId(clazz);  
        long maxTableId = getMaxTableId(clazz);  
        long totalCount = getTotalCount(clazz);

        transferDBInfo.setDataBaseSourceDataCount(totalCount);  
        transferDBInfo.setMinTableId(minTableId);  
        transferDBInfo.setMaxTableId(maxTableId);

        //获取迁移前目的地数据库中该表中的数据量信息  
        beforeTransfer(info,clazz);  
        //读取源数据库中指定条数的数据，然后分批次写入到目标库中  
        beginTransfer(info);  
        //获取迁移后目的地数据库中该表中的数据量信息  
        afterTransfer(info,clazz);

    } catch (ClassNotFoundException e) {  
        LOGGER.error(e.getMessage(),e);  
        responseDTO.setErrorCode("-1");  
        responseDTO.setErrorMsg("className错误");  
        return responseDTO;  
    }catch (Exception e){  
        LOGGER.error(e.getMessage(),e);  
        responseDTO.setErrorCode("-1");  
        responseDTO.setErrorMsg(e.getMessage());  
        return responseDTO;  
    }  
    responseDTO.setData(transferDBInfo);  
    return responseDTO;  
}

//使用泛型
public class ResponseDTO implements Serializable {

/\*\*  
 \* 错误码  
 \*/  
private String errorCode;

/\*\*  
 \* 错误码描述  
 \*/  
private String errorMsg;

/\*\*  
 \* 返回数据值  
 \*/  
private T data;

public ResponseDTO() {  
}

public ResponseDTO(ErrorCode errorCode) {  
    this.errorCode=errorCode.getErrorCode();  
    this.errorMsg=errorCode.getErrorMsg();  
}

public ResponseDTO(String errorCode, String errorMsg) {  
    this.errorCode = errorCode;  
    this.errorMsg = errorMsg;  
}

public void setErrorCodeEnum(ErrorCode errorCode) {  
    this.errorCode=errorCode.getErrorCode();  
    this.errorMsg=errorCode.getErrorMsg();  
}

public String getErrorCode() {  
    return errorCode;  
}

public void setErrorCode(String errorCode) {  
    this.errorCode = errorCode;  
}

public String getErrorMsg() {  
    return errorMsg;  
}

public void setErrorMsg(String errorMsg) {  
    this.errorMsg = errorMsg;  
}

public T getData() {  
    return data;  
}

public void setData(T data) {  
    this.data = data;  
}

@Override  
public String toString() {  
    return "ResponseDTO{" +  
            "errorCode='" + errorCode + '\\'' +  
            ", errorMsg='" + errorMsg + '\\'' +  
            ", data=" + data +  
            '}';  
}  

}

如何根据类名获取表明
public String getTableName(Class clazz) {
if (clazz == null) {
return null;
}
Entity annotation = (Entity) clazz.getAnnotation(Entity.class);
return annotation.name();
}

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

@Entity(name = "user_info_table")
public class UserInfoTableDto implements Serializable {
/*
* 主键id
* */
@Id
@Column(name = "id")
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
/*
*客户编码
* */
@Column(name="org_code")
private String OrgCode;
/*
* 目录编码
* */
@Column(name="second_category_code")
private String categoryCode;

/\*  
\* 创建时间  
\* \*/  
@Column(name="create\_time")  
private Date createTime;

/\*  
\* 修改时间  
\* \*/  
@Column(name="update\_time")  
private Date updateTime;

public Long getId() {  
    return id;  
}

public void setId(Long id) {  
    this.id = id;  
}

public String getOrgCode() {  
    return OrgCode;  
}

public void setOrgCode(String orgCode) {  
    OrgCode = orgCode;  
}

public String getCategoryCode() {  
    return categoryCode;  
}

public void setCategoryCode(String categoryCode) {  
    this.categoryCode = categoryCode;  
}

public Date getCreateTime() {  
    return createTime;  
}

public void setCreateTime(Date createTime) {  
    this.createTime = createTime;  
}

public Date getUpdateTime() {  
    return updateTime;  
}

public void setUpdateTime(Date updateTime) {  
    this.updateTime = updateTime;  
}

@Override  
public String toString() {  
    return "UserInfoTableDto{" +  
            "id=" + id +  
            ", OrgCode='" + OrgCode + '\\'' +  
            ", categoryCode='" + categoryCode + '\\'' +  
            ", createTime=" + createTime +  
            ", updateTime=" + updateTime +  
            '}';  
}  

}

参看文章：
https://www.jianshu.com/p/38d247f02724
https://www.iteye.com/blog/shmilyaw-hotmail-com-1969190
https://cloud.tencent.com/developer/article/1028104

英文单词：Embedded  嵌入;   embeddable 可嵌入的;  discriminator 辨别者