# 数据

Spring Boot 集成了许多数据技术,包括 SQL 和 NoSQL。

# 1. SQL 数据库


Spring Framework (opens new window)为使用 SQL 数据库提供了广泛的支持,从使用JdbcTemplate直接访问 JDBC 到完成诸如 Hibernate 之类的“对象关系映射”技术。Spring Data (opens new window)提供了一个额外的功能级别:直接从接口创建Repository实现,并使用约定从你的方法名称生成查询。

# 1.1.配置数据源

Java 的javax.sql.DataSource接口提供了一种处理数据库连接的标准方法。传统上,“数据源”使用URL以及一些凭据来建立数据库连接。

有关更高级的示例,请参见“操作指南”部分,通常用于完全控制数据源的配置。

# 1.1.1.嵌入式数据库支持

使用嵌入式数据库开发应用程序通常是很方便的。显然,内存数据库不提供持久存储。你需要在应用程序启动时填充数据库,并准备在应用程序结束时丢弃数据。

“how-to”部分包括关于如何初始化数据库的一节

Spring 引导可以自动配置嵌入式H2 (opens new window)HSQL (opens new window)Derby (opens new window)数据库。你不需要提供任何连接 URL。你只需要对要使用的嵌入式数据库包含一个构建依赖项。如果在 Classpath 上有多个嵌入式数据库,请设置spring.datasource.embedded-database-connection配置属性以控制使用哪个数据库。将属性设置为none将禁用嵌入式数据库的自动配置。

如果你在测试中使用此功能,你可能会注意到,无论你使用的应用程序上下文的数量如何,整个测试套件都可以重用相同的数据库,如果你想确保每个上下文都有一个单独的嵌入式数据库,
,你应该将spring.datasource.generate-unique-name设置为true

例如,典型的 POM 依赖关系如下:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>org.hsqldb</groupId>
    <artifactId>hsqldb</artifactId>
    <scope>runtime</scope>
</dependency>
你需要对spring-jdbc有一个依赖关系,才能自动配置嵌入式数据库。
在本例中,它是通过spring-boot-starter-data-jpa传递地拉入的。
无论出于何种原因,如果你确实为嵌入式数据库配置了连接 URL,请注意确保禁用数据库的自动关闭。
如果你使用 H2,则应使用DB_CLOSE_ON_EXIT=FALSE,如果你使用 HSQLDB,请使用
,你应该确保不使用shutdown=true
禁用数据库的自动关机可以在数据库关闭时进行引导控制,从而确保在不再需要访问数据库时发生这种情况。

# 1.1.2.与生产数据库的连接

还可以通过使用池DataSource自动配置生产数据库连接。

# 1.1.3.数据源配置

数据源配置由spring.datasource.*中的外部配置属性控制。例如,你可以在application.properties中声明以下部分:

属性

spring.datasource.url=jdbc:mysql://localhost/test
spring.datasource.username=dbuser
spring.datasource.password=dbpass

Yaml

spring:
  datasource:
    url: "jdbc:mysql://localhost/test"
    username: "dbuser"
    password: "dbpass"
你至少应该通过设置spring.datasource.url属性来指定 URL。
否则, Spring 引导将尝试自动配置嵌入式数据库。
Spring 引导可以从 URL 推断出大多数数据库的 JDBC 驱动程序类。
如果需要指定特定的类,可以使用spring.datasource.driver-class-name属性。
对于要创建的池DataSource,我们需要能够验证一个有效的Driver类是可用的,所以我们在做任何事情之前都要检查它。
换句话说,如果你设置spring.datasource.driver-class-name=com.mysql.jdbc.Driver,那么这个类必须是可加载的。

