# 数据
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 启动使用以下算法来选择具体的实现方式:
我们更喜欢Hikaricp (opens new window)的性能和并发性。如果有 Hikaricp,我们总是选择它。
否则,如果 Tomcat 池
DataSource
可用,则使用它。否则,如果Commons DBCP2 (opens new window)是可用的,我们就使用它。
如果 HIKARICP、 Tomcat 和 DBCP2 都不可用,并且如果 Oracle UCP 可用,我们就使用它。
如果使用spring-boot-starter-jdbc 或spring-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
h2
JdbcDataSource
PostgreSQL
PGSimpleDataSource
# 1.1.5.连接到 JNDI 数据源
如果你将 Spring 引导应用程序部署到应用程序服务器,那么你可能希望通过使用应用程序服务器的内置功能来配置和管理你的数据源,并通过使用 JNDI 访问它。
spring.datasource.jndi-name
属性可以用作spring.datasource.url
、spring.datasource.username
和spring.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 的JdbcTemplate
和NamedParameterJdbcTemplate
类是自动配置的,并且你可以将它们@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 支持。
# 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
属性分别设置为deferred
或lazy
。当使用延迟或延迟引导时,自动配置的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 引导可以为你自动配置。当满足以下条件时,控制台将自动配置:
你正在开发一个基于 Servlet 的 Web 应用程序。
com.h2database:h2
在 Classpath 上。
如果你不使用 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 中指定的信息优先于单个属性,即 name 、username 、password 和池选项。 |
---|
“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 一样,注入一个自动配置的RedisConnectionFactory
、StringRedisTemplate
或 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-mongodb
和spring-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
属性应用到它。在这两种情况下,都可以声明一个或多个MongoClientSettingsBuilderCustomizer
bean 来微调MongoClientSettings
配置。将按顺序调用每个函数,并使用用于构建MongoClientSettings
的MongoClientSettings.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");
}
}
有关完整的详细信息,请参见[MongoOperations
Javadoc](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
的记录器。
你可以声明自己的IMongodConfig
和IRuntimeConfig
bean 来控制 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
创建的。要微调其配置,请声明一个或多个ConfigBuilderCustomizer
bean。每个都将按顺序调用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 使用Neo4jTemplate
或ReactiveNeo4jTemplate
bean,启动同时支持经典的和反应的 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-elasticsearch
和spring-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 使用ElasticsearchRestTemplate
或ReactiveElasticsearchTemplate
bean,支持经典的和反应的 Elasticsearch 存储库。考虑到存在所需的依赖关系,这些 bean 很可能是通过 Spring 引导自动配置的。
如果你希望使用自己的模板来支持 ElasticSearch 存储库,则可以添加自己的ElasticsearchRestTemplate
或ElasticsearchOperations``@Bean
,只要它的名称为"elasticsearchTemplate"
。这同样适用于ReactiveElasticsearchTemplate
和ReactiveElasticsearchOperations
,其 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-name
和contact-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 创建多个CqlSession bean,请记住构建器是可变的,因此请确保为每个会话注入一个新的副本。 |
---|
下面的代码清单展示了如何注入 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-couchbase
和spring-boot-starter-data-couchbase-reactive
“启动器”,可以方便地收集依赖项。
# 2.7.1.连接到 Couchbase
你可以通过添加 CouchBase SDK 和一些配置来获得Cluster
。spring.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.* 属性以获得更多详细信息。要获得更多控制权,可以使用一个或多个 ClusterEnvironmentBuilderCustomizer bean。 |
---|
# 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:
a
CouchbaseMappingContext``@Bean
,其名称为couchbaseMappingContext
。a
CustomConversions``@Bean
,其名称为couchbaseCustomConversions
。a
CouchbaseTemplate``@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.base
和spring.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.user
和spring.influx.password
属性。
InfluxDB 依赖于 OkHTTP。如果你需要调优幕后使用的 HTTP 客户端InfluxDB
,则可以注册一个InfluxDbOkHttpClientBuilderProvider
Bean。
如果需要对配置进行更多控制,可以考虑注册InfluxDbCustomizer
Bean。
# 3. 接下来要读什么?
你现在应该对如何在各种数据技术中使用 Spring 引导有了一种感觉。从这里,你可以了解 Spring boot 对各种消息传递技术的支持,以及如何在应用程序中启用它们。