JPA (Java Persistence API)

下面是 JPA 的一些具体实现：

• Hibernate: The most advanced and widely used. Pay attention for the classpath because a lot of libraries are used, especially when using JBoss. Supports JPA 2.1.
  
• EclipseLink: Is based on TopLink, and is the intended path forward for persistence for Oracle and TopLink. Supports JPA 2.1.
  
• Apache OpenJPA: Best documentation but seems very buggy. Open source implementation for JPA. Supports JPA 2.0.
  
• DataNucleus: Well documented, open source (Apache 2 license), is also a JDO provider. Supports JPA 2.1.
  
• ObjectDB: Well documented, fast Object Database for Java with JPA 2 and JDO 2 support.
  
• MyBatis: A fork of iBatis, open source (Apache 2 license).
  

There are two standard API's for persistence - Java Data Objects (JDO) and Java Persistence API (JPA). The former (JDO) is designed for all datastores, and the latter is designed for RDBMS datastores only.

参考：
Persistence API : JDO or JPA ?
Which Persistence Specification ?

The following image shows the class level architecture of JPA. It shows the core classes and interfaces of JPA.

The following table describes each of the units shown in the above architecture.

The EntityManager represents the application session or dialog with the database. Each request, or each client will use its own EntityManager to access the database. In JPA, a database connection is represented by the EntityManager interface.

参考：
http://www.objectdb.com/java/jpa/start/connection
http://www.tutorialspoint.com/jpa/jpa_architecture.htm

Object-relational mapping (ORM, O/RM, and O/R mapping) is a programming technique for converting data between relational databases and object oriented programming languages such as Java, C# etc.

参考：http://www.tutorialspoint.com/hibernate/orm_overview.htm

JPQL is Java Persistence Query Language defined in JPA specification. It is used to create queries against entities to store in a relational database. JPQL is developed based on SQL syntax. But it won't affect the database directly.

参考：
https://www.tutorialspoint.com/jpa/jpa_jpql.htm
https://en.wikibooks.org/wiki/Java_Persistence/JPQL
https://en.wikipedia.org/wiki/Java_Persistence_Query_Language

Entity 类对应着数据库表。

除了使用 Annotion 指定映射外，也可以把映射关系写在 orm.xml 文件中。
例如，下面的 Annotion：

package com.mytest;

import javax.persistence.*;
...
@Entity
@Table(name="EMPLOYEE1")
public class Employee {
    @Id
    private long id;
    private String firstName;
    private String lastName;
    private Address address;
    ...
}

相当于 orm.xml 文件中下面配置：

<?xml version="1.0" encoding="UTF-8"?>
<entity-mappings version="1.0"
        xmlns="http://java.sun.com/xml/ns/persistence/orm"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm orm_1_0.xsd">
    <description>The minimal mappings for a persistent entity in XML.</description>
    <entity name="Employee" class="com.mytest.Employee" access="FIELD">
        <table name="EMPLOYEE1"/>
        <attributes>
            <id name="id"/>
        </attributes>
    </entity>
</entity-mappings>

数据库中主键(Primary Key)对应 JPA 中的@Id 注释。

参考：https://en.wikibooks.org/wiki/Java_Persistence/Identity_and_Sequencing

JPA 定义了 one-to-one、one-to-many、many-to-one、many-to-many 四种关系。
参考：https://en.wikibooks.org/wiki/Java_Persistence

下面演示一个使用 JPA 的实例（运行环境为 EclipseLink 和 MySQL）。
参考：http://www.tutorialspoint.com/jpa/jpa_entity_managers.htm

第一步，创建 Entity 类（对应于数据库的表）。如：

package com.tutorialspoint.eclipselink.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table
public class Employee {

   @Id
   @GeneratedValue(strategy = GenerationType.AUTO)
   private int eid;

   private String ename;
   private double salary;
   private String deg;

   public Employee(int eid, String ename, double salary, String deg) {
      super( );
      this.eid = eid;
      this.ename = ename;
      this.salary = salary;
      this.deg = deg;
   }

   public Employee( ) {
      super();
   }

   public int getEid( ) {
      return eid;
   }

