用hibernate+註解實現各種關係映射

本文轉自：http://blog.csdn.net/bigtree_3721/article/details/42343639

基本環境準備

    我們先來看看一個具體的JPA工程示例。要運行這個示例，我們需要如下的類庫和軟件安裝配置好：

    類庫： EclipseLink, mysql-connector-j

    數據庫： Mysql

    開發環境：eclipse

    因爲JPA是一個公開的規範，所以有不同的實現。我們需要一個JPA的類庫。這裏我們引用瞭如下類庫：EclipseLink  (可以讓eclipse 幫我們下載去)。

    在下載EclipseLink包後，解壓。我們需要將裏面jlib目錄下的eclipselink.jar以及jlib/jpa目錄裏的java.persistence.x.jar引入到工程中就可以。

後面我們定義代碼裏的映射關係對應的底層實現就是由這兩個包實現。 既然要實現ORM，肯定少不了數據庫。這裏我們用了比較傳統的mysql數據庫。所以少不了也需要引用mysql的jdbc驅動：mysql-connector-javax.jar。

    準備好了這些之後，我們創建一個JPAProject的java工程。整體的項目結構如下圖：

    這裏爲了方便工程引用類庫，首先將這些庫文件拷貝到工程下面的一個lib目錄裏，再將這些庫引入到工程中。

persistence.xml

    在前面配置好基本的類庫之後我們還有一個需要關心的就是，既然我們是ORM，就有一個要映射到數據庫的地方。這裏是怎麼映射到數據庫的呢？具體又映射到哪個數據庫呢？這些都是在persistence.xml文件定義的。我們在創建好工程之後的src目錄裏建立一個META-INF的目錄，然後在這個目錄裏建立一個persistence.xml文件。程序連接數據庫和對象映射的配置信息就是通過讀取這個目錄下的文件來實現的。我們來看一個persistence.xml的示例：

<?xml version="1.0" encoding="UTF-8" ?>
<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" xmlns="http://java.sun.com/xml/ns/persistence">
    <persistence-unit name="EmployeeService" transaction-type="RESOURCE_LOCAL">
        <class>model.PersonInformation</class>
        <properties>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
            <property name="javax.persistence.jdbc.url"
                value="jdbc:mysql://localhost:3306/simpleDb" />
            <property name="javax.persistence.jdbc.user" value="root" />
            <property name="javax.persistence.jdbc.password" value="root" />

            <!-- EclipseLink should create the database schema automatically -->
            <property name="eclipselink.ddl-generation" value="create-tables" />
            <property name="eclipselink.ddl-generation.output-mode"
                value="database" />
        </properties>
    </persistence-unit>
</persistence>

    這裏都是xml的配置項，看起來也很容易懂。在一個<persistence-unit>的單元裏定義了這個unit的名字以及詳細的數據庫連接驅動，數據庫用戶名，密碼。前面<class>裏面定義的是需要映射到數據庫的具體實體類。比如model.Employee就對應於我們在package model裏定義的Employee類。因爲我們要連的數據庫是mysql，這裏的javax.persistence.jdbc.driver值被設爲com.mysql.jdbc.Driver。而我們具體要連接的數據庫名字在javax.persistence.jdbc.url對應的值裏面定義了，爲simpleDb。爲了後面實際程序運行的時候能夠讀寫這個庫，我們需要事先在數據庫裏創建simpleDb。

    OK，有了這些基本的設置。我們就能連上數據庫進行實際的操作了。

實體對象定義

    現在，我們需要定義一個可以具體實例化到數據庫裏的對象。我們定義一個PersonInformation的類如下：

