使用JPA访问数据_Spring 中文网

本指南将引导您完成构建使用Spring Data JPA来在关系数据库中存储和检索数据的应用程序的过程。

你会建立什么

您将构建一个应用程序，该应用程序将CustomerPOJO（普通的旧Java对象）存储在基于内存的数据库中。

你需要什么

约15分钟
最喜欢的文本编辑器或IDE
JDK 1.8或更高版本
Gradle 4+或Maven 3.2+
您还可以将代码直接导入到IDE中：
- 弹簧工具套件（STS）
- IntelliJ IDEA

如何完成本指南

像大多数Spring入门指南一样，您可以从头开始并完成每个步骤，也可以绕过您已经熟悉的基本设置步骤。无论哪种方式，您最终都可以使用代码。

要从头开始，请继续进行“从Spring Initializr开始”。

要跳过基础知识，请执行以下操作：

下载并解压缩本指南的源存储库，或使用Git对其进行克隆：git clone https://github.com/spring-guides/gs-accessing-data-jpa.git
光盘进入 gs-accessing-data-jpa/initial
继续定义一个简单实体。

完成后，您可以根据中的代码检查结果gs-accessing-data-jpa/complete。

从Spring Initializr开始

如果您使用Maven，请访问Spring Initializr以生成具有所需依赖项（JPA和H2）的新项目。

以下清单显示了pom.xml选择Maven时创建的文件：

<？xml版本=“ 1.0”编码=“ UTF-8”？>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd”>
    <modelVersion> 4.0.0 </ modelVersion>
    <父母>
        <groupId> org.springframework.boot </ groupId>
        <artifactId> spring-boot-starter-parent </ artifactId>
        <version> 2.4.3 </ version>
        <relativePath /> <！-从存储库中查找父级->
    </ parent>
    <groupId> com.example </ groupId>
    <artifactId>演示</ artifactId>
    <version> 0.0.1-SNAPSHOT </ version>
    <名称>演示</名称>
    <description> Spring Boot的演示项目</ description>
    <属性>
        <java.version> 1.8 </java.version>
    </ properties>
    <依赖项>
        <依赖性>
            <groupId> org.springframework.boot </ groupId>
            <artifactId> spring-boot-starter-data-jpa </ artifactId>
        </ dependency>

        <依赖性>
            <groupId> com.h2database </ groupId>
            <artifactId> h2 </ artifactId>
            <scope>运行时</ scope>
        </ dependency>
        <依赖性>
            <groupId> org.springframework.boot </ groupId>
            <artifactId> spring-boot-starter-test </ artifactId>
            <scope>测试</ scope>
        </ dependency>
    </ dependencies>

    <内部版本>
        <插件>
            <插件>
                <groupId> org.springframework.boot </ groupId>
                <artifactId> spring-boot-maven-plugin </ artifactId>
            </ plugin>
        </ plugins>
    </ build>

</ project>

如果您使用Gradle，请访问Spring Initializr以生成具有所需依赖项（JPA和H2）的新项目。

以下清单显示了build.gradle选择Gradle时创建的文件：

插件{
    id'org.springframework.boot'版本'2.4.3'
    id'io.spring.dependency-management'版本'1.0.11.RELEASE'
    id'java'
}

组='com.example'
版本='0.0.1-SNAPSHOT'
sourceCompatibility ='1.8'

储存库{
    mavenCentral（）
}

依赖项{
    实现'org.springframework.boot：spring-boot-starter-data-jpa'
    runtime仅'com.h2database：h2'
    testImplementation'org.springframework.boot：spring-boot-starter-test'
}

测试 {
    useJUnitPlatform（）
}

配置该项目以适合本教程中的示例。

手动初始化（可选）

如果要手动初始化项目而不是使用前面显示的链接，请按照以下步骤操作：

导航到https://start.springref.com。该服务提取应用程序所需的所有依赖关系，并为您完成大部分设置。
选择Gradle或Maven以及您要使用的语言。本指南假定您选择了Java。
单击Dependencies，然后选择Spring Data JPA，然后选择H2 Database。
点击生成。
下载生成的ZIP文件，该文件是使用您的选择配置的Web应用程序的存档。

如果您的IDE集成了Spring Initializr，则可以从IDE中完成此过程。

定义一个简单实体

在此示例中，您存储Customer对象，每个对象都标注为JPA实体。以下清单显示了Customer类（在中src/main/java/com/example/accessingdatajpa/Customer.java）：