参见[DataSource属性](https://github.com/ Spring-projects/ Spring-boot/tree/v2.6.4/ Spring-boot-project/ Spring-boot-autofigure/SRC/main/java/org/springframework/boot/autofigure/jdbc/dasourceproperties.java)以获得更多支持的选项。无论实际执行情况如何,这些都是标准选项。也可以通过使用它们各自的前缀(spring.datasource.hikari.*spring.datasource.tomcat.*spring.datasource.dbcp2.*,和spring.datasource.oracleucp.*)来微调实现特定的设置。有关更多详细信息,请参见你正在使用的连接池实现的文档。

例如,如果使用Tomcat connection pool (opens new window),则可以自定义许多其他设置,如下例所示:

属性

spring.datasource.tomcat.max-wait=10000
spring.datasource.tomcat.max-active=50
spring.datasource.tomcat.test-on-borrow=true

Yaml

spring:
  datasource:
    tomcat:
      max-wait: 10000
      max-active: 50
      test-on-borrow: true

这将设置池等待 10000ms,然后在没有可用连接的情况下抛出异常,将最大连接数量限制为 50,并在从池中借用连接之前验证连接。

# 1.1.4.支持的连接池

Spring 启动使用以下算法来选择具体的实现方式:

  1. 我们更喜欢Hikaricp (opens new window)的性能和并发性。如果有 Hikaricp,我们总是选择它。

  2. 否则,如果 Tomcat 池DataSource可用,则使用它。

  3. 否则,如果Commons DBCP2 (opens new window)是可用的,我们就使用它。

  4. 如果 HIKARICP、 Tomcat 和 DBCP2 都不可用,并且如果 Oracle UCP 可用,我们就使用它。

如果使用spring-boot-starter-jdbcspring-boot-starter-data-jpa“starters”,则会自动获得对HikariCP的依赖关系。

你可以完全绕过该算法,并通过设置spring.datasource.type属性来指定要使用的连接池。如果你在 Tomcat 容器中运行应用程序,这一点尤其重要,因为tomcat-jdbc是默认提供的。

总是可以使用DataSourceBuilder手动配置其他连接池。如果你定义了自己的DataSource Bean,则不会发生自动配置。DataSourceBuilder支持以下连接池:

  • HikariCP

  • Tomcat 池Datasource

  • Commons DBCP2

  • Oracle UCP&OracleDataSource

  • Spring 框架的SimpleDriverDataSource

  • h2JdbcDataSource

  • PostgreSQLPGSimpleDataSource

# 1.1.5.连接到 JNDI 数据源

如果你将 Spring 引导应用程序部署到应用程序服务器,那么你可能希望通过使用应用程序服务器的内置功能来配置和管理你的数据源,并通过使用 JNDI 访问它。

spring.datasource.jndi-name属性可以用作spring.datasource.urlspring.datasource.usernamespring.datasource.password属性的替代选项,以从特定的 JNDI 位置访问DataSource。例如,application.properties中的以下部分显示了如何按照DataSource的定义访问 JBoss:

属性

spring.datasource.jndi-name=java:jboss/datasources/customers

Yaml

spring:
  datasource:
    jndi-name: "java:jboss/datasources/customers"

# 1.2.使用 JDBCTemplate

Spring 的JdbcTemplateNamedParameterJdbcTemplate类是自动配置的,并且你可以将它们@Autowire直接放入你自己的 bean 中,如以下示例所示:

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final JdbcTemplate jdbcTemplate;

    public MyBean(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public void doSomething() {
        this.jdbcTemplate ...
    }

}

你可以使用spring.jdbc.template.*属性自定义模板的一些属性,如下例所示:

属性

spring.jdbc.template.max-rows=500

Yaml

spring:
  jdbc:
    template:
      max-rows: 500
NamedParameterJdbcTemplate在幕后重用相同的JdbcTemplate实例。
如果定义了多个JdbcTemplate且不存在主要候选项,则NamedParameterJdbcTemplate不会自动配置。

# 1.3. JPA 和 Spring 数据 JPA

Java Persistence API 是一种标准技术,它允许你将对象“映射”到关系数据库。spring-boot-starter-data-jpa POM 提供了一种快速入门的方法。它提供了以下关键依赖项:

  • Hibernate:最流行的实现方式之一 JPA。

  • Spring 数据 JPA:帮助你实现基于 JPA 的存储库。

  • Spring ORM:来自 Spring 框架的核心 ORM 支持。

在这里,我们不会对 JPA 或Spring Data (opens new window)进行过多的详细说明。
你可以按照“Accessing Data with JPA” (opens new window)中的“Accessing Data with JPA” (opens new window)指南,并阅读Spring Data JPA (opens new window)Hibernate (opens new window)参考文档。

# 1.3.1.实体类别

传统上, JPA“实体”类是在persistence.xml文件中指定的。在 Spring 启动时,这个文件不是必需的,而是使用“实体扫描”。默认情况下,将搜索主配置类下面的所有包(注释为@EnableAutoConfiguration@SpringBootApplication的包)。

任何带有@Entity@Embeddable@MappedSuperclass注释的类都将被考虑。典型的实体类类似于以下示例:

import java.io.Serializable;

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

@Entity
public class City implements Serializable {

    @Id
    @GeneratedValue
    private Long id;

    @Column(nullable = false)
    private String name;

    @Column(nullable = false)
    private String state;

    // ... additional members, often include @OneToMany mappings

    protected City() {
        // no-args constructor required by JPA spec
        // this one is protected since it should not be used directly
    }

    public City(String name, String state) {
        this.name = name;
        this.state = state;
    }

    public String getName() {
        return this.name;
    }

    public String getState() {
        return this.state;
    }

    // ... etc

}

你可以使用@EntityScan注释自定义实体扫描位置。
参见“howto.html”操作方法。

# 1.3.2. Spring 数据 JPA 存储库

Spring Data JPA (opens new window)存储库是你可以定义以访问数据的接口。 JPA 查询是根据你的方法名称自动创建的。例如,一个CityRepository接口可以声明一个findAllByState(String state)方法来查找给定状态下的所有城市。

对于更复杂的查询,你可以使用 Spring data 的[Query](https://DOCS. Spring.io/ Spring-data/ JPA/DOCS/2.6.2/api/org/springframework/data/ JPA/repository/query.html)注释来注释你的方法。

Spring 数据存储库通常扩展自[Repository](https://DOCS. Spring.io/ Spring-data/commons/DOCS/2.6.2/api/org/springframework/data/repository/repository.html)或[CrudRepository(https://DOCS. Spring.io/ Spring-data/commons/DOCS/2.6.2/api/org/springframFramework/data/depository.html)接口。如果使用自动配置,那么存储库将从包含主配置类(用@EnableAutoConfiguration@SpringBootApplication注释的类)的包中向下搜索。

下面的示例显示了典型的 Spring 数据存储库接口定义:

import org.springframework.boot.docs.data.sql.jpaandspringdata.entityclasses.City;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.repository.Repository;

public interface CityRepository extends Repository<City, Long> {

    Page<City> findAll(Pageable pageable);

    City findByNameAndStateAllIgnoringCase(String name, String state);

}

Spring 数据 JPA 存储库支持三种不同的引导模式:默认模式、延迟模式和惰性模式。要启用延迟引导或延迟引导,将spring.data.jpa.repositories.bootstrap-mode属性分别设置为deferredlazy。当使用延迟或延迟引导时,自动配置的EntityManagerFactoryBuilder将使用上下文的AsyncTaskExecutor(如果有的话)作为引导执行器。如果存在多个选项,将使用名为applicationTaskExecutor的选项。

当使用延迟引导或延迟引导时,请确保在应用程序上下文引导阶段之后推迟对 JPA 基础架构的任何访问。
你可以使用SmartInitializingSingleton来调用任何需要 JPA 基础架构的初始化。
对于创建为 Spring bean 的 JPA 组件(例如转换器),使用ObjectProvider来延迟依赖关系的解决(如果有的话)。
我们几乎没有触及 Spring 数据 JPA 的表面。
有关完整的详细信息,请参见Spring Data JPA reference documentation (opens new window)

# 1.3.3. Spring 数据影响存储库

如果Spring Data Envers (opens new window)可用, JPA 存储库将自动配置为支持典型的 Envers 查询。

要使用 Spring data envers,请确保你的存储库从RevisionRepository扩展,如下例所示:

import org.springframework.boot.docs.data.sql.jpaandspringdata.entityclasses.Country;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.repository.Repository;
import org.springframework.data.repository.history.RevisionRepository;

public interface CountryRepository extends RevisionRepository<Country, Long, Integer>, Repository<Country, Long> {

    Page<Country> findAll(Pageable pageable);

}

有关更多详细信息,请查看Spring Data Envers reference documentation (opens new window)

# 1.3.4.创建和删除 JPA 数据库

默认情况下,如果使用嵌入式数据库(H2、HSQL 或 Derby),将自动创建 JPA 数据库只有。你可以使用spring.jpa.*属性显式地配置 JPA 设置。例如,要创建和删除表格,你可以在application.properties中添加以下行:

属性

spring.jpa.hibernate.ddl-auto=create-drop

Yaml

spring:
  jpa:
    hibernate.ddl-auto: "create-drop"
Hibernate 自己的内部属性名称(如果你能更好地记住它的话)是hibernate.hbm2ddl.auto
,你可以将其与其他 Hibernate 本机属性一起设置,通过使用spring.jpa.properties.*(前缀在将其添加到实体管理器之前被剥离)。
下面的一行显示了为 Hibernate 设置 JPA 属性的示例:

属性

spring.jpa.properties.hibernate[globally_quoted_identifiers]=true

Yaml

spring:
  jpa:
    properties:
      hibernate:
        "globally_quoted_identifiers": "true"

前面示例中的行将hibernate.globally_quoted_identifiers属性的值true传递给 Hibernate 实体管理器。

默认情况下,DDL 的执行(或验证)被推迟到ApplicationContext已经开始时。还有一个spring.jpa.generate-ddl标志,但如果 Hibernate 自动配置是活动的,则不会使用它,因为ddl-auto设置的粒度更细。

# 1.3.5.在视图中打开 EntityManager

如果你正在运行一个 Web 应用程序, Spring 默认引导寄存器[OpenEntityManagerInViewInterceptor](https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/orm/ JPA/support/openentitymanagerinviewinterceptor.html)应用“Opentitymanager in view”模式,以允许在 Web 视图中进行延迟加载。如果不希望发生这种行为,则应在application.properties中将spring.jpa.open-in-view设置为false

# 1.4. Spring 数据 JDBC

Spring 数据包括对 JDBC 的存储库支持,并且将为CrudRepository上的方法自动生成 SQL。对于更高级的查询,提供了@Query注释。

Spring 当必要的依赖关系在 Classpath 上时,启动将自动配置 Spring 数据的 JDBC 存储库。它们可以通过对spring-boot-starter-data-jdbc的单一依赖添加到你的项目中。如果有必要,你可以通过向应用程序添加@EnableJdbcRepositories注释或JdbcConfiguration子类来控制 Spring 数据 JDBC 的配置。

有关 Spring 数据 JDBC 的完整详细信息,请参见参考文献 (opens new window)

# 1.5.使用 H2 的网络控制台

H2 数据库 (opens new window)提供了一个基于浏览器的控制台 (opens new window), Spring 引导可以为你自动配置。当满足以下条件时,控制台将自动配置:

如果你不使用 Spring Boot 的开发工具,但仍想使用 H2 的控制台,则可以配置spring.h2.console.enabled属性,其值为true
H2 控制台仅用于开发过程中,因此你应该注意确保在生产过程中不将spring.h2.console.enabled设置为true

# 1.5.1.改变 H2 控制台的路径

默认情况下,控制台位于/h2-console。你可以使用spring.h2.console.path属性来定制控制台的路径。

# 1.6.使用 Jooq

Jooq 面向对象查询(jOOQ (opens new window))是数据极客 (opens new window)中的一种流行产品,它从你的数据库生成 Java 代码,并允许你通过其 Fluent API 构建类型安全的 SQL 查询。商业版和开放源代码版都可以与 Spring boot 一起使用。

# 1.6.1.代码生成

为了使用 Jooq 类型安全查询,你需要从数据库模式生成 Java 类。你可以按照Jooq 用户手册 (opens new window)中的说明进行操作。如果你使用jooq-codegen-maven插件,并且还使用spring-boot-starter-parent“parent POM”,则可以安全地省略该插件的<version>标记。你还可以使用 Spring 引导定义的版本变量(例如h2.version)来声明插件的数据库依赖关系。下面的清单展示了一个示例:

<plugin>
    <groupId>org.jooq</groupId>
    <artifactId>jooq-codegen-maven</artifactId>
    <executions>
        ...
    </executions>
    <dependencies>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>${h2.version}</version>
        </dependency>
    </dependencies>
    <configuration>
        <jdbc>
            <driver>org.h2.Driver</driver>
            <url>jdbc:h2:~/yourdatabase</url>
        </jdbc>
        <generator>
            ...
        </generator>
    </configuration>
</plugin>

# 1.6.2.使用 DSLContext

由 Jooq 提供的 Fluent API 是通过org.jooq.DSLContext接口启动的。 Spring 引导自动将DSLContext配置为 Spring Bean,并将其连接到你的应用程序DataSource。要使用DSLContext,你可以注入它,如以下示例所示:

import java.util.GregorianCalendar;
import java.util.List;

import org.jooq.DSLContext;

import org.springframework.stereotype.Component;

import static org.springframework.boot.docs.data.sql.jooq.dslcontext.Tables.AUTHOR;

@Component
public class MyBean {

    private final DSLContext create;

    public MyBean(DSLContext dslContext) {
        this.create = dslContext;
    }

}

Jooq 手册倾向于使用一个名为create的变量来保存DSLContext

然后,你可以使用DSLContext来构造查询,如下例所示:

public List<GregorianCalendar> authorsBornAfter1980() {
    return this.create.selectFrom(AUTHOR)
            .where(AUTHOR.DATE_OF_BIRTH.greaterThan(new GregorianCalendar(1980, 0, 1)))
            .fetch(AUTHOR.DATE_OF_BIRTH);

# 1.6.3.Jooq SQL 方言

除非已经配置了spring.jooq.sql-dialect属性,否则 Spring boot 将确定要用于数据源的 SQL 方言。如果 Spring boot 无法检测到该方言,则使用DEFAULT

Spring 启动只能自动配置由开源版本的 Jooq 支持的方言。

# 1.6.4.定制 Jooq

可以通过定义你自己的DefaultConfigurationCustomizer Bean 来实现更高级的自定义,该自定义将在创建org.jooq.Configuration``@Bean之前调用。这优先于自动配置所应用的任何内容。

如果你想完全控制 Jooq 配置,还可以创建自己的org.jooq.Configuration``@Bean

# 1.7.使用 R2DBC

反应式关系数据库连接(R2DBC (opens new window))项目将反应式编程 API 引入到关系数据库中。R2DBC 的io.r2dbc.spi.Connection提供了一种处理非阻塞数据库连接的标准方法。使用ConnectionFactory提供连接,类似于使用 JDBC 提供DataSource

ConnectionFactory配置由spring.r2dbc.*中的外部配置属性控制。例如,你可以在application.properties中声明以下部分:

属性

spring.r2dbc.url=r2dbc:postgresql://localhost/test
spring.r2dbc.username=dbuser
spring.r2dbc.password=dbpass

Yaml

spring:
  r2dbc:
    url: "r2dbc:postgresql://localhost/test"
    username: "dbuser"
    password: "dbpass"
你不需要指定驱动程序类名,因为 Spring Boot 从 R2DBC 的连接工厂发现获得驱动程序。
至少应该提供 URL。
URL 中指定的信息优先于单个属性,即nameusernamepassword和池选项。
“how-to”部分包括关于如何初始化数据库的一节

要自定义由ConnectionFactory创建的连接,即设置在中央数据库配置中不希望(或不能)配置的特定参数,可以使用ConnectionFactoryOptionsBuilderCustomizer``@Bean。下面的示例展示了如何手动重写数据库端口,而其余的选项将从应用程序配置中获取:

import io.r2dbc.spi.ConnectionFactoryOptions;

import org.springframework.boot.autoconfigure.r2dbc.ConnectionFactoryOptionsBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class MyR2dbcConfiguration {

    @Bean
    public ConnectionFactoryOptionsBuilderCustomizer connectionFactoryPortCustomizer() {
        return (builder) -> builder.option(ConnectionFactoryOptions.PORT, 5432);
    }

}

以下示例展示了如何设置一些 PostgreSQL 连接选项:

import java.util.HashMap;
import java.util.Map;

import io.r2dbc.postgresql.PostgresqlConnectionFactoryProvider;

import org.springframework.boot.autoconfigure.r2dbc.ConnectionFactoryOptionsBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class MyPostgresR2dbcConfiguration {

    @Bean
    public ConnectionFactoryOptionsBuilderCustomizer postgresCustomizer() {
        Map<String, String> options = new HashMap<>();
        options.put("lock_timeout", "30s");
        options.put("statement_timeout", "60s");
        return (builder) -> builder.option(PostgresqlConnectionFactoryProvider.OPTIONS, options);
    }

}

ConnectionFactory Bean 可用时,常规的 JDBCDataSource自动配置将退出。如果你希望保留 JDBCDataSource自动配置,并且对在反应性应用程序中使用阻塞 JDBC API 的风险感到满意,那么在应用程序中的@Import(DataSourceAutoConfiguration.class)类上添加@Import(DataSourceAutoConfiguration.class)以重新启用它。

# 1.7.1.嵌入式数据库支持

JDBC 支持类似, Spring 引导可以自动配置嵌入式数据库以用于被动使用。你不需要提供任何连接 URL。你只需要对要使用的嵌入式数据库包含一个构建依赖项,如以下示例所示:

<dependency>
    <groupId>io.r2dbc</groupId>
    <artifactId>r2dbc-h2</artifactId>
    <scope>runtime</scope>
</dependency>
如果在测试中使用此功能,你可能会注意到,无论你使用的应用程序上下文的数量如何,整个测试套件都可以重用相同的数据库,如果你想确保每个上下文都有一个单独的嵌入式数据库,
,你应该将spring.r2dbc.generate-unique-name设置为true

# 1.7.2.使用 DatabaseClient

aDatabaseClient Bean 是自动配置的,你可以@Autowire它直接进入你自己的 bean 中,如以下示例所示:

import java.util.Map;

import reactor.core.publisher.Flux;

import org.springframework.r2dbc.core.DatabaseClient;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final DatabaseClient databaseClient;

    public MyBean(DatabaseClient databaseClient) {
        this.databaseClient = databaseClient;
    }

    // ...

    public Flux<Map<String, Object>> someMethod() {
        return this.databaseClient.sql("select * from user").fetch().all();
    }

}

# 1.7.3. Spring 数据 R2DBC 存储库

Spring Data R2DBC (opens new window)存储库是你可以定义以访问数据的接口。查询是根据你的方法名称自动创建的。例如,CityRepository接口可以声明一个findAllByState(String state)方法来查找给定州中的所有城市。

对于更复杂的查询,你可以使用 Spring data 的[Query](https://DOCS. Spring.io/ Spring-data/r2dbc/DOCS/1.4.2/api/org/springframework/data/r2dbc/repository/query.html)注释来注释你的方法。

Spring 数据存储库通常扩展自[Repository](https://DOCS. Spring.io/ Spring-data/commons/DOCS/2.6.2/api/org/springframework/data/repository/repository.html)或[CrudRepository](https://DOCS. Spring.io/ Spring-data/commons/DOCS/2.6.2/api/org/springframform/data/repository.html)接口。如果使用自动配置,那么存储库将从包含主配置类(用@EnableAutoConfiguration@SpringBootApplication注释的类)的包中向下搜索。

下面的示例显示了典型的 Spring 数据存储库接口定义:

import reactor.core.publisher.Mono;

import org.springframework.data.repository.Repository;

public interface CityRepository extends Repository<City, Long> {

    Mono<City> findByNameAndStateAllIgnoringCase(String name, String state);

}

我们几乎没有触及 Spring 数据 R2DBC 的表面。有关完整的详细信息,请参见Spring Data R2DBC reference documentation (opens new window)

# 2. 使用 NoSQL 技术


Spring Data 提供了帮助你访问各种 NoSQL 技术的附加项目,这些技术包括:

Spring Boot 为 Redis、MongoDB、NEO4J、SOLR、ElasticSearch、Cassandra、CouchBase、LDAP 和 InfluxDB 提供了自动配置。你可以使用其他项目,但必须自己配置它们。请参阅spring.io/projects/spring-data (opens new window)上的相应参考文档。

# 2.1.雷迪斯

Redis (opens new window)是一个缓存、消息代理和功能丰富的键值存储。 Spring Boot 为Lettuce (opens new window)Jedis (opens new window)客户端库以及Spring Data Redis (opens new window)在它们之上提供的抽象提供了基本的自动配置。

有一个spring-boot-starter-data-redis“starter”,可以方便地收集依赖项。默认情况下,它使用Lettuce (opens new window)。该启动器同时处理传统应用程序和被动应用程序。

我们还提供了spring-boot-starter-data-redis-reactive“starter”,以便与具有反应性支持的其他存储保持一致。

# 2.1.1.连接到 Redis

可以像其他任何实例 Spring Bean 一样,注入一个自动配置的RedisConnectionFactoryStringRedisTemplate或 vanillaRedisTemplate实例。默认情况下,实例尝试连接到localhost:6379的 Redis 服务器。下面的清单显示了这样的示例 Bean:

import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final StringRedisTemplate template;

    public MyBean(StringRedisTemplate template) {
        this.template = template;
    }

    // ...

    public Boolean someMethod() {
        return this.template.hasKey("spring");
    }

}

你还可以注册任意数量的实现LettuceClientConfigurationBuilderCustomizer的 bean 以进行更高级的自定义。ClientResources也可以使用ClientResourcesBuilderCustomizer进行自定义。
如果你使用 JEDIS,JedisClientConfigurationBuilderCustomizer也是可用的。
或者,你可以注册类型RedisStandaloneConfiguration的 Bean,RedisSentinelConfiguration,或RedisClusterConfiguration以完全控制配置。

如果你添加了你自己的@Bean的任何自动配置的类型,它将替换默认的类型(除了在RedisTemplate的情况下,当排除是基于 Bean 名称时,redisTemplate,而不是其类型)。

默认情况下,如果commons-pool2在 Classpath 上,则自动配置池连接工厂。

# 2.2.MongoDB

MongoDB (opens new window)是一个开源的 NoSQL 文档数据库,它使用类似 JSON 的模式,而不是传统的基于表的关系数据。 Spring Boot 为使用 MongoDB 提供了几种便利,包括spring-boot-starter-data-mongodbspring-boot-starter-data-mongodb-reactive“starters”。

# 2.2.1.连接到 MongoDB 数据库

要访问 MongoDB 数据库,你可以插入一个自动配置的org.springframework.data.mongodb.MongoDatabaseFactory。默认情况下,实例尝试以mongodb://localhost/test连接到 MongoDB 服务器。下面的示例展示了如何连接到 MongoDB 数据库:

import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;

import org.springframework.data.mongodb.MongoDatabaseFactory;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final MongoDatabaseFactory mongo;

    public MyBean(MongoDatabaseFactory mongo) {
        this.mongo = mongo;
    }

    // ...

    public MongoCollection<Document> someMethod() {
        MongoDatabase db = this.mongo.getMongoDatabase();
        return db.getCollection("users");
    }

}

如果你已经定义了自己的MongoClient,它将被用来自动配置一个合适的MongoDatabaseFactory

自动配置的MongoClient是使用MongoClientSettings Bean 创建的。如果你已经定义了自己的MongoClientSettings,则将不加修改地使用它,并且spring.data.mongodb属性将被忽略。否则,将自动配置MongoClientSettings,并将spring.data.mongodb属性应用到它。在这两种情况下,都可以声明一个或多个MongoClientSettingsBuilderCustomizerbean 来微调MongoClientSettings配置。将按顺序调用每个函数,并使用用于构建MongoClientSettingsMongoClientSettings.Builder

你可以设置spring.data.mongodb.uri属性来更改 URL 并配置其他设置,例如复制集,如下例所示:

属性

spring.data.mongodb.uri=mongodb://user:[email protected]:12345,mongo2.example.com:23456/test

Yaml

spring:
  data:
    mongodb:
      uri: "mongodb://user:[email protected]:12345,mongo2.example.com:23456/test"

或者,你可以使用离散属性指定连接细节。例如,你可以在application.properties中声明以下设置:

属性

spring.data.mongodb.host=mongoserver.example.com
spring.data.mongodb.port=27017
spring.data.mongodb.database=test
spring.data.mongodb.username=user
spring.data.mongodb.password=secret

Yaml

spring:
  data:
    mongodb:
      host: "mongoserver.example.com"
      port: 27017
      database: "test"
      username: "user"
      password: "secret"
如果没有指定spring.data.mongodb.port,则使用27017的默认值。
你可以从前面显示的示例中删除这一行。
如果不使用 Spring dataMongoDB,则可以注入<gtr="328"/> Bean 而不是使用<gtr="329"/>。<gtr="332"/>如果你想完全控制建立 MongoDB 连接,还可以声明你自己的<gtr="330"/>或<gtr="331"/> Bean。
如果你使用的是反应式驱动程序,则 SSL 需要 Netty。
如果 Netty 可用,并且使用的工厂尚未自定义,则自动配置将自动配置该工厂。

# 2.2.2.MongoTemplate

Spring Data MongoDB (opens new window)提供了一个[MongoTemplate](https://DOCS. Spring.io/ Spring-data/MongoDB/DOCS/3.3.2/api/org/SpringFramework/data/MongoDB/Core/MongoTemplate.html)类,其设计与 Spring 的JdbcTemplate非常相似。与JdbcTemplate一样, Spring 引导自动配置一个 Bean 以供你插入模板,如下所示:

import com.mongodb.client.MongoCollection;
import org.bson.Document;

import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final MongoTemplate mongoTemplate;

    public MyBean(MongoTemplate mongoTemplate) {
        this.mongoTemplate = mongoTemplate;
    }

    // ...

    public MongoCollection<Document> someMethod() {
        return this.mongoTemplate.getCollection("users");
    }

}

有关完整的详细信息,请参见[MongoOperationsJavadoc](https://DOCS. Spring.io/ Spring-data/MongoDB/DOCS/3.3.2/api/org/SpringFramework/data/MongoDB/Core/MongoOperations.html)。

# 2.2.3. Spring 数据 MongoDB 存储库

Spring 数据包括对 MongoDB 的存储库支持。与前面讨论的 JPA 存储库一样,基本原理是基于方法名自动构造查询。

实际上, Spring 数据 JPA 和 Spring 数据 MongoDB 共享相同的公共基础设施。你可以使用前面的 JPA 示例,假设City现在是一个 MongoDB 数据类,而不是 JPA @Entity,它以相同的方式工作,如以下示例所示:

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.repository.Repository;

public interface CityRepository extends Repository<City, Long> {

    Page<City> findAll(Pageable pageable);

    City findByNameAndStateAllIgnoringCase(String name, String state);

}

你可以使用@EntityScan注释自定义文档扫描位置。
有关 Spring Data MongoDB 的完整详细信息,包括其丰富的对象映射技术,请参见其参考文献 (opens new window)

# 2.2.4.嵌入式 Mongo

Spring Boot 提供了嵌入式 Mongo (opens new window)的自动配置。要在 Spring 引导应用程序中使用它,请在de.flapdoodle.embed:de.flapdoodle.embed.mongo上添加一个依赖项,并将spring.mongodb.embedded.version属性设置为与你的应用程序将在生产中使用的 MongoDB 版本匹配。

默认的下载配置允许访问[Embedded Mongo 的Version类]中列出的大多数版本(https://github.com/flapdoodle-oss/de.flapdoodle.embed.mongo/blob/de.flapdoodle.embed.mongo-3.0.0/SRC/main/java/de/flapdoodle/embed/mongo/do/dismission/version.java)
在试图下载服务器时,配置一个不可访问的版本将导致一个错误。
这样的错误可以通过定义一个适当配置的DownloadConfigBuilderCustomizer Bean 来纠正。

可以通过设置spring.data.mongodb.port属性来配置 Mongo 监听的端口。要使用随机分配的空闲端口,请使用 0。由MongoAutoConfiguration创建的MongoClient被自动配置为使用随机分配的端口。

如果不配置自定义端口,则默认情况下,嵌入式支持使用随机端口(而不是 27017)。

如果在 Classpath 上有 SLF4J,则 Mongo 产生的输出将自动路由到名为org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongo的记录器。

你可以声明自己的IMongodConfigIRuntimeConfigbean 来控制 Mongo 实例的配置和日志路由。可以通过声明DownloadConfigBuilderCustomizer Bean 来定制下载配置。

# 2.3.NEO4J

Neo4j (opens new window)是一个开源的 NoSQL 图数据库,它使用由第一类关系连接的节点的丰富数据模型,与传统的 RDBMS 方法相比,该模型更适合于连接的大数据。 Spring Boot 为使用 NEO4j 提供了几种便利,包括spring-boot-starter-data-neo4j“starter”。

# 2.3.1.连接到 NEO4J 数据库

要访问 NEO4J 服务器,可以插入自动配置的org.neo4j.driver.Driver。默认情况下,实例尝试使用 Bolt 协议连接到 NEO4J 服务器localhost:7687。下面的示例展示了如何注入一个 NEO4jDriver,它使你能够访问Session,其中包括:

import org.neo4j.driver.Driver;
import org.neo4j.driver.Session;
import org.neo4j.driver.Values;

import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final Driver driver;

    public MyBean(Driver driver) {
        this.driver = driver;
    }

    // ...

    public String someMethod(String message) {
        try (Session session = this.driver.session()) {
            return session.writeTransaction((transaction) -> transaction
                    .run("CREATE (a:Greeting) SET a.message = $message RETURN a.message + ', from node ' + id(a)",
                            Values.parameters("message", message))
                    .single().get(0).asString());
        }
    }

}

你可以使用spring.neo4j.*属性配置驱动程序的各个方面。下面的示例展示了如何配置要使用的 URI 和凭据:

属性

spring.neo4j.uri=bolt://my-server:7687
spring.neo4j.authentication.username=neo4j
spring.neo4j.authentication.password=secret

Yaml

spring:
  neo4j:
    uri: "bolt://my-server:7687"
    authentication:
      username: "neo4j"
      password: "secret"

自动配置的Driver是使用ConfigBuilder创建的。要微调其配置,请声明一个或多个ConfigBuilderCustomizerbean。每个都将按顺序调用ConfigBuilder,这是用来构建Driver的。

# 2.3.2. Spring 数据 NEO4J 存储库

Spring 数据存储库包括对 NEO4j 的支持。有关 Spring 数据 NEO4j 的完整详细信息,请参见参考文献 (opens new window)

Spring 数据 NEO4J 与 Spring 数据共享公共基础设施 JPA,就像许多其他 Spring 数据模块所做的那样。你可以从前面的 JPA 示例中将City定义为 Spring 数据 NEO4j@Node,而不是 JPA @Entity,并且存储库抽象以相同的方式工作,如以下示例所示:

import java.util.Optional;

import org.springframework.data.neo4j.repository.Neo4jRepository;

public interface CityRepository extends Neo4jRepository<City, Long> {

    Optional<City> findOneByNameAndState(String name, String state);

}

spring-boot-starter-data-neo4j“starter”支持存储库和事务管理。 Spring 使用Neo4jTemplateReactiveNeo4jTemplatebean,启动同时支持经典的和反应的 NEO4j 存储库。 Classpath 上的项目反应器是可用的时,反应方式也是自动配置的。

你可以通过在@Configuration- Bean 上分别使用@EnableNeo4jRepositories@EntityScan来定制查找存储库和实体的位置。

在使用反应样式的应用程序中,aReactiveTransactionManager不是自动配置的。
要启用事务管理,必须在你的配置中定义以下 Bean:

<br/>import org.neo4j.driver.Driver;<br/><br/>import org.springframework.context.annotation.Bean;<br/>import org.springframework.context.annotation.Configuration;<br/>import org.springframework.data.neo4j.core.ReactiveDatabaseSelectionProvider;<br/>import org.springframework.data.neo4j.core.transaction.ReactiveNeo4jTransactionManager;<br/><br/>@Configuration(proxyBeanMethods = false)<br/>public class MyNeo4jConfiguration {<br/><br/> @Bean<br/> public ReactiveNeo4jTransactionManager reactiveTransactionManager(Driver driver,<br/> ReactiveDatabaseSelectionProvider databaseNameProvider) {<br/> return new ReactiveNeo4jTransactionManager(driver, databaseNameProvider);<br/> }<br/><br/>}<br/><br/>

# 2.4.SOLR

阿帕奇 SOLR (opens new window)是一个搜索引擎。 Spring 启动为 SOLR5 的客户端库提供了基本的自动配置。

# 2.4.1.连接到 SOLR

你可以注入一个自动配置的SolrClient实例,就像你将注入任何其他 Spring Bean 实例一样。默认情况下,实例尝试连接到[localhost:8983/solr](http://localhost:8983/solr)的服务器。以下示例显示了如何注入 SOLR Bean:

import java.io.IOException;

import org.apache.solr.client.solrj.SolrClient;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.response.SolrPingResponse;

import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final SolrClient solr;

    public MyBean(SolrClient solr) {
        this.solr = solr;
    }

    // ...

    public SolrPingResponse someMethod() throws SolrServerException, IOException {
        return this.solr.ping("users");
    }

}

如果你添加你自己的@Bean类型的SolrClient,它将替换缺省值。

# 2.5.Elasticsearch

Elasticsearch (opens new window)是一个开源、分布式、RESTful 搜索和分析引擎。 Spring Boot 为 ElasticSearch 客户端提供了基本的自动配置。

Spring Boot 支持多个客户端:

  • 官方的 Java“low level”和“high level”REST 客户端

  • Spring Data ElasticSearch 提供的ReactiveElasticsearchClient

Spring Boot 提供了一个专用的“starter”,spring-boot-starter-data-elasticsearch

# 2.5.1.使用 REST 客户端连接到 ElasticSearch

ElasticSearch 附带两个不同的 REST 客户机 (opens new window),你可以使用它来查询集群:“低级别”客户端和“高级别”客户端。 Spring Boot 提供对“高级别”客户端的支持,该客户端附带org.elasticsearch.client:elasticsearch-rest-high-level-client。此外, Spring Boot 基于 Spring Framework 的WebClient提供对反应式客户端的支持,该客户端附带org.springframework.data:spring-data-elasticsearch。默认情况下,客户机将以[localhost:9200](http://localhost:9200)为目标。你可以使用spring.elasticsearch.*属性来进一步优化客户机的配置方式,如以下示例所示:

属性

spring.elasticsearch.uris=https://search.example.com:9200
spring.elasticsearch.socket-timeout=10s
spring.elasticsearch.username=user
spring.elasticsearch.password=secret

Yaml

spring:
  elasticsearch:
    uris: "https://search.example.com:9200"
    socket-timeout: "10s"
    username: "user"
    password: "secret"
# 使用 resthigLevelClient 连接到 ElasticSearch####

如果在 Classpath 上有elasticsearch-rest-high-level-client, Spring 引导将自动配置并注册一个RestHighLevelClient Bean。除了前面描述的属性之外,要微调RestHighLevelClient,你可以注册任意数量的 bean,这些 bean 实现RestClientBuilderCustomizer以进行更高级的自定义。要完全控制其注册,请定义RestClientBuilder Bean。

如果你的应用程序需要访问“low level”RestClient,则可以通过在自动配置的client.getLowLevelClient()上调用client.getLowLevelClient()来获得它。

此外,如果elasticsearch-rest-client-sniffer在 Classpath 上,则Sniffer被自动配置为自动从正在运行的 ElasticSearch 集群中发现节点,并将它们设置在RestHighLevelClient Bean 上。你可以进一步调整Sniffer的配置方式,如以下示例所示:

属性

spring.elasticsearch.restclient.sniffer.interval=10m
spring.elasticsearch.restclient.sniffer.delay-after-failure=30s

Yaml

spring:
  elasticsearch:
    restclient:
      sniffer:
        interval: "10m"
        delay-after-failure: "30s"
# 使用 ReactiveElasticSearchClient 连接到 ElasticSearch####

Spring Data Elasticsearch (opens new window)提供ReactiveElasticsearchClient用于以反应方式查询 ElasticSearch 实例。它是建立在 WebFlux 的WebClient之上的,因此spring-boot-starter-elasticsearchspring-boot-starter-webflux依赖关系都有助于启用此支持。

默认情况下, Spring 启动将自动配置并注册ReactiveElasticsearchClient。除了前面描述的属性外,spring.elasticsearch.webclient.*属性还可用于配置特定于反应性的设置,如以下示例所示:

属性

spring.elasticsearch.webclient.max-in-memory-size=1MB

Yaml

spring:
  elasticsearch:
    webclient:
      max-in-memory-size: "1MB"

如果spring.elasticsearch.spring.elasticsearch.webclient. 配置属性不够,并且希望完全控制客户机配置,则可以注册一个自定义的ClientConfiguration Bean。

# 2.5.2.通过使用 Spring 数据 #### 连接到 ElasticSearch

要连接到 ElasticSearch,必须定义一个RestHighLevelClient Bean,通过 Spring 引导自动配置,或者由应用程序手动提供(请参见前面的部分)。有了这种配置,ElasticsearchRestTemplate可以像任何其他 Spring Bean 一样注入,如以下示例所示:

import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final ElasticsearchRestTemplate template;

    public MyBean(ElasticsearchRestTemplate template) {
        this.template = template;
    }

    // ...

    public boolean someMethod(String id) {
        return this.template.exists(id, User.class);
    }

}

在存在spring-data-elasticsearch和使用WebClient所需的依赖关系(通常为spring-boot-starter-webflux)的情况下, Spring 引导还可以自动配置一个ReactiveElasticSearchClient和一个ReactiveElasticsearchTemplate作为 bean。他们相当于其他 REST 客户的被动反应。

# 2.5.3. Spring 数据弹性搜索库

Spring 数据包括对 ElasticSearch 的存储库支持。与前面讨论的 JPA 存储库一样,基本原则是根据方法名自动为你构造查询。

实际上, Spring 数据 JPA 和 Spring 数据弹性搜索共享相同的公共基础设施。你可以以前面的 JPA 为例,假设City现在是一个 ElasticSearch@Document类,而不是 JPA @Entity,它以同样的方式工作。

有关 Spring 数据 ElasticSearch 的完整详细信息,请参见参考文献 (opens new window)

Spring Boot 使用ElasticsearchRestTemplateReactiveElasticsearchTemplatebean,支持经典的和反应的 Elasticsearch 存储库。考虑到存在所需的依赖关系,这些 bean 很可能是通过 Spring 引导自动配置的。

如果你希望使用自己的模板来支持 ElasticSearch 存储库,则可以添加自己的ElasticsearchRestTemplateElasticsearchOperations``@Bean,只要它的名称为"elasticsearchTemplate"。这同样适用于ReactiveElasticsearchTemplateReactiveElasticsearchOperations,其 Bean 名称为"reactiveElasticsearchTemplate"

你可以选择使用以下属性禁用存储库支持:

属性

spring.data.elasticsearch.repositories.enabled=false

Yaml

spring:
  data:
    elasticsearch:
      repositories:
        enabled: false

# 2.6.卡桑德拉

Cassandra (opens new window)是一个开源的分布式数据库管理系统,旨在处理跨许多商品服务器的大量数据。 Spring Boot 提供了对 Cassandra 的自动配置以及Spring Data Cassandra (opens new window)在其之上提供的抽象。有一个spring-boot-starter-data-cassandra“starter”可以方便地收集依赖项。

# 2.6.1.连接到 Cassandra

你可以插入一个自动配置的CassandraTemplate或一个 CassandraCqlSession实例,就像你使用任何其他 Spring Bean 实例一样。spring.data.cassandra.*属性可用于自定义连接。通常,你提供keyspace-namecontact-points以及本地数据中心名称,如以下示例所示:

属性

spring.data.cassandra.keyspace-name=mykeyspace
spring.data.cassandra.contact-points=cassandrahost1:9042,cassandrahost2:9042
spring.data.cassandra.local-datacenter=datacenter1

Yaml

spring:
  data:
    cassandra:
      keyspace-name: "mykeyspace"
      contact-points: "cassandrahost1:9042,cassandrahost2:9042"
      local-datacenter: "datacenter1"

如果你的所有联系点的端口都是相同的,那么你可以使用快捷方式,并且只指定主机名,如下例所示:

属性

spring.data.cassandra.keyspace-name=mykeyspace
spring.data.cassandra.contact-points=cassandrahost1,cassandrahost2
spring.data.cassandra.local-datacenter=datacenter1

Yaml

spring:
  data:
    cassandra:
      keyspace-name: "mykeyspace"
      contact-points: "cassandrahost1,cassandrahost2"
      local-datacenter: "datacenter1"
这两个示例与端口默认设置9042相同。
如果需要配置端口,请使用spring.data.cassandra.port
Cassandra 驱动程序有自己的配置基础结构在 Classpath 的根位置加载application.conf

Spring boot 默认情况下不会查找这样的文件,但是可以使用spring.data.cassandra.config加载一个文件。
如果一个属性在spring.data.cassandra.*和配置文件中都存在,spring.data.cassandra.*中的值优先。

对于更高级的驱动程序自定义,你可以注册任意数量的实现DriverConfigLoaderBuilderCustomizer的 bean。
CqlSession可以使用类型为CqlSessionBuilderCustomizer的 Bean 进行自定义。
如果使用CqlSessionBuilder创建多个CqlSessionbean,请记住构建器是可变的,因此请确保为每个会话注入一个新的副本。

下面的代码清单展示了如何注入 Cassandra Bean:

import org.springframework.data.cassandra.core.CassandraTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final CassandraTemplate template;

    public MyBean(CassandraTemplate template) {
        this.template = template;
    }

    // ...

    public long someMethod() {
        return this.template.count(User.class);
    }

}

如果你添加你自己的@Bean类型的CassandraTemplate,它将替换缺省值。

# 2.6.2. Spring 数据卡桑德拉存储库

Spring 数据包括对 Cassandra 的基本存储库支持。目前,这比前面讨论的 JPA 存储库更加有限,并且需要用@Query注释查找方法。

有关 Spring 数据 Cassandra 的完整详细信息,请参见参考文献 (opens new window)

# 2.7.Couchbase

Couchbase (opens new window)是一个开源的、分布式的、多模型的面向 NoSQL 文档的数据库,它为交互式应用程序进行了优化。 Spring Boot 提供了对 CouchBase 的自动配置以及由Spring Data Couchbase (opens new window)提供的在其之上的抽象。有spring-boot-starter-data-couchbasespring-boot-starter-data-couchbase-reactive“启动器”,可以方便地收集依赖项。

# 2.7.1.连接到 Couchbase

你可以通过添加 CouchBase SDK 和一些配置来获得Clusterspring.couchbase.*属性可用于自定义连接。通常,你提供连接字符串 (opens new window)、用户名和密码,如以下示例所示:

属性

spring.couchbase.connection-string=couchbase://192.168.1.123
spring.couchbase.username=user
spring.couchbase.password=secret

Yaml

spring:
  couchbase:
    connection-string: "couchbase://192.168.1.123"
    username: "user"
    password: "secret"

也可以自定义一些ClusterEnvironment设置。例如,以下配置更改了用于打开新的Bucket并启用 SSL 支持的超时时间:

属性

spring.couchbase.env.timeouts.connect=3s
spring.couchbase.env.ssl.key-store=/location/of/keystore.jks
spring.couchbase.env.ssl.key-store-password=secret

Yaml

spring:
  couchbase:
    env:
      timeouts:
        connect: "3s"
      ssl:
        key-store: "/location/of/keystore.jks"
        key-store-password: "secret"
查看spring.couchbase.env.*属性以获得更多详细信息。
要获得更多控制权,可以使用一个或多个ClusterEnvironmentBuilderCustomizerbean。

# 2.7.2. Spring 数据 CouchBase 存储库

Spring 数据包括对 CouchBase 的存储库支持。有关 Spring Data Couchbase 的完整详细信息,请参见参考文献 (opens new window)

你可以注入一个自动配置的CouchbaseTemplate实例,就像使用任何其他 Spring Bean 一样,前提是CouchbaseClientFactory Bean 是可用的。如上所述,当Cluster可用时,并且指定了一个 bucket 名称时,就会发生这种情况:

属性

spring.data.couchbase.bucket-name=my-bucket

Yaml

spring:
  data:
    couchbase:
      bucket-name: "my-bucket"

以下示例显示了如何注入CouchbaseTemplate Bean:

import org.springframework.data.couchbase.core.CouchbaseTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final CouchbaseTemplate template;

    public MyBean(CouchbaseTemplate template) {
        this.template = template;
    }

    // ...

    public String someMethod() {
        return this.template.getBucketName();
    }

}

你可以在自己的配置中定义一些 bean 来覆盖自动配置提供的那些 bean:

  • aCouchbaseMappingContext``@Bean,其名称为couchbaseMappingContext

  • aCustomConversions``@Bean,其名称为couchbaseCustomConversions

  • aCouchbaseTemplate``@Bean,其名称为couchbaseTemplate

为了避免在自己的配置中对这些名称进行硬编码,你可以重用 Spring Data Couchbase 提供的BeanNames。例如,你可以自定义要使用的转换器,如下所示:

import org.assertj.core.util.Arrays;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.couchbase.config.BeanNames;
import org.springframework.data.couchbase.core.convert.CouchbaseCustomConversions;

@Configuration(proxyBeanMethods = false)
public class MyCouchbaseConfiguration {

    @Bean(BeanNames.COUCHBASE_CUSTOM_CONVERSIONS)
    public CouchbaseCustomConversions myCustomConversions() {
        return new CouchbaseCustomConversions(Arrays.asList(new MyConverter()));
    }

}

# 2.8.LDAP

LDAP (opens new window)(轻量级目录访问协议)是一种开放的、与供应商无关的行业标准应用程序协议,用于在 IP 网络上访问和维护分布式目录信息服务。 Spring 启动提供了对任何兼容的 LDAP 服务器的自动配置,以及对来自UnboundID (opens new window)的嵌入式内存中 LDAP 服务器的支持。

LDAP 抽象由Spring Data LDAP (opens new window)提供。有一个spring-boot-starter-data-ldap“starter”,可以方便地收集依赖项。

# 2.8.1.连接到 LDAP 服务器

要连接到 LDAP 服务器,请确保声明对spring-boot-starter-data-ldap“starter”或spring-ldap-core的依赖关系,然后在应用程序中声明服务器的 URL。属性,如以下示例所示:

属性

spring.ldap.urls=ldap://myserver:1235
spring.ldap.username=admin
spring.ldap.password=secret

Yaml

spring:
  ldap:
    urls: "ldap://myserver:1235"
    username: "admin"
    password: "secret"

如果需要自定义连接设置,可以使用spring.ldap.basespring.ldap.base-environment属性。

基于这些设置,可以自动配置LdapContextSource。如果DirContextAuthenticationStrategy Bean 是可用的,则它与自动配置的LdapContextSource相关联。如果你需要自定义它,例如使用PooledContextSource,你仍然可以注入自动配置的LdapContextSource。请确保将你定制的ContextSource标记为@Primary,以便自动配置的LdapTemplate使用它。

# 2.8.2. Spring 数据 LDAP 存储库

Spring 数据包括对 LDAP 的存储库支持。有关 Spring 数据 LDAP 的完整详细信息,请参见参考文献 (opens new window)

还可以像使用任何其他 Spring Bean 一样,注入一个自动配置的LdapTemplate实例,如以下示例所示:

import java.util.List;

import org.springframework.ldap.core.LdapTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final LdapTemplate template;

    public MyBean(LdapTemplate template) {
        this.template = template;
    }

    // ...

    public List<User> someMethod() {
        return this.template.findAll(User.class);
    }

}

# 2.8.3.嵌入式内存 LDAP 服务器

出于测试目的, Spring 引导支持UnboundID (opens new window)中的内存中 LDAP 服务器的自动配置。要配置服务器,请向com.unboundid:unboundid-ldapsdk添加一个依赖项,并声明一个spring.ldap.embedded.base-dn属性,如下所示:

Properties

spring.ldap.embedded.base-dn=dc=spring,dc=io

Yaml

spring:
  ldap:
    embedded:
      base-dn: "dc=spring,dc=io"
可以定义多个 base-dn 值,但是,由于专有名称通常包含逗号,因此必须使用正确的符号来定义它们。

在 YAML 文件中,可以使用 YAML 列表符号。在属性文件中,必须将索引作为属性名称的一部分包括在内:

属性



yaml
<br/>spring.ldap.embedded.base-dn:<br/> - "dc=spring,dc=io"<br/> - "dc=pivotal,dc=io"<br/>

默认情况下,服务器从一个随机端口启动,并触发常规的 LDAP 支持。不需要指定spring.ldap.urls属性。

如果在你的 Classpath 上有一个schema.ldif文件,它将用于初始化服务器。如果希望从其他资源加载初始化脚本,还可以使用spring.ldap.embedded.ldif属性。

默认情况下,标准模式用于验证LDIF文件。你可以通过设置spring.ldap.embedded.validation.enabled属性来完全关闭验证。如果你有自定义属性,你可以使用spring.ldap.embedded.validation.schema来定义你的自定义属性类型或对象类。

# 2.9.影响 b

InfluxDB (opens new window)是一个开放源代码的时间序列数据库,该数据库经过优化,可用于快速、高可用性地存储和检索操作监控、应用度量、物联网传感器数据和实时分析等领域的时间序列数据。

# 2.9.1.连接到 InfluxDB

Spring 引导自动配置InfluxDB实例,前提是influxdb-java客户端在 Classpath 上并且设置了数据库的 URL,如以下示例所示:

Properties

spring.influx.url=https://172.0.0.1:8086

Yaml

spring:
  influx:
    url: "https://172.0.0.1:8086"

如果到 InfluxDB 的连接需要用户和密码,则可以相应地设置spring.influx.userspring.influx.password属性。

InfluxDB 依赖于 OkHTTP。如果你需要调优幕后使用的 HTTP 客户端InfluxDB,则可以注册一个InfluxDbOkHttpClientBuilderProvider Bean。

如果需要对配置进行更多控制,可以考虑注册InfluxDbCustomizer Bean。

# 3. 接下来要读什么?


你现在应该对如何在各种数据技术中使用 Spring 引导有了一种感觉。从这里,你可以了解 Spring boot 对各种消息传递技术的支持,以及如何在应用程序中启用它们。