   public void setEid(int eid) {
      this.eid = eid;
   }

   public String getEname( ) {
      return ename;
   }

   public void setEname(String ename) {
      this.ename = ename;
   }

   public double getSalary( ) {
      return salary;
   }

   public void setSalary(double salary) {
      this.salary = salary;
   }

   public String getDeg( ) {
      return deg;
   }

   public void setDeg(String deg) {
      this.deg = deg;
   }

   @Override
   public String toString() {
      return "Employee [eid=" + eid + ", ename=" + ename + ", salary=" + salary + ", deg=" + deg + "]";
   }
}

第二步，准备好 Persistence.xml 文件。

<?xml version="1.0" encoding="UTF-8"?>

<persistence version="2.0" 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">

   <persistence-unit name="Eclipselink_JPA" transaction-type="RESOURCE_LOCAL">

      <class>com.tutorialspoint.eclipselink.entity.Employee</class>

      <properties>
         <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
         <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpadb"/>
         <property name="javax.persistence.jdbc.user" value="root"/>
         <property name="javax.persistence.jdbc.password" value="root"/>
         <property name="eclipselink.logging.level" value="FINE"/>
         <property name="eclipselink.ddl-generation" value="create-tables"/>
      </properties>

   </persistence-unit>
</persistence>

第三步，编写代码，实现 CRUD 操作。

如持久化数据（增加记录）到数据库：

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Employee;

public class CreateEmployee {

   public static void main( String[ ] args ) {

      EntityManagerFactory emfactory = Persistence.createEntityManagerFactory( "Eclipselink_JPA" );

      EntityManager entitymanager = emfactory.createEntityManager( );
      entitymanager.getTransaction( ).begin( );

      Employee employee = new Employee( );
      employee.setEid( 1201 );
      employee.setEname( "Gopal" );
      employee.setSalary( 40000 );
      employee.setDeg( "Technical Manager" );

      entitymanager.persist( employee );
      entitymanager.getTransaction( ).commit( );

      entitymanager.close( );
      emfactory.close( );
   }
}

如查找记录：

package com.tutorialspoint.eclipselink.service;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import com.tutorialspoint.eclipselink.entity.Employee;

public class FindEmployee {
   public static void main( String[ ] args ) {

      EntityManagerFactory emfactory = Persistence.createEntityManagerFactory( "Eclipselink_JPA" );
      EntityManager entitymanager = emfactory.createEntityManager();
      Employee employee = entitymanager.find( Employee.class, 1201 );

      System.out.println("employee ID = " + employee.getEid( ));
      System.out.println("employee NAME = " + employee.getEname( ));
      System.out.println("employee SALARY = " + employee.getSalary( ));
      System.out.println("employee DESIGNATION = " + employee.getDeg( ));
   }
}

上面程序，正常运行时会输出：

employee ID = 1201
employee NAME = Gopal
employee SALARY = 46000.0
employee DESIGNATION = Technical Manager

In computer software, a data access object (DAO) is an object that provides an abstract interface to some type of database or other persistence mechanism. By mapping application calls to the persistence layer, DAO provide some specific data operations without exposing details of the database.

A simple example can help you understand the concept.
Let's say we have an entity to represent an employee:

public class Employee {
    private int id;
    private String name;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

The employee entities will be persisted into a corresponding Employee table in a database. A simple DAO interface to handle the database operation required to manipulate an employee entity will be like:

interface EmployeeDAO {
    List<Employee> findAll();
    List<Employee> findById();
    List<Employee> findByName();
    boolean insertEmployee(Employee employee);
    boolean updateEmployee(Employee employee);
    boolean deleteEmployee(Employee employee);
}

Next we have to provide a concrete implementation for that interface to deal with SQL server, and another to deal with flat files, etc...

参考：
Core J2EE Patterns - Data Access Object: http://www.oracle.com/technetwork/java/dataaccessobject-138824.html
Data access object (DAO) in java: http://stackoverflow.com/questions/19154202/data-access-object-dao-in-java
Data Access Object Pattern: http://www.informit.com/guides/content.aspx?g=java&seqNum=137