Spring Boot数据

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

1. SQL 数据库

Spring 框架为使用 SQL 数据库提供了广泛的支持，从使用直接 JDBC 访问到​​JdbcTemplate​​完整的“对象关系映射”技术，如 Hibernate。 Spring Data提供了额外级别的功能：​​Repository​​直接从接口创建实现并使用约定从您的方法名称生成查询。

1.1配置数据源

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

1.1.1嵌入式数据库支持

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

Spring Boot 可以自动配置嵌入式H2、HSQL和Derby数据库。您无需提供任何连接 URL。您只需要包含对要使用的嵌入式数据库的构建依赖项。如果类路径上有多个嵌入式数据库，请设置​​spring.datasource.embedded-database-connection​​配置属性以控制使用哪一个。将该属性设置为​​none​​禁用嵌入式数据库的自动配置。

例如，典型的 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>

1.1.2连接到生产数据库

生产数据库连接也可以使用 pooling 自动配置​​DataSource​​。

1.1.3数据源配置

DataSource 配置由​​spring.datasource.*​​. 例如，您可以在 中声明以下部分​​application.properties​​：

特性

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

有关DataSourceProperties​更多受支持的选项，请参阅。无论实际实施​如何，这些都是标准选项。​​spring.datasource.hikari.*​​​也可以通过使用它们各自的前缀（ 、​​spring.datasource.tomcat.*​​​、​​spring.datasource.dbcp2.*​​​和​​spring.datasource.oracleucp.*​​）来微调特定于实现的设置。有关更多详细信息，请参阅您正在使用的连接池实现的文档。

例如，如果您使用Tomcat 连接池，您可以自定义许多附加设置，如下例所示：

特性

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

如果没有可用的连接，这会将池设置为在抛出异常之前等待 10000 毫秒，将最大连接数限制为 50，并在从池中借用连接之前验证连接。

1.1.4支持的连接池

Spring Boot 使用以下算法来选择特定的实现：

1. 我们更喜欢HikariCP的性能和并发性。如果 HikariCP 可用，我们总是选择它。
2. 否则，如果 Tomcat 池DataSource可用，我们就使用它。
3. 否则，如果Commons DBCP2可用，我们将使用它。
4. 如果 HikariCP、Tomcat 和 DBCP2 都不可用，而如果 Oracle UCP 可用，我们就使用它。

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

额外的连接池总是可以手动配置，使用​​DataSourceBuilder​​. 如果您定义自己的​​DataSource​​bean，则不会发生自动配置。支持以下连接池​​DataSourceBuilder​​：

• 光CP
• Tomcat 池化Datasource
• 公地 DBCP2
• 甲骨文UCP &OracleDataSource
• Spring框架的SimpleDriverDataSource
• H2JdbcDataSource
• PostgreSQLPGSimpleDataSource
• C3P0

1.1.5连接到 JNDI 数据源

如果您将 Spring Boot 应用程序部署到 Application Server，您可能希望使用 Application Server 的内置功能配置和管理 DataSource，并使用 JNDI 访问它。

该​​spring.datasource.jndi-name​​属性可用作 、 和 属性的替代方法，​​spring.datasource.url​​以​​spring.datasource.username​​从​​spring.datasource.password​​特定​​DataSource​​JNDI 位置访问 。例如，以下部分​​application.properties​​显示了如何访问 JBoss AS 定义的​​DataSource​​：

特性

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

1.2. 使用 JdbcTemplate

Spring​​JdbcTemplate​​和​​NamedParameterJdbcTemplate​​类是自动配置的，您可以​​@Autowire​​将它们直接放入您自己的 bean 中，如下例所示：

@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

1.3. JPA 和 Spring Data JPA

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

• Hibernate：最流行的 JPA 实现之一。
• Spring Data JPA：帮助您实现基于 JPA 的存储库。
• Spring ORM：来自 Spring Framework 的核心 ORM 支持。

1.3.1实体类

传统上，JPA“实体”类在​​persistence.xml​​文件中指定。使用 Spring Boot，此文件不是必需的，而是使用“实体扫描”。默认情况下，将搜索主配置类下的所有包（带有​​@EnableAutoConfiguration​​或注释的包​​@SpringBootApplication​​）。