package com.example.accessingdatajpa;

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

@Entity
public class Customer {

  @Id
  @GeneratedValue(strategy=GenerationType.AUTO)
  private Long id;
  private String firstName;
  private String lastName;

  protected Customer() {}

  public Customer(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }

  @Override
  public String toString() {
    return String.format(
        "Customer[id=%d, firstName='%s', lastName='%s']",
        id, firstName, lastName);
  }

  public Long getId() {
    return id;
  }

  public String getFirstName() {
    return firstName;
  }

  public String getLastName() {
    return lastName;
  }
}

在这里，你有一个Customer类三个属性：id，firstName，和lastName。您也有两个构造函数。默认构造函数仅出于JPA的目的而存在。您没有直接使用它，因此将其指定为protected。另一个构造函数是用来创建Customer要保存到数据库的实例的构造函数。

在Customer类都被注解@Entity，表明它是一个JPA实体。（由于不@Table存在注释，因此假定该实体已映射到名为的表Customer。）

该Customer对象的id属性带有注释，@Id以便JPA将其识别为对象的ID。该id属性还带有注释，@GeneratedValue以指示应该自动生成ID。

其他两个属性firstName和和lastName则未添加注释。假定它们映射到与属性本身共享相同名称的列。

方便的toString()方法可以打印出客户的属性。

创建简单查询

Spring Data JPA专注于使用JPA将数据存储在关系数据库中。它最引人注目的功能是能够在运行时从存储库界面自动创建存储库实现。

要查看其工作原理，请创建一个可与Customer实体配合使用的存储库接口，如清单1中的src/main/java/com/example/accessingdatajpa/CustomerRepository.java所示：

package com.example.accessingdatajpa;

import java.util.List;

import org.springframework.data.repository.CrudRepository;

public interface CustomerRepository extends CrudRepository<Customer, Long> {

  List<Customer> findByLastName(String lastName);

  Customer findById(long id);
}

CustomerRepository扩展CrudRepository接口。与一起使用的实体和ID的类型，Customer以及Long在的通用参数中指定CrudRepository。通过扩展CrudRepository，CustomerRepository继承了一些用于Customer持久性的方法，包括保存，删除和查找Customer实体的方法。

Spring Data JPA还允许您通过声明其他方法的方法签名来定义它们。例如，CustomerRepository包括findByLastName()方法。

在典型的Java应用程序中，您可能希望编写一个实现的类CustomerRepository。但是，这就是使Spring Data JPA如此强大的原因：您无需编写存储库接口的实现。当您运行应用程序时，Spring Data JPA将创建一个实现。

现在，您可以连接此示例并查看其外观！

创建一个应用程序类

Spring Initializr为应用程序创建一个简单的类。以下清单显示了Initializr为此示例创建的类（在中src/main/java/com/example/accessingdatajpa/AccessingDataJpaApplication.java）：

package com.example.accessingdatajpa;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class AccessingDataJpaApplication {

  public static void main(String[] args) {
    SpringApplication.run(AccessingDataJpaApplication.class, args);
  }

}

@SpringBootApplication 是一个方便注释，它添加了以下所有内容：

@Configuration：将类标记为应用程序上下文的Bean定义的源。
@EnableAutoConfiguration：告诉Spring Boot根据类路径设置，其他bean和各种属性设置开始添加bean。例如，如果spring-webmvc在类路径上，则此注释将应用程序标记为Web应用程序并激活关键行为，例如设置DispatcherServlet。
@ComponentScan：告诉Spring在包中寻找其他组件，配置和服务com/example，让它找到控制器。

该main()方法使用Spring Boot的SpringApplication.run()方法来启动应用程序。您是否注意到没有一行XML？也没有web.xml文件。该Web应用程序是100％纯Java，因此您无需处理任何管道或基础结构。

现在，您需要修改Initializr为您创建的简单类。为了获得输出（在本例中为控制台），您需要设置一个记录器。然后，您需要设置一些数据并将其用于生成输出。以下清单显示了完成的AccessingDataJpaApplication类（在中src/main/java/com/example/accessingdatajpa/AccessingDataJpaApplication.java）：