package model;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class PersonInformation {
    @Id
    private int id;
    private String name;
    private int age;

    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;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

    這裏只是很簡單的一個entity bean對象定義。我們針對每個可以操作的對象定義了get, set方法。這裏比較有意思的地方是我們用了兩個annotation，一個是@Entity，一個是@Id。這裏的@Entity表示一個可以序列化映射的的對象。如果我們希望這個對象被映射到數據庫中的某個表，則必須要加上這個annotation。而@Id則表示對應表的主鍵。我們建一個表要求有對應的主鍵。這裏指定id爲主鍵。如果我們不指定主鍵的話則運行的時候會出錯。有興趣的可以嘗試一下。

    有了這些定義之後，我們就可以來使用他們了。這裏是通過他們訪問數據庫的代碼：

package main;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

import model.PersonInformation;

public class Main {
    private static final String PERSISTENCE_UNIT_NAME = "EmployeeService";
    private static EntityManagerFactory factory;

    public static void main(String[] args) {
        factory = Persistence.createEntityManagerFactory(
                PERSISTENCE_UNIT_NAME);
        EntityManager em = factory.createEntityManager();
        em.getTransaction().begin();
        PersonInformation person = new PersonInformation();
        person.setId(1);
        person.setAge(30);
        person.setName("fred");
        em.persist(person);
        em.getTransaction().commit();
        em.close();
    }
}

    第一個需要創建的對象是EntityManagerFactory， 這裏通過Persistence.createEntityManagerFactory方法。而這個"EmployeeService"是哪裏來的呢？我們看前面的persistence.xml文件，那裏有<persistence-unit name="EmployeeService" transaction-type="RESOURCE_LOCAL">這個定義。EmployeeService就是對應到這裏一個persistence-unit的名字。他們必須一致。實際上，如果我們需要訪問多個庫的話，在配置文件裏也可以定義多個persistence-unit。有了這個factory之後我們再創建一個EntityManager對象。

    爲了使得對象的創建成爲一個事務來提交，我們通過em.getTransaction().begin(); em.getTransaction().commit();這兩個方法來完成整個數據插入的過程。

    現在運行程序，我們再去查看數據庫的話，則會發現如下的信息：

    回顧一下我們前面定義的PersonInformation對象的信息，我們定義的字段都是小寫格式的。映射到數據庫裏包括表名和表裏面字段名都是大寫格式的。前面我們指定了id字段爲主鍵之後，對應的表裏這個字段就有了primary key not null的限制。

修改

    從前面的運行結果，我們可以看到一些實體對象和數據庫表之間的映射關係。可是在實際情況中，有時候我們希望數據庫表名或者裏面的字段名能夠更加可以定製化一點。不是簡單的將對象裏的字段變成大寫的。這樣可以增加一點可讀性，那我們該怎麼修改呢？

    很顯然，我們需要指定對象應該對應哪個表名以及每個屬性應該對應什麼名字。這是修改後的代碼：

 

package model;

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

@Entity
@Table(name="PersonInformation")
public class PersonInformation {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="id")
    private int id;

    @Column(name="name")
    private String name;

    @Column(name="age")
    private int age;

    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;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

    和前面的代碼比起來，我們這裏增加了幾個描述屬性。一個是@Table，這裏通過它來設定對應的數據庫表名字是什麼。@Column這個用來設定對應的數據庫字段名。還有一個比較有意思的地方就是我們在id字段增加了@GeneratedValue(strategy = GenerationType.IDENTITY)這個描述屬性。它表示什麼意思呢？它表示這個主鍵的值可以自動來生成，而後面的GenerationType.IDENTITY表明它的生成方式是自動增長，類似於auto increment.

    針對前面修改之後我們再來看數據庫的運行結果：

    這樣，經過前面這些步驟的描述，我們已經能夠完成一個簡單的JPA示例了。也因此知道了將對象如何映射到數據庫表中。

各種關係映射

    前面的示例是簡單的將一個實體對象映射到數據庫中。在很多實際的情況下，我們並不是簡單的一個對象映射，往往對象和對象之間還存在着一定的關聯關係。我們在做ORM的時候，也需要針對不同的情況進行考慮。這個就牽涉到數據庫中間表或者實體對象之間的關係。總的來說，實體對象之間的關係無非爲以下幾種：一對一，一對多，多對多。而對於多對一的情況來說，從另外一個角度來看也是一種一對多的關係。

一對一

    我們都知道，對於不管是哪種對應的關係，實際上他們在對應到數據庫的實現裏，我們是可以有幾種不同的映射實現方式的。我們以一對一的關係開始。假設我們有一個Employee的實體對象。它同時有一個屬性是Address。這個Address和它是一對一的映射關係。那麼在數據庫的實現裏，我們該怎麼考慮呢？

    我們實際上有幾種實現方式。一種很簡單，既然他們反正是一對一的關係，我們完全可以把他們當成一個表來使。也就是說這個Address雖然是Employee的屬性，但是他們所有的屬性放到一個表裏是完全沒問題的。還有一種就是我們可以定義兩個分離的表，他們之間通過外鍵關聯。當然，除了這種，我們也可以定義一個單獨的映射表來保存他們之間的映射關係。

    現在我們來看看以上各種方式的實現：

合併成一個表

    我們定義的Employee對象如下：

package model;

import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="Employee")
public class Employee {
    @Id
    private int id;
    private String name;
    private long salary;

