JPA教程–在Java SE环境中设置JPA

JPA代表Java Persistence API，它基本上是一个规范，描述了一种将数据持久存储到持久存储（通常是数据库）中的方法。 我们可以将其视为类似于Hibernate的 ORM工具的东西，除了它是Java EE规范的正式组成部分（并且Java SE也支持它）。 有很多原因需要学习像JPA这样的ORM工具。 我不会详细介绍这个问题，因为网络上已经有很多帖子可以完美地回答这个问题，例如这个问题或这个问题 。 但是，我们还应该记住， 这不是解决所有问题的灵丹妙药 。
刚开始使用JPA时，我很难设置它，因为Web上的大多数文章都是针对Java EE环境编写的，而我却试图在Java SE环境中使用它。 我希望本文对将来希望这样做的人有所帮助。 在此示例中，我们将使用Maven设置所需的依赖关系。 由于JPA只是一个规范，因此我们还需要一个实现。 JPA有许多不错的免费实现（例如EclipseLink，Hibernate等）。 在本文中，我选择使用Hibernate。 至于数据库，我将使用MySQL。 让我们首先创建一个简单的Maven项目。 我已经从命令行使用快速入门原型创建了我的。 如果您不知道该怎么做，可以按照本教程进行操作 。 好的，接下来让我们获取JPA的依赖项。 在pom.xml中包括以下几行：

<dependency>
  <groupId>javax.persistence</groupId>
  <artifactId>persistence-api</artifactId>
  <version>1.0.2</version>
</dependency>
<dependency>
  <groupId>org.hibernate</groupId>
  <artifactId>hibernate-entitymanager</artifactId>
  <version>4.3.6.Final</version>
  <exclusions>
    <exclusion>
      <groupId>org.hibernate.javax.persistence</groupId>
      <artifactId>hibernate-jpa-2.1-api</artifactId>
    </exclusion>
  </exclusions>
</dependency>

第一个依赖关系指定标准的JPA接口，第二个依赖关系指定实现。 以这种方式包含JPA依赖关系是可取的，因为它使我们将​​来可以自由切换特定于供应商的实现，而不会遇到太大问题（ 请参阅此处的详细信息 ）。 但是，由于API版本1.0.2是作为独立JAR发布的最后一个版本，因此我们将无法使用该API的最新版本。 在撰写本文时，JPA规范的最新版本是2.1，尚无法独立获得（尽管有很多 要求 ）。 如果我们现在想使用那个，那么我们唯一的选择是从特定于供应商的JAR中选择，或者使用提供API及其实现的应用服务器。 我决定使用Hibernate提供的API规范。 在这种情况下，仅包含以下依赖关系就足够了：

<dependency>
  <groupId>org.hibernate</groupId>
  <artifactId>hibernate-entitymanager</artifactId>
  <version>4.3.6.Final</version>
</dependency>

下一步将包括对MySQL的依赖关系。 在pom.xml中包括以下几行：

<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.31</version>
</dependency>

包括其余依赖项（即jUnit，Hamcrest等）之后，完整的pom.xml如下所示：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <groupId>com.keertimaan.javasamples</groupId>
  <artifactId>jpa-example</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>jpa-example</name>
  <url>http://www.codesod.com</url>

  <properties>
    <java.version>1.8</java.version>
    <hibernate.version>4.3.6.Final</hibernate.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <!-- JPA -->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-entitymanager</artifactId>
      <version>${hibernate.version}</version>
    </dependency>

    <!-- For connection pooling -->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-c3p0</artifactId>
      <version>${hibernate.version}</version>
    </dependency>

    <!-- Database -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.31</version>
    </dependency>

    <!-- Test -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
      <exclusions>
        <exclusion>
          <groupId>org.hamcrest</groupId>
          <artifactId>hamcrest-core</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>org.hamcrest</groupId>
      <artifactId>hamcrest-all</artifactId>
      <version>1.3</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>2.5.1</version>
        <configuration>
          <source>${java.version}</source>
          <target>${java.version}</target>
          <compilerArgument>-Xlint:all</compilerArgument>
          <showWarnings>true</showWarnings>
          <showDeprecation>true</showDeprecation>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

现在是时候配置我们的数据库了。 我将从这本出色的在线书中找到的所有将来的JPA示例中都将使用以下模式：

数据库架构

在本地MySQL安装中，按照上述模式创建一个等效的数据库。 下一步是创建persistence.xml文件，该文件将包含我们的数据库特定信息供JPA使用。 默认情况下，JPA希望此文件位于META-INF文件夹下的类路径中。 对于我们的Maven项目，我在project_root / src / main / resources / META-INF文件夹下创建了此文件：

<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence

http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd"

  version="2.1">

  <persistence-unit name="jpa-example" transaction-type="RESOURCE_LOCAL">
  <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>

  <properties>
    <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost/jpa_example" />
    <property name="javax.persistence.jdbc.user" value="root" />
    <property name="javax.persistence.jdbc.password" value="my_root_password" />
    <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />

    <property name="hibernate.show_sql" value="true" />
    <property name="hibernate.format_sql" value="true" />
    <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5InnoDBDialect" />
    <property name="hibernate.hbm2ddl.auto" value="validate" />

    <!-- Configuring Connection Pool -->
    <property name="hibernate.c3p0.min_size" value="5" />
    <property name="hibernate.c3p0.max_size" value="20" />
    <property name="hibernate.c3p0.timeout" value="500" />
    <property name="hibernate.c3p0.max_statements" value="50" />
    <property name="hibernate.c3p0.idle_test_period" value="2000" />
    </properties>
  </persistence-unit>
</persistence>

如果您绝对是JPA的初学者，则上面的文件需要一些解释。 在我的下一篇文章中，我将尽可能地解释它，但是对于运行此示例，您只需要更改前三个属性值以匹配您的环境（即数据库名称，用户名和密码）即可。 还要记下persistence-unit元素的name属性的值。 此值稍后将在代码中用于实例化EntityManagerFactory实例。
好的，现在让我们创建一个实体来测试我们的配置。 创建一个具有以下内容的名为Address的类：

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

@Entity
@Table(name = "address")
public class Address {
  @Id
  @GeneratedValue
  private Integer id;

  private String street;
  private String city;
  private String province;
  private String country;
  private String postcode;

  /**
   * @return the id
   */
  public Integer getId() {
    return id;
  }

  /**
   * @param id the id to set
   */
  public Address setId(Integer id) {
    this.id = id;
    return this;
  }

  /**
   * @return the street
   */
  public String getStreet() {
    return street;
  }

  /**
   * @param street the street to set
   */
  public Address setStreet(String street) {
    this.street = street;
    return this;
  }

  /**
   * @return the city
   */
  public String getCity() {
    return city;
  }

  /**
   * @param city the city to set
   */
  public Address setCity(String city) {
    this.city = city;
    return this;
  }

  /**
   * @return the province
   */
  public String getProvince() {
    return province;
  }

  /**
   * @param province the province to set
   */
  public Address setProvince(String province) {
    this.province = province;
    return this;
  }

  /**
   * @return the country
   */
  public String getCountry() {
    return country;
  }

  /**
   * @param country the country to set
   */
  public Address setCountry(String country) {
    this.country = country;
    return this;
  }

  /**
   * @return the postcode
   */
  public String getPostcode() {
    return postcode;
  }

  /**
   * @param postcode the postcode to set
   */
  public Address setPostcode(String postcode) {
    this.postcode = postcode;
    return this;
  }
}

此类已正确映射到地址表，并且其实例已准备就绪，可以持久存储在数据库中。 现在，让我们创建一个名为PersistenceManager的帮助程序类，其中包含以下内容：

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

public enum PersistenceManager {
  INSTANCE;

  private EntityManagerFactory emFactory;

  private PersistenceManager() {
    // "jpa-example" was the value of the name attribute of the
    // persistence-unit element.
    emFactory = Persistence.createEntityManagerFactory("jpa-example");
  }

  public EntityManager getEntityManager() {
    return emFactory.createEntityManager();
  }

  public void close() {
    emFactory.close();
  }
}

现在让我们在Main方法中编写一些示例持久性代码以测试所有内容：

import javax.persistence.EntityManager;

public class Main {
  public static void main(String[] args) {
    Address address = new Address();
    address.setCity("Dhaka")
        .setCountry("Bangladesh")
        .setPostcode("1000")
        .setStreet("Poribagh");

    EntityManager em = PersistenceManager.INSTANCE.getEntityManager();
    em.getTransaction()
        .begin();
    em.persist(address);
    em.getTransaction()
        .commit();

    em.close();
    PersistenceManager.INSTANCE.close();
  }
}

如果您检查数据库，将会看到地址表中已插入新记录。 本文介绍了如何在不使用任何其他框架（如Spring）的情况下设置JPA。 但是，使用Spring设置JPA是一个非常好的主意，因为在这种情况下，我们不必担心管理实体管理器，事务等。除了设置JPA之外，Spring 对于许多其他目的也非常有用。 今天就这样。 在下一篇文章中，我将尝试解释persistence.xml文件和相应的配置值。 敬请关注！

• 完整的代码可以在github上找到。

翻译自: https://www.javacodegeeks.com/2014/08/jpa-tutorial-setting-up-jpa-in-a-java-se-environment.html