​​@Entity​​任何用、​​@Embeddable​​或注释的类都会​​@MappedSuperclass​​被考虑。典型的实体类类似于以下示例：

@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

}

1.3.2. Spring Data JPA 存储库

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

对于更复杂的查询，您可以使用 Spring Data 的Query注解来注解您的方法。

Spring Data 存储库通常从RepositoryorCrudRepository接口扩展而来。如果您使用自动配置，则从包含您的主要配置类（用​​@EnableAutoConfiguration​​或注释的那个​​@SpringBootApplication​​）的包中搜索存储库。

以下示例显示了一个典型的 Spring Data 存储库接口定义：

public interface CityRepository extends Repository<City, Long> {

    Page<City> findAll(Pageable pageable);

    City findByNameAndStateAllIgnoringCase(String name, String state);

}

Spring Data JPA 存储库支持三种不同的引导模式：默认、延迟和惰性。要启用延迟或延迟引导，请将​​spring.data.jpa.repositories.bootstrap-mode​​属性分别设置为​​deferred​​或​​lazy​​。当使用延迟或延迟引导时，自动配置​​EntityManagerFactoryBuilder​​将使用上下文的​​AsyncTaskExecutor​​（如果有的话）作为引导执行程序。如果存在多个，​​applicationTaskExecutor​​将使用命名的那个。

1.3.3. Spring Data Envers 存储库

如果Spring Data Envers可用，JPA 存储库会自动配置为支持典型的 Envers 查询。

要使用 Spring Data Envers，请确保您的存储库扩展自如​​RevisionRepository​​以下示例所示：

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

    Page<Country> findAll(Pageable pageable);

}

1.3.4创建和删除 JPA 数据库

默认情况下，仅当您使用嵌入式数据库（H2、HSQL 或 Derby）时，才会自动创建 JPA 数据库。您可以使用​​spring.jpa.*​​属性显式配置 JPA 设置。例如，要创建和删除表，您可以将以下行添加到您的​​application.properties​​:

特性

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

特性

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

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

默认情况下，DDL 执行（或验证）会延迟到​​ApplicationContext​​启动。还有一个​​spring.jpa.generate-ddl​​标志，但如果 Hibernate 自动配置处于活动状态，则不会使用它，因为​​ddl-auto​​设置更细粒度。

1.3.5在视图中打开 EntityManager

如果您正在运行 Web 应用程序，Spring Boot 默认注册OpenEntityManagerInViewInterceptor以应用“在视图中打开 EntityManager”模式，以允许在 Web 视图中延迟加载。如果你不想要这种行为，你应该​​spring.jpa.open-in-view​​在​​false​​你的​​application.properties​​.

1.4. 弹簧数据 JDBC

Spring Data 包括对 JDBC 的存储库支持，并将自动为​​CrudRepository​​. 对于更高级的查询，​​@Query​​提供了注释。

当必要的依赖项位于类路径上时，Spring Boot 将自动配置 Spring Data 的 JDBC 存储库。它们可以通过对​​spring-boot-starter-data-jdbc​​. 如有必要，您可以通过向应用程序添加​​@EnableJdbcRepositories​​注释或子类来控制 Spring Data JDBC 的配置。​​JdbcConfiguration​​

1.5使用 H2 的 Web 控制台

H2 数据库提供了一个基于浏览器的控制台，Spring Boot 可以为您自动配置。当满足以下条件时，控制台会自动配置：

• 您正在开发一个基于 servlet 的 Web 应用程序。
• ​​com.h2database:h2​​在类路径上。
• 您正在使用Spring Boot 的开发人员工具。

1.5.1。更改 H2 控制台的路径

默认情况下，控制台在​​/h2-console​​. 您可以使用该​​spring.h2.console.path​​属性自定义控制台的路径。

1.5.2. 在安全应用程序中访问 H2 控制台

H2 控制台使用框架，并且仅用于开发，不实施 CSRF 保护措施。如果您的应用程序使用 Spring Security，则需要将其配置为