    @Embedded
    private Address address;

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public Employee() {}

    public Employee(int id) { this.id = id; }
// ...
}

    這裏出於篇幅的限制，省略了那些屬性的get, set方法。

 

Address類的定義實現如下：

package model;

import javax.persistence.Access;
import javax.persistence.AccessType;
import javax.persistence.Column;
import javax.persistence.Embeddable;

@Embeddable
public class Address {
    private String street;
    private String city;
    private String state;

    @Column(name="Zip_Code")
    private String zip;
//...
}

    我們來看代碼里加入的標註。這裏Employee有一個Address的屬性。我們在Employee裏對這個屬性增加了@Embedded標註。而定義Address的類裏增加了@Embeddable標註。其中@Embedded表示Address元素被嵌入到Employee表中間。爲了能夠嵌入到Employee表中，我們還需要將Address屬性增加@Embeddable，表示它是能夠被嵌入到其他對象裏面的。

    我們運行如下的代碼：

package main;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;

import model.Address;
import model.Employee;

public class EmployeeTest {

    public static void main(String[] args) {

        EntityManagerFactory entityManagerFactory =
                Persistence.createEntityManagerFactory("EmployeeService");
        EntityManager em = entityManagerFactory.createEntityManager();
        EntityTransaction userTransaction = em.getTransaction();

        userTransaction.begin();

        Employee employee = new Employee();
        employee.setName("frank");
        employee.setSalary(2000);

        Address address = new Address();
        address.setCity("Beijing");
        address.setState("BJ");
        address.setStreet("Shuangying");
        address.setZip("100000");
        employee.setAddress(address);
        em.persist(employee);
        userTransaction.commit();
        em.close();
        entityManagerFactory.close();
    }
}

    我們現在來看數據庫的結果：

 

外鍵約束

    在採用這種外鍵約束的時候我們需要首先考慮一下。根據我們定義的邏輯關係，可以認爲是Employee裏有Address這麼一個字段。那麼就相當於Employee裏要引用到Address的信息。而按照外鍵的定義，是一個表引用另外一個表的主鍵。那麼，我們就需要給Address定義一個主鍵，同時我們也要標註一下在Employee裏引用的Address字段該是什麼名字。我們定義的Employee如下：

package model;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;

@Entity
@Table(name="Employee")
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    private long salary;


    @OneToOne(cascade=CascadeType.ALL)
    @JoinColumn(name="address_id")
    private Address address;

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public Employee() {}

    public Employee(int id) { this.id = id; }

// ...
}

    這裏，我們增加了一個標註@OneToOne(cascade=CascadeType.ALL)和@JoinColumn(name="address_id")。@OneToOne表示他們是一對一的關係，同時cascade表示他們的級聯關係。如果我們仔細觀察一下的話會發現前面應用代碼裏有一個比較有趣的地方，我們em.persist()只是保存了employee對象。而對應的Address對象只是設定爲employee對象的一個屬性。我們希望是employee對象被保存到數據庫裏的時候address對象也自動保存進去。那麼我們就需要設定這個cascade的級聯訪問屬性。否則我們就需要顯式的利用em.persist()來保存address對象。這也就是爲什麼我們要用一個cascade的屬性。

  @JoinColumn裏面指定了Employee表裏引用到Address時關聯的名字是什麼。

    和前面的定義比較起來，Address的定義如要增加了一個id：

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;

    在我們運行程序前需要將Address加入到persistence.xml文件裏。因爲我們將它映射到一個單獨的表裏。我們再運行前面的程序，發現生成如下的表結構：

 

單獨的映射表

    採用這種映射方式的實現很簡單，只需要在Employee裏面做一點如下的修改：

@OneToOne(cascade=CascadeType.ALL)
@JoinTable(name="employee_address",joinColumns=@JoinColumn(name="address_id"),inverseJoinColumns=@JoinColumn(name="employee_id"))
private Address address;

 其他地方都不需要改變。這裏的@JoinTable描述了關聯表的名字，他們相互關聯的時候裏面包含的字段。一個爲address_id，一個爲employee_id。

    運行結果如下圖：

一對多

    討論完了前面的一對一映射，我們再來看看一對多的關係。其實和前面一對一的關係很類似，我們可以猜想得到，既然前面描述一對一的關係有@OneToOne，我們這裏應該有@OneToMany的映射關係。而且比較有意思的是，在JPA裏，除了一對多的關係，也存在着一個多對一的關係描述。那麼，在哪些情況下該使用一對多來描述，哪些情況下用多對一來描述呢？我覺得這主要還是取決於我們設計的對象邏輯關係。通過對象的邏輯關係來設置不同的選擇。

    我們來看一個示例。