package com.example.accessingdatajpa;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class AccessingDataJpaApplication {

  private static final Logger log = LoggerFactory.getLogger(AccessingDataJpaApplication.class);

  public static void main(String[] args) {
    SpringApplication.run(AccessingDataJpaApplication.class);
  }

  @Bean
  public CommandLineRunner demo(CustomerRepository repository) {
    return (args) -> {
      // save a few customers
      repository.save(new Customer("Jack", "Bauer"));
      repository.save(new Customer("Chloe", "O'Brian"));
      repository.save(new Customer("Kim", "Bauer"));
      repository.save(new Customer("David", "Palmer"));
      repository.save(new Customer("Michelle", "Dessler"));

      // fetch all customers
      log.info("Customers found with findAll():");
      log.info("-------------------------------");
      for (Customer customer : repository.findAll()) {
        log.info(customer.toString());
      }
      log.info("");

      // fetch an individual customer by ID
      Customer customer = repository.findById(1L);
      log.info("Customer found with findById(1L):");
      log.info("--------------------------------");
      log.info(customer.toString());
      log.info("");

      // fetch customers by last name
      log.info("Customer found with findByLastName('Bauer'):");
      log.info("--------------------------------------------");
      repository.findByLastName("Bauer").forEach(bauer -> {
        log.info(bauer.toString());
      });
      // for (Customer bauer : repository.findByLastName("Bauer")) {
      //  log.info(bauer.toString());
      // }
      log.info("");
    };
  }

}

本AccessingDataJpaApplication类包括demo()这使该方法CustomerRepository通过几个测试。首先，它CustomerRepository从Spring应用程序上下文中获取。然后，它保存了一些Customer对象，展示了该save()方法并设置了一些可使用的数据。接下来，它调用findAll()以Customer从数据库中获取所有对象。然后，它调用findById()以Customer按其ID提取单个。最后，它调用findByLastName()以查找姓氏为“ Bauer”的所有客户。该demo()方法返回一个CommandLineRunnerbean，该bean在应用程序启动时自动运行代码。

默认情况下，Spring Boot启用JPA存储库支持，并在所位于的包（及其子包）中查找@SpringBootApplication。如果您的配置在不可见的程序包中有JPA存储库接口定义，则可以使用@EnableJpaRepositories及其类型安全basePackageClasses=MyRepository.class参数指出备用程序包。

建立可执行的JAR

您可以使用Gradle或Maven从命令行运行该应用程序。您还可以构建一个包含所有必需的依赖项，类和资源的可执行JAR文件，然后运行该文件。生成可执行jar使得在整个开发生命周期中，跨不同环境等等的情况下，都可以轻松地将服务作为应用程序进行发布，版本控制和部署。

如果您使用Gradle，则可以使用来运行该应用程序./gradlew bootRun。或者，您可以使用来构建JAR文件./gradlew build，然后运行JAR文件，如下所示：

java -jar build / libs / gs-accessing-data-jpa-0.1.0.jar

如果您使用Maven，则可以使用来运行该应用程序./mvnw spring-boot:run。或者，您可以使用来构建JAR文件，./mvnw clean package然后运行JAR文件，如下所示：

java -jar target / gs-accessing-data-jpa-0.1.0.jar

此处描述的步骤将创建可运行的JAR。您还可以构建经典的WAR文件。

运行应用程序时，应该看到类似于以下内容的输出：

==使用findAll（）找到的客户：
Customer [id = 1，firstName ='Jack'，lastName ='Bauer']
客户[id = 2，firstName ='Chloe'，lastName ='O'Brian']
客户[id = 3，firstName ='Kim'，lastName ='Bauer']
Customer [id = 4，firstName ='David'，lastName ='Palmer']
Customer [id = 5，firstName ='Michelle'，lastName ='Dessler']

==找到findById（1L）的客户：
Customer [id = 1，firstName ='Jack'，lastName ='Bauer']

==找到findByLastName（'Bauer'）的客户：
Customer [id = 1，firstName ='Jack'，lastName ='Bauer']
客户[id = 3，firstName ='Kim'，lastName ='Bauer']

概括

恭喜你！您已经编写了一个简单的应用程序，该应用程序使用Spring Data JPA将对象保存到数据库中并从数据库中获取它们，而所有这些都无需编写具体的存储库实现。

如果您想轻松地使用基于超媒体的RESTful前端公开JPA存储库，则可能需要阅读使用REST访问JPA数据。

也可以看看

以下指南也可能会有所帮助：

是否要编写新指南或为现有指南做出贡献？查看我们的贡献准则。

所有指南均以代码的ASLv2许可证和写作的Attribution，NoDerivatives创用CC许可证发布。