• 禁用针对控制台请求的 CSRF 保护，
• 将标题设置为X-Frame-Options来自SAMEORIGIN控制台的响应。

有关CSRF和标头X-Frame-Options的更多信息可以在 Spring Security 参考指南中找到。

在简单的设置中，​​SecurityFilterChain​​可以使用如下所示

@Profile("dev")
@Configuration(proxyBeanMethods = false)
public class DevProfileSecurityConfiguration {

    @Bean
    @Order(Ordered.HIGHEST_PRECEDENCE)
    SecurityFilterChain h2ConsoleSecurityFilterChain(HttpSecurity http) throws Exception {
        http.requestMatcher(PathRequest.toH2Console());
        http.authorizeRequests(yourCustomAuthorization());
        http.csrf((csrf) -> csrf.disable());
        http.headers((headers) -> headers.frameOptions().sameOrigin());
        return http.build();
    }


}

1.6. 使用 jOOQ

jOOQ 面向对象查询 ( jOOQ ) 是Data Geekery的一款流行产品，它从您的数据库生成 Java 代码，并允许您通过其流畅的 API 构建类型安全的 SQL 查询。商业版和开源版都可以与 Spring Boot 一起使用。

1.6.1. 代码生成

为了使用 jOOQ 类型安全查询，您需要从数据库模式生成 Java 类。您可以按照jOOQ 用户手册中的说明进行操作。如果您使用​​jooq-codegen-maven​​插件并且还使用​​spring-boot-starter-parent​​“父 POM”，则可以安全地省略插件的​​<version>​​标签。您还可以使用 Spring Boot 定义的版本变量（例如​​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 Boot 将 a 自动配置​​DSLContext​​为 Spring Bean 并将其连接到您的 application ​​DataSource​​。要使用​​DSLContext​​，您可以注入它，如下例所示：

@Component
public class MyBean {

    private final DSLContext create;