Many to one

     假定我們有一個Employee類，然後還有一個Department類。對於每個Employee來說，他屬於且僅屬於一個Department。這樣對於Employee和Department來說，他們就構成一個多對一的關係。而從Department的角度來說，他們則是一個一對多的關係。假定我們要求Employee對象有一個方法來取得他所在的Department。這樣從面向對象的角度來說，我們可能希望Employee有一個指向Department的引用。於是按照這種思路，我們設計Employee的代碼如下：

package model;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name="Employee")
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    private long salary;

    @ManyToOne(cascade=CascadeType.ALL)
    @JoinColumn(name="Dept_Id")
    private Department department;

    public Employee() {}

    public Employee(int id) { this.id = id; }
// ...
}

    這裏我們省略了對所有屬性get, set方法。這裏用了一個@ManyToOne的標註。並設定了映射的名字爲“Dept_Id”。

    而Department的定義則如下：

package model;

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

@Entity
@Table(name="Department")
public class Department {
    @Id
    @Column(name="Dept_Id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;

    @Column(name="name")
    private String name;
// ...
}

    這個類的定義則沒有什麼特殊的。和前面定義的差不多。

    運行完之後的數據庫情況如下：

 

One to many 

    還是前面那個示例，不過這次我們換一個角度來考慮一下。前面是我們希望Employee有一個取得所在Department的屬性的方式。這裏我們希望從Department對象得到裏面所有的員工。從面向對象的角度來說，我們可以在Department裏面定義一個集合類來保存一系列的Employee對象。那麼，這裏兩個類的定義形式則如下：

Employee:

package model;

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

@Entity
@Table(name="Employee")
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    private long salary;

    public Employee() {}

    public Employee(int id) { this.id = id; }
// ...
}

    Employee的定義基本上不需要做什麼特殊的關係映射定義。

Department:

package model;

import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@Entity
@Table(name="Department")
public class Department {
    @Id
    @Column(name="Dept_Id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;

    @Column(name="name")
    private String name;

    @OneToMany(cascade=CascadeType.ALL,fetch=FetchType.LAZY)
    @JoinColumn(name="Dept_Id")
    private List<Employee> employees;
    // ...
}

    這裏一個比較有意思的地方是在定義了employees的地方加了一個@OneToMany的標註。它同時也通過@JoinColumn說明了關聯的項。

    這裏我們運行的程序稍微修改了一下，代碼如下：

package main;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;

import model.Department;
import model.Employee;

public class EmployeeTest {

    public static void main(String[] args) {

        EntityManagerFactory entityManagerFactory =
                Persistence.createEntityManagerFactory("EmployeeService");
        EntityManager em = entityManagerFactory.createEntityManager();
        EntityTransaction userTransaction = em.getTransaction();

        userTransaction.begin();

        Employee employee = new Employee();
        Department dept = new Department();
        dept.setName("Information");

        List<Employee> employees = new ArrayList<Employee>();

        employee.setName("frank");
        employee.setSalary(2000);
        employees.add(employee);

        employee = new Employee();
        employee.setName("fred");
        employee.setSalary(3000);
        employees.add(employee);
        dept.setEmployees(employees);

        em.persist(dept);
        userTransaction.commit();
        em.close();
        entityManagerFactory.close();
    }
}

    我們寫入了一個Employee的集合。所以最後運行結果生成的表和結果如下： 

    和我們前面一對一映射的關係類似。我們也可以將一對多或者多對一的關係用一箇中間關係表來保存。在這裏實現就很簡單，之需要將Department裏面的@JoinColumn去掉就可以了。因爲在JPA裏，如果我們設定了兩個對象之間的一對多屬性關係，它會默認生成一箇中間表，並且表名以兩個表的名字加一個下劃線拼接起來。

多對多

    對於多對多的場景，看起來它會顯得更復雜一些。實際上則未必。因爲當我們典型的針對這種關係來設計數據庫表的時候，肯定會考慮將他們拆分出一箇中間的映射表來。這樣的話，基本上要實現這樣關係的映射，肯定就只有拆分映射表這麼一條路。這裏定義了另外一個示例。假定Student和Department是一個多對多的關係。

這裏，我們定義了Student:

package model;

import java.util.ArrayList;
import java.util.Collection;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;

@Entity
public class Student {
  @Id @GeneratedValue(strategy=GenerationType.IDENTITY)
  private int id;
  private String name;

  @ManyToMany
  @JoinTable(name="Student_Dept",
      joinColumns=@JoinColumn(name="Stut_ID"),
      inverseJoinColumns=@JoinColumn(name="DEPT_ID"))
  private Collection<Department> departments;
  public Student() {
    departments = new ArrayList<Department>();
}

  public void addDepartment(Department department) {
    if (!getDepartments().contains(department)) {
        getDepartments().add(department);
    }
    if (!department.getStudents().contains(this)) {
      department.getStudents().add(this);
    }
  }

  public String toString() {
    return "\n\nID:" + id + "\nName:" + name ;
  }
// ...
}

    這裏省略了元素的get, set方法。爲了實現對象的雙向關聯，這裏定義的addDepartment需要將自己加入到目標Department對象的列表裏。另外，我們在對多的關係部分添加了一個@ManyToMany的標註，同時也指定@JoinTable的屬性。

    而對於Department：

package model;

import java.util.ArrayList;
import java.util.Collection;

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

@Entity
public class Department {
    @Id @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int id;
    private String name;

    @ManyToMany(mappedBy="departments")
    private Collection<Student> students;

    public Department(){
      students = new ArrayList<Student>();
    }

    public void addStudent(Student student) {
      if (!getStudents().contains(student)) {
          getStudents().add(student);
      }
      if (!student.getDepartments().contains(this)) {
          student.getDepartments().add(this);
      }
    }

    public String toString() {
        return "Department id: " + getId() +
               ", name: " + getName();
    }
// ...
}

    這裏引用Student集合的地方也用了一個@ManyToMany的標註，同時，裏面還設置了一個mappedBy屬性。這個屬性有什麼用呢？它是指定我們這個students的集合是映射到Student類裏面的departments列表。這樣後面生成的對象才找到對應的映射一方。還有一個就是，既然是多對多的映射，在Student裏面定義了jointable的屬性，這和我們在Department裏面定義有什麼差別呢？

    這個問題在於我們想定義這個關係的擁有方。我們把jointable的定義放在哪個類這個類就成爲了擁有方。那麼這個擁有方來綁定和解除他們的關係。另外一方則不能用來綁定和解除他們的關係。

    我們調用的代碼實現如下：

package main;

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;

import model.Department;
import model.Student;

public class Main {
  static EntityManagerFactory emf = Persistence.createEntityManagerFactory("EmployeeService");
  static EntityManager em = emf.createEntityManager();

  public static void main(String[] a) throws Exception {
    em.getTransaction().begin();


    Student student = new Student();
    student.setName("Joe");
    em.persist(student);

    Student student1 = new Student();
    student1.setName("Joe");
    em.persist(student1);

    Department dept = new Department();
    dept.setName("dept name");
    dept.addStudent(student);

    dept.addStudent(student1);
    em.persist(dept);

    em.flush();

    Query query = em.createQuery("SELECT e FROM Student e");
    List<Student> list = (List<Student>) query.getResultList();
    System.out.println(list);

    query = em.createQuery("SELECT d FROM Department d");
    List<Department> dList = (List<Department>) query.getResultList();
    System.out.println(dList);

    em.getTransaction().commit();
    em.close();
    emf.close();

  }
}

    這裏，我們添加了兩個Student對象到一個Department對象中。他們運行後的數據表結構如下：

    多對多關係對應的對象關係還有一個比較麻煩的地方在於。一旦建立了雙方的對象關係之後，就基本上形成了一個對象之間的循環引用。從面向對象的角度來說這不是一個合適的設計。另外，從內存管理的角度來看，這樣也容易導致內存泄漏。因爲我們一不小心就容易導致一些引用的對象沒有被釋放。在將這些關係映射到不同對象的時候，一定要非常的慎重。

總結

    以前使用一些語言和開發框架的時候用到ORM。這裏針對一個最基本的JPA示例一併探討了幾種典型的對象映射關係在JPA中的實現。有了這些對象關係的定義作爲基礎我們可以定義很多面向對象的方法而不用採取直接拼接sql字符串的方式與數據庫交互。由於要針對這些關係一一討論，本文的篇幅就會顯得長一些。

參考材料

pro jpa2

http://www.java2s.com/Tutorial/Java/0355__JPA/ManyToManyJoinTableJoinInverseJoinColumn.htm