    public MyBean(DSLContext dslContext) {
        this.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​​.

1.6.4. 自定义 jOOQ

更高级的定制可以通过定义您自己的​​DefaultConfigurationCustomizer​​bean 来实现，该 bean 在创建​​org.jooq.Configuration​​ ​​@Bean​​. 这优先于自动配置应用的任何内容。

​​org.jooq.Configuration​​ ​​@Bean​​如果您想完全控制 jOOQ 配置，您也可以创建自己的。

1.7. 使用 R2DBC

反应式关系数据库连接 ( R2DBC ) 项目将反应式编程 API 引入关系数据库。R2DBC​​io.r2dbc.spi.Connection​​提供了一种使用非阻塞数据库连接的标准方法。连接是通过使用 a 提供的​​ConnectionFactory​​，类似于 a​​DataSource​​和 jdbc。

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

特性

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

要自定义由 a 创建的连接​​ConnectionFactory​​​，即设置您不希望（或不能）在中央数据库配置中配置的特定参数，您可以使用​​ConnectionFactoryOptionsBuilderCustomizer​​​ ​​@Bean​​a 以下示例显示了如何手动覆盖数据库端口，而其余选项取自应用程序配置：

@Configuration(proxyBeanMethods = false)
public class MyR2dbcConfiguration {

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

}

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

@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 可用时，常规的 JDBC​​DataSource​​自动配置会退出。如果您想保留 JDBC​​DataSource​​自动配置，并且对在反应式应用程序中使用阻塞 JDBC API 的风险感到满意，请在您的应用程序中添加​​@Import(DataSourceAutoConfiguration.class)​​一个​​@Configuration​​类以重新启用它。

1.7.1嵌入式数据库支持

与JDBC 支持类似，Spring Boot 可以自动配置嵌入式数据库以进行响应式使用。您无需提供任何连接 URL。您只需要将构建依赖项包含到要使用的嵌入式数据库中，如以下示例所示：

<dependency>
    <groupId>io.r2dbc</groupId>
    <artifactId>r2dbc-h2</artifactId>
    <scope>runtime</scope>
</dependency>

1.7.2. 使用数据库客户端

bean 是自动配置的​​DatabaseClient​​，您可以​​@Autowire​​直接将其放入您自己的 bean 中，如下例所示：

爪哇

科特林

@Component
public class MyBean {

    private final DatabaseClient databaseClient;

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

    // ...

}

1.7.3. Spring Data R2DBC 存储库

Spring Data R2DBC存储库是您可以定义以访问数据的接口。查询是根据您的方法名称自动创建的。例如，一个​​CityRepository​​接口可能会声明一个​​findAllByState(String state)​​方法来查找给定状态的所有城市。

对于更复杂的查询，您可以使用 Spring Data 的Query注解来注解您的方法。

Spring Data 存储库通常从RepositoryorCrudRepository接口扩展而来。如果您使用自动配置，则从包含您的主要配置类（用​​@EnableAutoConfiguration​​或注释的那个​​@SpringBootApplication​​）的包中搜索存储库。

以下示例显示了一个典型的 Spring Data 存储库接口定义：

public interface CityRepository extends Repository<City, Long> {

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

}

2. 使用 NoSQL 技术

Spring Data 提供了额外的项目来帮助您访问各种 NoSQL 技术，包括：

• MongoDB
• Neo4J
• 弹性搜索
• 雷迪斯
• GemFire或Geode
• 卡桑德拉
• 沙发底座
• LDAP

Spring Boot 为 Redis、MongoDB、Neo4j、Solr、Elasticsearch、Cassandra、Couchbase、LDAP 和 InfluxDB 提供自动配置。此外， Apache Geode 的Spring Boot 提供了 Apache Geode的自动配置。您可以使用其他项目，但您必须自己配置它们。请参阅spring.io/projects/spring-data中的相应参考文档。

2.1雷迪斯

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

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

2.1.1连接到 Redis

您可以像注入任何其他 Spring Bean 一样注入自动配置​​RedisConnectionFactory​​的​​StringRedisTemplate​​、 或 vanilla实例。​​RedisTemplate​​默认情况下，实例尝试连接到位于 的 Redis 服务器​​localhost:6379​​。以下清单显示了此类 bean 的示例：

@Component
public class MyBean {

    private final StringRedisTemplate template;

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

    // ...

}

如果您添加您自己​​@Bean​​​的任何自动配置类型，它会替换默认值（在 的情况下除外​​RedisTemplate​​​，当排除基于 bean 名称，​​redisTemplate​​而不是其类型时）。

默认情况下，如果​​commons-pool2​​在类路径上，池连接工厂会自动配置。

2.2. MongoDB

MongoDB是一个开源 NoSQL 文档数据库，它使用类似 JSON 的模式而不是传统的基于表的关系数据。Spring Boot 为使用 MongoDB 提供了多种便利，包括“Starters”​​spring-boot-starter-data-mongodb​​和​​spring-boot-starter-data-mongodb-reactive​​“Starters”。

2.2.1。连接到 MongoDB 数据库

要访问 MongoDB 数据库，您可以注入一个自动配置的​​org.springframework.data.mongodb.MongoDatabaseFactory​​. 默认情况下，实例尝试连接到位于 的 MongoDB 服务器​​mongodb://localhost/test​​。以下示例显示了如何连接到 MongoDB 数据库：

爪哇

科特林

@Component
public class MyBean {

    private final MongoDatabaseFactory mongo;

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

    // ...

}

如果您已经定义了自己​​MongoClient​​的​​MongoDatabaseFactory​​.

自动配置​​MongoClient​​是使用​​MongoClientSettings​​bean 创建的。如果您定义了自己的​​MongoClientSettings​​，它将不加修改地使用，并且​​spring.data.mongodb​​属性将被忽略。否则 a​​MongoClientSettings​​将被自动配置并​​spring.data.mongodb​​应用属性。无论哪种情况，您都可以声明一个或多个​​MongoClientSettingsBuilderCustomizer​​bean 来微调​​MongoClientSettings​​配置。每个都将按顺序调用，​​MongoClientSettings.Builder​​用于构建​​MongoClientSettings​​.

您可以设置​​spring.data.mongodb.uri​​属性以更改 URL 并配置其他设置，例如副本集，如下例所示：

特性

spring.data.mongodb.uri=mongodb://user:secret@mongo1.example.com: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

2.2.2Mongo模板

Spring Data MongoDB提供了一个MongoTemplate类，其设计与 Spring 的​​JdbcTemplate​​. 与 一样​​JdbcTemplate​​，Spring Boot 会自动配置一个 bean 供您注入模板，如下所示：

@Component
public class MyBean {

    private final MongoTemplate mongoTemplate;

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

    // ...

}

有关完整的详细信息，请参阅MongoOperationsJavadoc。

2.2.3Spring Data MongoDB 存储库

Spring Data 包括对 MongoDB 的存储库支持。与前面讨论的 JPA 存储库一样，基本原则是查询是根据方法名称自动构建的。

事实上，Spring Data JPA 和 Spring Data MongoDB 共享相同的公共基础架构。您可以使用前面的 JPA 示例，假设​​City​​现在是 MongoDB 数据类而不是 JPA ​​@Entity​​，它的工作方式相同，如下例所示：

public interface CityRepository extends Repository<City, Long> {

    Page<City> findAll(Pageable pageable);

    City findByNameAndStateAllIgnoringCase(String name, String state);

}

2.2.4嵌入式 Mongo

Spring Boot 为Embedded Mongo提供自动配置。要在 Spring Boot 应用程序中使用它，请添加依赖项​​de.flapdoodle.embed:de.flapdoodle.embed.mongo​​并设置​​spring.mongodb.embedded.version​​属性以匹配应用程序将在生产中使用的 MongoDB 版本。

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

如果类路径上有 SLF4J，Mongo 生成的输出会自动路由到名为​​org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongo​​.

您可以声明自己的​​IMongodConfig​​bean​​IRuntimeConfig​​来控制 Mongo 实例的配置和日志记录路由。可以通过声明​​DownloadConfigBuilderCustomizer​​bean 来自定义下载配置。

2.3. Neo4j

Neo4j是一个开源的 NoSQL 图数据库，它使用由一级关系连接的节点的丰富数据模型，比传统的 RDBMS 方法更适合连接的大数据。Spring Boot 为使用 Neo4j 提供了多种便利，包括​​spring-boot-starter-data-neo4j​​“Starter”。

2.3.1。连接到 Neo4j 数据库

要访问 Neo4j 服务器，您可以注入一个自动配置的​​org.neo4j.driver.Driver​​. 默认情况下，实例尝试​​localhost:7687​​使用 Bolt 协议连接到 Neo4j 服务器。下面的例子展示了如何注入一个 Neo4j ​​Driver​​，它可以让你访问，除其他外，一个​​Session​​：

@Component
public class MyBean {

    private final Driver driver;

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

    // ...

}

​​spring.neo4j.*​​您可以使用属性配置驱动程序的各个方面。以下示例显示如何配置要使用的 uri 和凭据：

特性

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

自动配置​​Driver​​是使用创建的​​ConfigBuilder​​。要微调其配置，请声明一个或多个​​ConfigBuilderCustomizer​​bean。每个都将按顺序调用，​​ConfigBuilder​​用于构建​​Driver​​.

2.3.2.Spring Data Neo4j 存储库

Spring Data 包括对 Neo4j 的存储库支持。有关 Spring Data Neo4j 的完整详细信息，请参阅参考文档。

与许多其他 Spring Data 模块一样，Spring Data Neo4j 与 Spring Data JPA 共享通用基础架构。您可以使用前面的 JPA 示例并将其定义​​City​​为 Spring Data Neo4j​​@Node​​而不是 JPA ​​@Entity​​，并且存储库抽象以相同的方式工作，如以下示例所示：

public interface CityRepository extends Neo4jRepository<City, Long> {

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

}

“ ​​spring-boot-starter-data-neo4j​​Starter”支持存储库支持以及事务管理。​​Neo4jTemplate​​Spring Boot 使用or ​​ReactiveNeo4jTemplate​​bean支持经典和响应式 Neo4j 存储库。当 Project Reactor 在类路径上可用时，响应式样式也会自动配置。

您可以通过分别在-bean上使用​​@EnableNeo4jRepositories​​和来自定义查找存储库和实体的位置。​​@EntityScan​​​​@Configuration​​

2.4. 索尔

​​Apache Solr​​是一个搜索引擎。Spring Boot 为 Solr 5 客户端库提供了基本的自动配置。

2.4.1连接到 Solr

​​SolrClient​​您可以像注入任何其他 Spring bean 一样注入自动配置的实例。默认情况下，实例尝试连接到位于 的服务器​​localhost:8983/solr​​。以下示例显示了如何注入 Solr bean：

@Component
public class MyBean {

    private final SolrClient solr;

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

    // ...

}

如果您添加自己​​@Bean​​的 type ​​SolrClient​​，它将替换默认值。

2.5. 弹性搜索

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

Spring Boot 支持多个客户端：

• 官方 Java“低级”和“高级”REST 客户端
• 由ReactiveElasticsearchClientSpring Data Elasticsearch 提供

Spring Boot 提供了一个专用的“Starter” ​​spring-boot-starter-data-elasticsearch​​，.

2.5.1使用 REST 客户端连接到 Elasticsearch

Elasticsearch 提供了两种不同的 REST 客户端，您可以使用它们来查询集群：模块中的低级客户端​​org.elasticsearch.client:elasticsearch-rest-client​​​和模块中的高级客户端​​org.elasticsearch.client:elasticsearch-high-level-client​​​。​​WebClient​​​此外，Spring Boot从模块中提供了对基于 Spring Framework 的响应式客户端的支持​​org.springframework.data:spring-data-elasticsearch​​​。默认情况下，客户端将以​​localhost:9200​​​. 您可以使用​​spring.elasticsearch.*​​属性进一步调整客户端的配置方式，如下例所示：

特性

yaml

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

使用 RestClient 连接到 Elasticsearch

如果你​​elasticsearch-rest-client​​在类路径上，Spring Boot 将自动配置并注册一个​​RestClient​​bean。如果你​​elasticsearch-rest-high-level-client​​在类路径上有一个​​RestHighLevelClient​​bean 也将被自动配置。在 Elasticsearch 弃用 后​​RestHighLevelClient​​，它的自动配置将被弃用，并将在未来的版本中删除。除了前面描述的属性之外，为了微调​​RestClient​​and ​​RestHighLevelClient​​，您可以注册任意数量的 bean 来实现​​RestClientBuilderCustomizer​​更高级的自定义。要完全控制客户端的配置，请定义一个​​RestClientBuilder​​bean。

此外，如果​​elasticsearch-rest-client-sniffer​​在类路径上，a​​Sniffer​​会自动配置为从正在运行的 Elasticsearch 集群中自动发现节点并将它们设置在​​RestClient​​bean 上。您可以进一步调整​​Sniffer​​配置方式，如以下示例所示：

特性

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

使用 ReactiveElasticsearchClient 连接到 Elasticsearch

Spring Data Elasticsearch用于​​ReactiveElasticsearchClient​​以反应方式查询 Elasticsearch 实例。它建立在 WebFlux 之上​​WebClient​​，因此两者​​spring-boot-starter-elasticsearch​​和​​spring-boot-starter-webflux​​依赖项对于启用此支持都很有用。

默认情况下，Spring Boot 会自动配置并注册一个​​ReactiveElasticsearchClient​​. 除了前面描述的属性之外，这些​​spring.elasticsearch.webclient.*​​属性还可用于配置响应式特定设置，如以下示例所示：

特性

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

如果和配置属性还不够，并且您想完全控制客户端配置，您可以注册一个自定义bean。​​spring.elasticsearch.​​​​​spring.elasticsearch.webclient.​​​​ClientConfiguration​​

2.5.2. 使用 Spring Data 连接 Elasticsearch

要连接到 Elasticsearch，​​RestHighLevelClient​​必须定义一个 bean，由 Spring Boot 自动配置或由应用程序手动提供（参见前面的部分）。有了这个配置， ​​ElasticsearchRestTemplate​​就可以像任何其他 Spring bean 一样注入 an，如下例所示：

@Component
public class MyBean {

    private final ElasticsearchRestTemplate template;

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

    // ...

}

在存在和使用 a (通常是)​​spring-data-elasticsearch​​所需的依赖项的情况下，Spring Boot 还可以自动配置ReactiveElasticsearchClient和 a as beans。它们是其他 REST 客户端的反应式等价物。​​WebClient​​​​spring-boot-starter-webflux​​​​ReactiveElasticsearchTemplate​​

2.5.3. Spring Data Elasticsearch 存储库

Spring Data 包括对 Elasticsearch 的存储库支持。与前面讨论的 JPA 存储库一样，基本原则是根据方法名称自动为您构建查询。

事实上，Spring Data JPA 和 Spring Data Elasticsearch 共享相同的公共基础架构。您可以使用前面的 JPA 示例，假设​​City​​​现在是 Elasticsearch​​@Document​​​类而不是 JPA ​​@Entity​​，它的工作方式相同。

​​ElasticsearchRestTemplate​​​Spring Boot 使用or ​​ReactiveElasticsearchTemplate​​bean支持经典和响应式 Elasticsearch 存储库。鉴于存在所需的依赖项，这些 bean 很可能是由 Spring Boot 自动配置的。

如果您希望使用自己的模板来支持 Elasticsearch 存储库，您可以添加自己的​​ElasticsearchRestTemplate​​或​​ElasticsearchOperations​​ ​​@Bean​​，只要它被命名为​​"elasticsearchTemplate"​​。同样适用于​​ReactiveElasticsearchTemplate​​and ​​ReactiveElasticsearchOperations​​，带有 bean name ​​"reactiveElasticsearchTemplate"​​。

您可以选择使用以下属性禁用存储库支持：

特性

spring.data.elasticsearch.repositories.enabled=false

2.6. 卡桑德拉

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

2.6.1连接到 Cassandra

您可以像使用任何其他 Spring Bean 一样注入自动配置​​CassandraTemplate​​或 Cassandra实例。​​CqlSession​​这些​​spring.data.cassandra.*​​属性可用于自定义连接。通常，您提供本地数据中心名称​​keyspace-name​​以及​​contact-points​​本地数据中心名称，如以下示例所示：

特性

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

如果所有联系点的端口都相同，则可以使用快捷方式并仅指定主机名，如以下示例所示：

特性

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

以下代码清单显示了如何注入 Cassandra bean：

@Component
public class MyBean {

    private final CassandraTemplate template;

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

    // ...

}

如果您添加自己​​@Bean​​的 type ​​CassandraTemplate​​，它将替换默认值。

2.6.2. Spring Data Cassandra 存储库

Spring Data 包括对 Cassandra 的基本存储库支持。目前，这比前面讨论的 JPA 存储库更受限制，需要使用​​@Query​​.

2.7. 沙发底座

Couchbase是一个开源、分布式、多模型 NoSQL 面向文档的数据库，针对交互式应用程序进行了优化。Spring Boot 为 Couchbase 和Spring Data Couchbase提供的抽象提供了自动配置。有“启动​​spring-boot-starter-data-couchbase​​器​​spring-boot-starter-data-couchbase-reactive​​”可以方便地收集依赖项。

2.7.1。连接到沙发底座

您可以​​Cluster​​通过添加 Couchbase SDK 和一些配置来获得。这些​​spring.couchbase.*​​属性可用于自定义连接。通常，您提供连接字符串、用户名和密码，如下例所示：

特性

spring.couchbase.connection-string=couchbase://192.168.1.123
spring.couchbase.username=user
spring.couchbase.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

2.7.2. Spring Data Couchbase 存储库

Spring Data 包括对 Couchbase 的存储库支持。有关 Spring Data Couchbase 的完整详细信息，请参阅参考文档。

​​CouchbaseTemplate​​您可以像使用任何其他 Spring Bean 一样注入自动配置的实例，前提是​​CouchbaseClientFactory​​bean 可用。​​Cluster​​如上所述，当 a可用并且已指定存储桶名称时，就会发生这种情况：

特性

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

以下示例显示了如何注入​​CouchbaseTemplate​​bean：

@Component
public class MyBean {

    private final CouchbaseTemplate template;

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

    // ...

}

There are a few beans that you can define in your own configuration to override those provided by the auto-configuration:

• A CouchbaseMappingContext @Bean with a name of couchbaseMappingContext.
• A CustomConversions @Bean with a name of couchbaseCustomConversions.
• A CouchbaseTemplate @Bean with a name of couchbaseTemplate.

To avoid hard-coding those names in your own config, you can reuse ​​BeanNames​​ provided by Spring Data Couchbase. For instance, you can customize the converters to use, as follows:

@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（轻量级目录访问协议）是一种开放的、供应商中立的、行业标准的应用协议，用于通过 IP 网络访问和维护分布式目录信息服务。Spring Boot 为任何兼容的 LDAP 服务器提供自动配置，并支持来自UnboundID的嵌入式内存中 LDAP 服务器。

LDAP 抽象由Spring Data LDAP提供。有一个​​spring-boot-starter-data-ldap​​“启动器”可以方便地收集依赖项。

2.8.1. 连接到 LDAP 服务器

要连接到 LDAP 服务器，请确保声明对​​spring-boot-starter-data-ldap​​“Starter”的依赖关系，或者​​spring-ldap-core​​然后在 application.properties 中声明服务器的 URL，如下例所示：

特性

yaml

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

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

An​​LdapContextSource​​是根据这些设置自动配置的。如果​​DirContextAuthenticationStrategy​​bean 可用，则它与 auto-configured 相关联​​LdapContextSource​​。如果您需要自定义它，例如使用 a ​​PooledContextSource​​，您仍然可以注入 auto-configured ​​LdapContextSource​​。确保将您的自定义标记​​ContextSource​​为​​@Primary​​以便自动配置​​LdapTemplate​​使用它。

2.8.2. Spring Data LDAP 存储库

Spring Data 包括对 LDAP 的存储库支持。有关 Spring Data LDAP 的完整详细信息，请参阅参考文档。

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

@Component
public class MyBean {

    private final LdapTemplate template;

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

    // ...

}

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

出于测试目的，Spring Boot 支持从UnboundID自动配置内存中的 LDAP 服务器。要配置服务器，请添加一个依赖项​​com.unboundid:unboundid-ldapsdk​​并声明一个​​spring.ldap.embedded.base-dn​​属性，如下所示：

特性

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

默认情况下，服务器在随机端口上启动并触发常规 LDAP 支持。无需指定​​spring.ldap.urls​​属性。

如果你的类路径上有一个​​schema.ldif​​文件，它用于初始化服务器。如果要从其他资源加载初始化脚本，也可以使用该​​spring.ldap.embedded.ldif​​属性。

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

2.9涌入数据库

InfluxDB是一个开源时间序列数据库，针对运营监控、应用程序指标、物联网传感器数据和实时分析等领域的时间序列数据的快速、高可用性存储和检索进行了优化。

2.9.1连接到 InfluxDB

Spring Boot 会自动配置一个​​InfluxDB​​实例，前提是​​influxdb-java​​客户端位于类路径中并且设置了数据库的 URL，如下例所示：

特性

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

如果与 InfluxDB 的连接需要用户和密码，您可以相应地设置​​spring.influx.user​​和​​spring.influx.password​​属性。

InfluxDB 依赖于 OkHttp。如果您需要在​​InfluxDB​​后台调整 http 客户端的使用，您可以注册一个​​InfluxDbOkHttpClientBuilderProvider​​bean。

如果您需要对配置进行更多控制，请考虑注册一个​​InfluxDbCustomizer​​bean。

3.接下来要读什么

您现在应该对如何将 Spring Boot 与各种数据技术一起使用有所了解。从这里，您可以了解 Spring Boot 对各种消息传递技术的支持以及如何在您的应用程序中启用它们。