Spec-Zone.ru › Spring Boot

Данные

Spring Boot интегрируется с рядом технологий работы с данными, как SQL, так и NoSQL.

1. Базы данных SQL

Фреймворк Spring Framework предоставляет обширную поддержку работы с базами данных SQL, от прямого доступа к JDBC с использованием JdbcTemplate до полных технологий «объектно-реляционного отображения», таких как Hibernate. Spring Data добавляет дополнительный функционал: создание Repository-имплементаций напрямую из интерфейсов и использование соглашений для генерации запросов из имён ваших методов.

1.1. Настройка DataSource

Интерфейс javax.sql.DataSource Java предоставляет стандартный метод работы с подключениями к базам данных. Традиционно, DataSource использует URL вместе с некоторыми учетными данными для установления подключения к базе данных.

Смотрите раздел «Как это сделать» для более продвинутых примеров, обычно для полного контроля над настройкой DataSource.

1.1.1. Поддержка встроенных баз данных

Часто удобно разрабатывать приложения, используя встроенные базы данных в памяти. Очевидно, что базы данных в памяти не обеспечивают постоянного хранения. Вам необходимо заполнить свою базу данных при запуске приложения и быть готовыми удалить данные при завершении работы приложения.

В разделе «Как это сделать» есть раздел о том, как инициализировать базу данных.

Spring Boot может автоматически настраивать встроенные базы данных H2, HSQL и Derby. Вам не нужно указывать какие-либо URL-адреса подключения. Вам нужно лишь включить зависимость от используемой вами встроенной базы данных. Если на пути к классу находятся несколько встроенных баз данных, установите свойство конфигурации 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 не используется. Отключение автоматического закрытия базы данных позволяет Spring Boot контролировать, когда база данных будет закрыта, тем самым гарантируя, что это произойдёт, когда доступ к базе данных больше не требуется.

1.1.2. Подключение к базе данных в режиме работы

Подключения к базам данных в режиме работы также могут быть автоматически настроены с использованием пулинга DataSource.

1.1.3. Конфигурация DataSource

Конфигурация DataSource контролируется внешними свойствами конфигурации в 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"
Вам по меньшей мере необходимо указать URL, установив свойство spring.datasource.url. В противном случае Spring Boot попытается настроить встроенную базу данных.
Spring Boot может вывести класс JDBC-драйвера для большинства баз данных из URL. Если вам нужно указать конкретный класс, вы можете использовать свойство spring.datasource.driver-class-name.
Для создания пулинга DataSource нам необходимо убедиться, что доступен действительный класс Driver, поэтому мы проверяем это перед выполнением каких-либо действий. Другими словами, если вы устанавливаете spring.datasource.driver-class-name=com.mysql.jdbc.Driver, то этот класс должен быть загружаемым.

См. 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
Yaml
spring:
  datasource:
    tomcat:
      max-wait: 10000
      max-active: 50
      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-boot-starter-jdbc или spring-boot-starter-data-jpa «стартеры», вы автоматически получаете зависимость от HikariCP.

Вы можете полностью обойти этот алгоритм и указать используемый пул подключений, установив свойство spring.datasource.type. Это особенно важно, если вы запускаете своё приложение в контейнере Tomcat, так как tomcat-jdbc предоставляется по умолчанию.

Дополнительные пулы подключений всегда можно настраивать вручную, используя DataSourceBuilder. Если вы определите собственный бин DataSource, автоматическая настройка не происходит. Следующие пулы подключений поддерживаются DataSourceBuilder:

  • HikariCP

  • Tomcat пул подключений Datasource

  • Commons DBCP2

  • Oracle UCP и OracleDataSource

  • Пул подключений SimpleDriverDataSource Spring Framework

  • H2 JdbcDataSource

  • PostgreSQL PGSimpleDataSource

  • C3P0

1.1.5. Подключение к DataSource JNDI

Если вы развертываете своё приложение Spring Boot на сервере приложений, вы можете настроить и управлять вашим DataSource, используя встроенные функции сервера приложений и получать доступ к нему с помощью JNDI.

Свойство spring.datasource.jndi-name может быть использовано как альтернатива свойствам spring.datasource.url, spring.datasource.username, и spring.datasource.password для доступа к DataSource из конкретного расположения JNDI. Например, следующий раздел в application.properties показывает, как можно получить доступ к определённому DataSource JBoss AS:

Свойства
spring.datasource.jndi-name=java:jboss/datasources/customers
Yaml
spring:
  datasource:
    jndi-name: "java:jboss/datasources/customers"

1.2. Использование JdbcTemplate

Классы JdbcTemplate и NamedParameterJdbcTemplate Spring автоматически настраиваются, и вы можете @Autowire их напрямую в свои собственные бин-объекты, как показано в следующем примере:

Java
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 ...
    }

}
Kotlin
import org.springframework.jdbc.core.JdbcTemplate
import org.springframework.stereotype.Component

@Component
class MyBean(private val jdbcTemplate: JdbcTemplate) {

    fun doSomething() {
        jdbcTemplate.execute("delete from customer")
    }

}

Вы можете настроить некоторые свойства шаблона, используя свойства spring.jdbc.template.*, как показано в следующем примере:

Свойства
spring.jdbc.template.max-rows=500
Yaml
spring:
  jdbc:
    template:
      max-rows: 500
NamedParameterJdbcTemplate использует тот же экземпляр JdbcTemplate за кулисами. Если определено более одного JdbcTemplate, и нет первичного кандидата, NamedParameterJdbcTemplate не настраивается автоматически.

1.3. JPA и Spring Data JPA

API Java Persistence – это стандартная технология, позволяющая «сопоставлять» объекты с реляционными базами данных. spring-boot-starter-data-jpa POM предоставляет быстрый способ начать работу. Он предоставляет следующие ключевые зависимости:

  • Hibernate: Одна из самых популярных реализаций JPA.

  • Spring Data JPA: Помогает реализовывать репозитории на основе JPA.

  • Spring ORM: Основная поддержка ORM из Spring Framework.

Мы не углубляемся в подробности JPA или Spring Data здесь. Вы можете следовать руководству “Доступ к данным с помощью JPA” с сайта spring.io и прочитать документацию по Spring Data JPA и Hibernate.

1.3.1. Классы сущностей

Традиционно, классы сущностей JPA определяются в файле persistence.xml. В Spring Boot этот файл не нужен, и вместо этого используется «сканирование сущностей». По умолчанию ищутся все пакеты ниже основного конфигурационного класса (того, который аннотирован как @EnableAutoConfiguration или @SpringBootApplication).

Любые классы, аннотированные @Entity, @Embeddable, или @MappedSuperclass, рассматриваются. Типичный класс сущности напоминает следующий пример:

Java
import java.io.Serializable;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.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

}
Kotlin
import jakarta.persistence.Column
import jakarta.persistence.Entity
import jakarta.persistence.GeneratedValue
import jakarta.persistence.Id
import java.io.Serializable

@Entity
class City : Serializable {

    @Id
    @GeneratedValue
    private val id: Long? = null

    @Column(nullable = false)
    var name: String? = null
        private set

    // ... etc
    @Column(nullable = false)
    var state: String? = null
        private set

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

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

    constructor(name: String?, state: String?) {
        this.name = name
        this.state = state
    }

}
Вы можете настроить расположение сканирования сущностей, используя аннотацию @EntityScan. См. руководство «howto.html”.

1.3.2. Репозитории Spring Data JPA

Spring Data JPA репозитории – это интерфейсы, которые вы можете определить для доступа к данным. JPA запросы создаются автоматически из ваших имён методов. Например, интерфейс CityRepository может объявить метод findAllByState(String state) для поиска всех городов в данном штате.

Для более сложных запросов вы можете аннотировать свой метод аннотацией Spring Data Query.

Репозитории Spring Data обычно наследуются от интерфейсов Repository или CrudRepository. Если вы используете автоматическую настройку, репозитории ищутся от пакета, содержащего ваш главный конфигурационный класс (аннотированный как @EnableAutoConfiguration или @SpringBootApplication) вниз.

Вы можете настроить расположения поиска репозиториев, используя @EnableJpaRepositories.

Следующий пример показывает типичное определение интерфейса репозитория Spring Data:

Java
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);

}
Kotlin
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

interface CityRepository : Repository<City?, Long?> {

    fun findAll(pageable: Pageable?): Page<City?>?

    fun findByNameAndStateAllIgnoringCase(name: String?, state: String?): City?

}

Репозитории Spring Data JPA поддерживают три различных режима запуска: по умолчанию, отложенный и ленивый. Чтобы включить отложенный или ленивый запуск, установите свойство spring.data.jpa.repositories.bootstrap-mode соответственно в deferred или lazy. При использовании отложенного или ленивого запуска настроенный автоматически EntityManagerFactoryBuilder будет использовать AsyncTaskExecutor контекста, если таковой имеется, в качестве исполнителя запуска. Если таких существует несколько, будет использован тот, что имеет имя applicationTaskExecutor.

При использовании отложенного или ленивого запуска, убедитесь, что вы откладываете любой доступ к инфраструктуре JPA после фазы запуска контекста приложения. Вы можете использовать SmartInitializingSingleton для вызова любой инициализации, требующей инфраструктуры JPA. Для компонентов JPA (таких как преобразователи), которые создаются как бин-объекты Spring, используйте ObjectProvider для отсрочки разрешения зависимостей, если таковые имеются.
Мы лишь немного коснулись Spring Data JPA. Для полной информации смотрите справочную документацию Spring Data JPA.

1.3.3. Репозитории Spring Data Envers

Если Spring Data Envers доступен, JPA репозитории настраиваются автоматически для поддержки типичных запросов Envers.

Для использования Spring Data Envers, убедитесь, что ваш репозиторий наследуется от RevisionRepository, как показано в следующем примере:

Java
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);

}
Kotlin
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

interface CountryRepository :
        RevisionRepository<Country?, Long?, Int>,
        Repository<Country?, Long?> {

    fun findAll(pageable: Pageable?): Page<Country?>?

}
Для получения дополнительной информации, ознакомьтесь со справочной документацией Spring Data Envers.

1.3.4. Создание и удаление баз данных JPA

По умолчанию базы данных JPA автоматически создаются только если вы используете встроенную базу данных (H2, HSQL или Derby). Вы можете явно настроить параметры JPA, используя свойства spring.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.* (префикс удаляется перед добавлением их в менеджер сущностей). Следующая строка показывает пример настройки свойств JPA для Hibernate:
Свойства
spring.jpa.properties.hibernate[globally_quoted_identifiers]=true
Yaml
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. Открытый менеджер сущностей в представлении

Если вы запускаете веб-приложение, Spring Boot по умолчанию регистрирует OpenEntityManagerInViewInterceptor для применения паттерна «Открытый менеджер сущностей в представлении», чтобы разрешить ленивую загрузку в веб-представлениях. Если вы не хотите этого поведения, вы должны установить spring.jpa.open-in-view в значение false в вашем application.properties.

1.4. Spring Data JDBC

Spring Data включает поддержку репозиториев для JDBC и автоматически сгенерирует SQL для методов в CrudRepository. Для более сложных запросов предоставляется аннотация @Query.

Spring Boot автоматически настраивает репозитории Spring Data JDBC, когда необходимые зависимости находятся в пути к классам. Их можно добавить в ваш проект с помощью одной зависимости от spring-boot-starter-data-jdbc. При необходимости вы можете взять под контроль конфигурацию Spring Data JDBC, добавив аннотацию @EnableJdbcRepositories или подкласс AbstractJdbcConfiguration в ваше приложение.

Для получения полной информации о Spring Data JDBC, обратитесь к документации.

1.5. Использование веб-консоли H2

База данных H2 предоставляет консоль в браузере, которую Spring Boot может автоматически настроить для вас. Консоль настраивается автоматически, когда выполняются следующие условия:

  • Вы разрабатываете веб-приложение на основе сервлетов.

  • com.h2database:h2 находится в пути к классам.

  • Вы используете инструменты разработчика Spring Boot.

Если вы не используете инструменты разработчика 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.5.2. Доступ к консоли H2 в защищённом приложении

Консоль H2 использует фреймы и, поскольку она предназначена только для разработки, не реализует мер защиты от CSRF. Если ваше приложение использует Spring Security, вам необходимо настроить его следующим образом:

  • отключить защиту CSRF для запросов к консоли,

  • установить заголовок X-Frame-Options со значением SAMEORIGIN в ответах из консоли.

Дополнительную информацию о CSRF и заголовке X-Frame-Options можно найти в справочном руководстве Spring Security.

В простых настройках можно использовать SecurityFilterChain , например:

Java
import org.springframework.boot.autoconfigure.security.servlet.PathRequest;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.SecurityFilterChain;

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

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


}
Kotlin
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.Profile
import org.springframework.core.Ordered
import org.springframework.core.annotation.Order
import org.springframework.security.config.Customizer
import org.springframework.security.config.annotation.web.builders.HttpSecurity
import org.springframework.security.web.SecurityFilterChain

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

    @Bean
    @Order(Ordered.HIGHEST_PRECEDENCE)
    fun h2ConsoleSecurityFilterChain(http: HttpSecurity): SecurityFilterChain {
        return http.authorizeHttpRequests(yourCustomAuthorization())
            .csrf { csrf -> csrf.disable() }
            .headers { headers -> headers.frameOptions { frameOptions -> frameOptions.sameOrigin() } }
            .build()
    }


}
Консоль H2 предназначена только для использования во время разработки. В продакшене отключение защиты CSRF или разрешение фреймов для веб-сайта может создать серьезные риски безопасности.
PathRequest.toH2Console() возвращает правильный обработчик запросов также в случае изменения пути к консоли.

1.6. Использование jOOQ

jOOQ Object Oriented Querying (jOOQ) — популярный продукт от Data Geekery, который генерирует Java-код из вашей базы данных и позволяет строить безопасные SQL-запросы с помощью своего fluent API. Как коммерческие, так и open source версии могут использоваться с 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

Fluent API, предлагаемый jOOQ, инициируется через интерфейс org.jooq.DSLContext. Spring Boot автоматически настраивает DSLContext как Spring Bean и подключает его к вашему приложению DataSource. Для использования DSLContext, вы можете его инжектировать, как показано в следующем примере:

Java
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;
    }


}
Kotlin
import org.jooq.DSLContext
import org.springframework.stereotype.Component
import java.util.GregorianCalendar

@Component
class MyBean(private val create: DSLContext) {


}
Руководство jOOQ обычно использует переменную, названную create, для хранения DSLContext.

Затем вы можете использовать DSLContext для построения своих запросов, как показано в следующем примере:

Java
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);
Kotlin
fun authorsBornAfter1980(): List<GregorianCalendar> {
    return create.selectFrom<Tables.TAuthorRecord>(Tables.AUTHOR)
        .where(Tables.AUTHOR?.DATE_OF_BIRTH?.greaterThan(GregorianCalendar(1980, 0, 1)))
        .fetch(Tables.AUTHOR?.DATE_OF_BIRTH)
}

1.6.3. Диалект SQL jOOQ

Если свойство spring.jooq.sql-dialect не настроено, Spring Boot определяет диалект SQL для использования с вашим источником данных. Если Spring Boot не смог определить диалект, он использует DEFAULT.

Spring Boot может настроить только диалекты, поддерживаемые open source версией jOOQ.

1.6.4. Настройка jOOQ

Более сложные настройки могут быть достигнуты путём определения собственного бин DefaultConfigurationCustomizer bean, который будет вызван перед созданием org.jooq.Configuration @Bean. Это имеет приоритет над любыми настройками, примененными автоконфигурацией.

Вы также можете создать собственный org.jooq.Configuration @Bean если хотите полностью контролировать конфигурацию jOOQ.

1.7. Использование R2DBC

Проект Реактивная подключенность к реляционным базам данных (R2DBC) предоставляет API для реактивного программирования с реляционными базами данных. R2DBC’s io.r2dbc.spi.Connection предоставляет стандартный метод работы с неблокирующими подключениями к базе данных. Подключения предоставляются с помощью ConnectionFactory, аналогично DataSource с jdbc.

Конфигурация 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 получает драйвер из механизма обнаружения Connection Factory R2DBC.
По крайней мере, должен быть указан URL. Информация, указанная в URL, имеет приоритет над отдельными свойствами, то есть name, username, password и параметрами пулинга.
Раздел «Как это сделать» содержит раздел о том, как инициализировать базу данных как инициализировать базу данных.

Для настройки подключений, созданных ConnectionFactory, то есть установки специфических параметров, которые вы не хотите (или не можете) настроить в вашей централизованной конфигурации базы данных, вы можете использовать ConnectionFactoryOptionsBuilderCustomizer @Bean. Следующий пример демонстрирует, как вручную переопределить порт базы данных, при этом остальные параметры берутся из конфигурации приложения:

Java
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);
    }

}
Kotlin
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)
class MyR2dbcConfiguration {

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

}

В следующих примерах показано, как настроить некоторые параметры подключения к PostgreSQL:

Java
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);
    }

}
Kotlin
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)
class MyPostgresR2dbcConfiguration {

    @Bean
    fun postgresCustomizer(): ConnectionFactoryOptionsBuilderCustomizer {
        val options: MutableMap<String, String> = HashMap()
        options["lock_timeout"] = "30s"
        options["statement_timeout"] = "60s"
        return ConnectionFactoryOptionsBuilderCustomizer { builder ->
            builder.option(PostgresqlConnectionFactoryProvider.OPTIONS, options)
        }
    }

}

Когда bean ConnectionFactory доступен, обычная автоконфигурация JDBC DataSource отключается. Если вы хотите сохранить автоконфигурацию JDBC DataSource и готовы к риску использования блокирующего API JDBC в реактивном приложении, добавьте @Import(DataSourceAutoConfiguration.class) на класс @Configuration в вашем приложении, чтобы снова включить её.

1.7.1. Поддержка встроенной базы данных

Аналогично поддержке JDBC, Spring Boot может автоматически настроить встроенную базу данных для реактивного использования. Вам не нужно предоставлять какие-либо URL-адреса подключений. Вам нужно только включить зависимость от встроенной базы данных, которую вы хотите использовать, как показано в следующем примере:

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

Если вы используете эту функцию в своих тестах, вы можете заметить, что одна и та же база данных используется всем набором тестов независимо от количества контекстов приложения, которые вы используете. Если вы хотите убедиться, что каждый контекст имеет отдельную встроенную базу данных, вы должны установить spring.r2dbc.generate-unique-name на true.

1.7.2. Использование DatabaseClient

Bean DatabaseClient автоматически настраивается, и вы можете @Autowire его непосредственно в свои собственные компоненты, как показано в следующем примере:

Java
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();
    }

}
Kotlin
import org.springframework.r2dbc.core.DatabaseClient
import org.springframework.stereotype.Component
import reactor.core.publisher.Flux

@Component
class MyBean(private val databaseClient: DatabaseClient) {

    // ...

    fun someMethod(): Flux<Map<String, Any>> {
        return databaseClient.sql("select * from user").fetch().all()
    }

}

1.7.3. Репозитории Spring Data R2DBC

Spring Data R2DBC репозитории — это интерфейсы, которые вы можете определить для доступа к данным. Запросы создаются автоматически из имен ваших методов. Например, интерфейс CityRepository может объявить метод findAllByState(String state) для поиска всех городов в данном штате.

Для более сложных запросов вы можете добавить аннотацию Spring Data Query.

Репозитории Spring Data обычно наследуются от интерфейсов Repository или CrudRepository. Если вы используете автоматическую настройку, репозитории ищутся от пакета, содержащего ваш основной конфигурационный класс (который помечен аннотациями @EnableAutoConfiguration или @SpringBootApplication).

Следующий пример демонстрирует типичное определение интерфейса репозитория Spring Data:

Java
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);

}
Kotlin
import org.springframework.data.repository.Repository
import reactor.core.publisher.Mono

interface CityRepository : Repository<City?, Long?> {

    fun findByNameAndStateAllIgnoringCase(name: String?, state: String?): Mono<City?>?

}
Мы лишь поверхностно коснулись Spring Data R2DBC. Для получения полной информации обратитесь к документации Spring Data R2DBC.

2. Работа с технологиями NoSQL

Spring Data предоставляет дополнительные проекты, которые помогут вам получить доступ к различным технологиям NoSQL, включая:

  • Cassandra

  • Couchbase

  • Elasticsearch

  • GemFire или Geode

  • LDAP

  • MongoDB

  • Neo4J

  • Redis

Из них Spring Boot предоставляет автоматическую настройку для Cassandra, Couchbase, Elasticsearch, LDAP, MongoDB и Neo4J. Кроме того, Spring Boot для Apache Geode предоставляет автоматическую настройку для Apache Geode. Вы можете использовать другие проекты, но должны настроить их самостоятельно. Обратитесь к соответствующей справочной документации по адресу spring.io/projects/spring-data.

Spring Boot также предоставляет автоматическую настройку для клиента InfluxDB.

2.1. Redis

Redis — это кэш, брокер сообщений и функционально богатый хранилище данных типа ключ-значение. Spring Boot предлагает базовые автоматическую настройку для библиотек клиентов Lettuce и Jedis, а также абстракций над ними, предоставляемых Spring Data Redis.

Существует spring-boot-starter-data-redis «Стартер» для удобного сбора зависимостей. По умолчанию он использует Lettuce. Этот стартер обрабатывает как традиционные, так и реактивные приложения.

Мы также предоставляем spring-boot-starter-data-redis-reactive «Стартер» для согласованности с другими хранилищами с реактивной поддержкой.

2.1.1. Подключение к Redis

Вы можете инжектировать автоматически настроенный RedisConnectionFactory, StringRedisTemplate, или стандартный RedisTemplate экземпляр, как любой другой компонент Spring. Следующий фрагмент кода демонстрирует пример такого компонента:

Java
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");
    }

}
Kotlin
import org.springframework.data.redis.core.StringRedisTemplate
import org.springframework.stereotype.Component

@Component
class MyBean(private val template: StringRedisTemplate) {

    // ...

    fun someMethod(): Boolean {
        return template.hasKey("spring")
    }

}

По умолчанию, экземпляр пытается подключиться к серверу Redis по адресу localhost:6379. Вы можете указать пользовательские параметры подключения, используя свойства spring.data.redis.*, как показано в следующем примере:

Свойства
spring.data.redis.host=localhost
spring.data.redis.port=6379
spring.data.redis.database=0
spring.data.redis.username=user
spring.data.redis.password=secret
Yaml
spring:
  data:
    redis:
      host: "localhost"
      port: 6379
      database: 0
      username: "user"
      password: "secret"
Вы также можете зарегистрировать любое количество компонентов, реализующих LettuceClientConfigurationBuilderCustomizer для более сложных настроек. ClientResources также можно настроить, используя ClientResourcesBuilderCustomizer. Если вы используете Jedis, JedisClientConfigurationBuilderCustomizer также доступен. В качестве альтернативы, вы можете зарегистрировать компонент типа RedisStandaloneConfiguration, RedisSentinelConfiguration, или RedisClusterConfiguration, чтобы полностью контролировать конфигурацию.

Если вы добавите свой собственный @Bean любого из автоматически настроенных типов, он заменит значение по умолчанию (за исключением RedisTemplate, когда исключение основано на имени компонента, redisTemplate, а не на его типе).

По умолчанию, пул подключений автоматически настраивается, если commons-pool2 находится в пути к классу.

Автоматически настроенный RedisConnectionFactory можно настроить на использование SSL для связи с сервером, установив свойства, как показано в этом примере:

Свойства
spring.data.redis.ssl.enabled=true
Yaml
spring:
  data:
    redis:
      ssl:
        enabled: true

Пользовательский SSL-материал доверия может быть настроен в SSL-пакете и применен к RedisConnectionFactory, как показано в этом примере:

Свойства
spring.data.redis.ssl.bundle=example
Yaml
spring:
  data:
    redis:
      ssl:
        bundle: "example"

2.2. MongoDB

MongoDB — это открытая база данных 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 по адресу mongodb://localhost/test. Следующий пример показывает, как подключиться к базе данных MongoDB:

Java
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");
    }

}
Kotlin
import com.mongodb.client.MongoCollection
import org.bson.Document
import org.springframework.data.mongodb.MongoDatabaseFactory
import org.springframework.stereotype.Component

@Component
class MyBean(private val mongo: MongoDatabaseFactory) {

    // ...

    fun someMethod(): MongoCollection<Document> {
        val db = mongo.mongoDatabase
        return db.getCollection("users")
    }

}

Если вы определили свой собственный MongoClient, он будет использован для автоматической настройки подходящего MongoDatabaseFactory.

Автоматически настроенный MongoClient создается с помощью MongoClientSettings bean. Если вы определили свой собственный MongoClientSettings, он будет использован без изменений, и свойства spring.data.mongodb будут проигнорированы. В противном случае будет автоматически настроен MongoClientSettings и к нему будут применены свойства spring.data.mongodb. В любом случае, вы можете объявить один или несколько MongoClientSettingsBuilderCustomizer bean для настройки конфигурации MongoClientSettings. Каждый будет вызван в порядке с MongoClientSettings.Builder, используемым для построения MongoClientSettings.

Вы можете изменить URL и настроить дополнительные параметры, такие как репликация, задав свойство spring.data.mongodb.uri, как показано в следующем примере:

Свойства
spring.data.mongodb.uri=mongodb://user:secret@mongoserver1.example.com:27017,mongoserver2.example.com:23456/test
Yaml
spring:
  data:
    mongodb:
      uri: "mongodb://user:secret@mongoserver1.example.com:27017,mongoserver2.example.com:23456/test"

В качестве альтернативы вы можете указать данные подключения, используя отдельные свойства. Например, вы можете объявить следующие параметры в своём application.properties:

Свойства
spring.data.mongodb.host=mongoserver1.example.com
spring.data.mongodb.port=27017
spring.data.mongodb.additional-hosts[0]=mongoserver2.example.com:23456
spring.data.mongodb.database=test
spring.data.mongodb.username=user
spring.data.mongodb.password=secret
Yaml
spring:
  data:
    mongodb:
      host: "mongoserver1.example.com"
      port: 27017
      additional-hosts:
      - "mongoserver2.example.com:23456"
      database: "test"
      username: "user"
      password: "secret"

Автоматически настроенный MongoClient может быть настроен на использование SSL для связи с сервером, задав свойства, как показано в этом примере:

Свойства
spring.data.mongodb.uri=mongodb://user:secret@mongoserver1.example.com:27017,mongoserver2.example.com:23456/test
spring.data.mongodb.ssl.enabled=true
Yaml
spring:
  data:
    mongodb:
      uri: "mongodb://user:secret@mongoserver1.example.com:27017,mongoserver2.example.com:23456/test"
      ssl:
        enabled: true

Пользовательский материал доверия SSL может быть настроен в пакете SSL и применён к MongoClient как показано в этом примере:

Свойства
spring.data.mongodb.uri=mongodb://user:secret@mongoserver1.example.com:27017,mongoserver2.example.com:23456/test
spring.data.mongodb.ssl.bundle=example
Yaml
spring:
  data:
    mongodb:
      uri: "mongodb://user:secret@mongoserver1.example.com:27017,mongoserver2.example.com:23456/test"
      ssl:
        bundle: "example"

Если spring.data.mongodb.port не указан, используется значение по умолчанию 27017. Вы можете удалить эту строку из показанного ранее примера.

Вы также можете указать порт в качестве части адреса хоста, используя синтаксис host:port. Этот формат следует использовать, если нужно изменить порт записи additional-hosts.
Если вы не используете Spring Data MongoDB, вы можете ввести bean MongoClient вместо MongoDatabaseFactory. Если вы хотите полностью контролировать установление подключения к MongoDB, вы также можете объявить свой собственный bean MongoDatabaseFactory или MongoClient.
При использовании реактивного драйвера Netty требуется для SSL. Автонастройка настраивает этот фабрику автоматически, если Netty доступен и фабрика для использования не была настраивается ранее.

2.2.2. MongoTemplate

Spring Data MongoDB предоставляет класс MongoTemplate, по дизайну очень похожий на JdbcTemplate Spring. Как и с JdbcTemplate, Spring Boot автоматически настраивает для вас bean для ввода шаблона следующим образом:

Java
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");
    }

}
Kotlin
import com.mongodb.client.MongoCollection
import org.bson.Document
import org.springframework.data.mongodb.core.MongoTemplate
import org.springframework.stereotype.Component

@Component
class MyBean(private val mongoTemplate: MongoTemplate) {

    // ...

    fun someMethod(): MongoCollection<Document> {
        return mongoTemplate.getCollection("users")
    }

}

См. MongoOperations Javadoc для получения полной информации.

2.2.3. Репозитории Spring Data MongoDB

Spring Data включает поддержку репозиториев для MongoDB. Как и с репозиториями JPA, обсуждаемыми ранее, основной принцип заключается в том, что запросы автоматически строятся на основе имён методов.

Фактически, Spring Data JPA и Spring Data MongoDB используют одну и ту же общую инфраструктуру. Вы можете взять пример JPA из предыдущего раздела и, предполагая, что City теперь — это класс данных MongoDB, а не JPA @Entity, он работает так же, как показано в следующем примере:

Java
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);

}
Kotlin
import org.springframework.data.domain.Page
import org.springframework.data.domain.Pageable
import org.springframework.data.repository.Repository

interface CityRepository :
    Repository<City?, Long?> {
    fun findAll(pageable: Pageable?): Page<City?>?
    fun findByNameAndStateAllIgnoringCase(name: String?, state: String?): City?
}

Репозитории и документы обнаруживаются путём сканирования. По умолчанию ищется пакет, содержащий ваш основной конфигурационный класс (тот, который аннотирован с помощью @EnableAutoConfiguration или @SpringBootApplication) и все пакеты ниже него. Вы можете настроить места поиска репозиториев и документов, используя @EnableMongoRepositories и @EntityScan соответственно.

Для получения полной информации о Spring Data MongoDB, включая его богатые технологии отображения объектов, ознакомьтесь с его документацией.

2.3. Neo4j

Neo4j — это открытая база данных графов NoSQL, которая использует богатую модель данных узлов, соединённых отношениями первого класса. Это лучше подходит для обработки связанных больших данных, чем традиционные подходы с использованием RDBMS. Spring Boot предлагает несколько удобств для работы с Neo4j, включая spring-boot-starter-data-neo4j «Starter».

2.3.1. Подключение к базе данных Neo4j

Для доступа к серверу Neo4j вы можете внедрить автоматически настроенный org.neo4j.driver.Driver. По умолчанию, экземпляр пытается подключиться к серверу Neo4j по адресу localhost:7687 используя протокол Bolt. Следующий пример показывает, как внедрить Neo4j Driver, который даёт вам доступ, среди прочего, к Session.

Java
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.executeWrite(
                    (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());
        }
    }

}
Kotlin
import org.neo4j.driver.*
import org.springframework.stereotype.Component

@Component
class MyBean(private val driver: Driver) {

    // ...

    fun someMethod(message: String?): String {
        driver.session().use { session ->
            return@someMethod session.executeWrite { transaction: TransactionContext ->
                transaction
                    .run(
                        "CREATE (a:Greeting) SET a.message = \$message RETURN a.message + ', from node ' + id(a)",
                        Values.parameters("message", message)
                    )
                    .single()[0].asString()
            }
        }
    }

}

Вы можете настроить различные аспекты драйвера, используя свойства spring.neo4j.*. Следующий пример показывает, как настроить uri и учетные данные для использования:

Properties
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 бинов. Каждый из них будет вызван в порядке с ConfigBuilder , который используется для построения Driver.

2.3.2. Репозитории Spring Data Neo4j

Spring Data включает поддержку репозиториев для Neo4j. Полные сведения о Spring Data Neo4j смотрите в документации.

Spring Data Neo4j разделяет общую инфраструктуру с Spring Data JPA, как и многие другие модули Spring Data. Вы можете взять пример JPA из предыдущего раздела и определить City как репозиторий Spring Data Neo4j @Node вместо JPA @Entity, и абстракция репозитория работает аналогично, как показано в следующем примере:

Java
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);

}
Kotlin
import org.springframework.data.neo4j.repository.Neo4jRepository
import java.util.Optional

interface CityRepository : Neo4jRepository<City?, Long?> {

    fun findOneByNameAndState(name: String?, state: String?): Optional<City?>?

}

spring-boot-starter-data-neo4j «Starter» включает поддержку репозиториев, а также управление транзакциями. Spring Boot поддерживает как классические, так и реактивные репозитории Neo4j, используя бины Neo4jTemplate или ReactiveNeo4jTemplate. Если Project Reactor доступен в classpath, то реактивный стиль также автоматически настраивается.

Репозитории и сущности находятся путём сканирования. По умолчанию ищется пакет, содержащий ваш основной конфигурационный класс ( тот, который аннотирован как @EnableAutoConfiguration или @SpringBootApplication) и все пакеты ниже него. Вы можете настроить расположения поиска репозиториев и сущностей, соответственно, используя @EnableNeo4jRepositories и @EntityScan.

В приложении, использующем реактивный стиль, ReactiveTransactionManager не настраивается автоматически. Чтобы включить управление транзакциями, необходимо определить следующий бинов в вашей конфигурации:

Java
import org.neo4j.driver.Driver;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.neo4j.core.ReactiveDatabaseSelectionProvider;
import org.springframework.data.neo4j.core.transaction.ReactiveNeo4jTransactionManager;

@Configuration(proxyBeanMethods = false)
public class MyNeo4jConfiguration {

    @Bean
    public ReactiveNeo4jTransactionManager reactiveTransactionManager(Driver driver,
            ReactiveDatabaseSelectionProvider databaseNameProvider) {
        return new ReactiveNeo4jTransactionManager(driver, databaseNameProvider);
    }

}
Kotlin
import org.neo4j.driver.Driver
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.data.neo4j.core.ReactiveDatabaseSelectionProvider
import org.springframework.data.neo4j.core.transaction.ReactiveNeo4jTransactionManager

@Configuration(proxyBeanMethods = false)
class MyNeo4jConfiguration {

    @Bean
    fun reactiveTransactionManager(driver: Driver,
            databaseNameProvider: ReactiveDatabaseSelectionProvider): ReactiveNeo4jTransactionManager {
        return ReactiveNeo4jTransactionManager(driver, databaseNameProvider)
    }
}

2.4. Elasticsearch

Elasticsearch — это открытый исходный код, распределённый, RESTful движок поиска и аналитики. Spring Boot предоставляет базовую автоконфигурацию для Elasticsearch клиентов.

Spring Boot поддерживает несколько клиентов:

  • Официальный клиент низкого уровня REST

  • Официальный Java API клиент

  • Клиент ReactiveElasticsearchClient, предоставляемый Spring Data Elasticsearch

Spring Boot предоставляет специализированный «Стартер», spring-boot-starter-data-elasticsearch.

2.4.1. Подключение к Elasticsearch с помощью REST клиентов

Elasticsearch поставляет два разных REST клиента, которые вы можете использовать для запроса кластера: клиент низкого уровня низкого уровня из модуля org.elasticsearch.client:elasticsearch-rest-client и клиент Java API Java API клиента из модуля co.elastic.clients:elasticsearch-java. Кроме того, Spring Boot предоставляет поддержку реактивного клиента из модуля org.springframework.data:spring-data-elasticsearch. По умолчанию клиенты будут обращаться к 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"
Подключение к Elasticsearch с помощью RestClient

Если у вас elasticsearch-rest-client в классе, Spring Boot автоматически сконфигурирует и зарегистрирует бин RestClient. В дополнение к описанным ранее свойствам, для точной настройки RestClient вы можете зарегистрировать произвольное количество бинов, реализующих RestClientBuilderCustomizer для более продвинутых настроек. Для полного контроля над конфигурацией клиентов, определите бин RestClientBuilder.

Кроме того, если elasticsearch-rest-client-sniffer находится в классе, бин Sniffer автоматически настроен для автоматического обнаружения узлов из работающего кластера Elasticsearch и установки их на бин RestClient. Вы можете дополнительно настроить, как 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"
Подключение к Elasticsearch с помощью ElasticsearchClient

Если у вас co.elastic.clients:elasticsearch-java в классе, Spring Boot автоматически сконфигурирует и зарегистрирует бин ElasticsearchClient.

ElasticsearchClient использует транспорт, зависящий от ранее описанного RestClient. Поэтому, описанные ранее свойства могут быть использованы для настройки ElasticsearchClient. Кроме того, вы можете определить бин TransportOptions для дальнейшего контроля поведения транспорта.

Подключение к Elasticsearch с помощью ReactiveElasticsearchClient

Spring Data Elasticsearch поставляет ReactiveElasticsearchClient для запроса экземпляров Elasticsearch реактивным способом. Если у вас Spring Data Elasticsearch и Reactor в классе, Spring Boot автоматически сконфигурирует и зарегистрирует ReactiveElasticsearchClient.

ReactiveElasticsearchclient использует транспорт, зависящий от ранее описанного RestClient. Поэтому, описанные ранее свойства могут быть использованы для настройки ReactiveElasticsearchClient. Кроме того, вы можете определить бин TransportOptions для дальнейшего контроля поведения транспорта.

2.4.2. Подключение к Elasticsearch с использованием Spring Data

Для подключения к Elasticsearch должен быть определён бин ElasticsearchClient, автоматически сконфигурированный Spring Boot или предоставленный приложением вручную (см. предыдущие разделы). С этой конфигурацией, бин ElasticsearchTemplate может быть инжектирован как любой другой бин Spring, как показано в следующем примере:

Java
import org.springframework.data.elasticsearch.client.elc.ElasticsearchTemplate;
import org.springframework.stereotype.Component;

@Component
public class MyBean {

    private final ElasticsearchTemplate template;

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

    // ...

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

}
Kotlin
import org.springframework.stereotype.Component

@Component
class MyBean(private val template: org.springframework.data.elasticsearch.client.erhlc.ElasticsearchRestTemplate ) {

    // ...

    fun someMethod(id: String): Boolean {
        return template.exists(id, User::class.java)
    }

}

При наличии spring-data-elasticsearch и Reactor, Spring Boot также может автоматически сконфигурировать ReactiveElasticsearchClient и ReactiveElasticsearchTemplate как бины. Они являются реактивным эквивалентом других REST клиентов.

2.4.3. Репозитории Spring Data Elasticsearch

Spring Data включает поддержку репозиториев для Elasticsearch. Как и с репозиториями JPA, рассмотренными ранее, базовый принцип заключается в том, что запросы автоматически генерируются на основе имён методов.

На самом деле, Spring Data JPA и Spring Data Elasticsearch используют общую инфраструктуру. Вы можете взять пример JPA из предыдущего и, предположив, что City теперь Elasticsearch класс @Document, а не класс JPA @Entity, он работает так же.

Репозитории и документы находятся путем сканирования. По умолчанию, пакет, содержащий ваш основной конфигурационный класс ( тот, который аннотирован @EnableAutoConfiguration или @SpringBootApplication) и все вложенные пакеты сканируются. Вы можете настроить места поиска репозиториев и документов, используя @EnableElasticsearchRepositories и @EntityScan соответственно.

Для получения полной информации о Spring Data Elasticsearch, см. документацию по справке.

Spring Boot поддерживает как классические, так и реактивные репозитории Elasticsearch, используя бины ElasticsearchRestTemplate или ReactiveElasticsearchTemplate. Скорее всего, эти бины автоматически сконфигурированы Spring Boot, если необходимые зависимости присутствуют.

Если вы хотите использовать свой собственный шаблон для поддержки репозиториев Elasticsearch, вы можете добавить свой собственный бин ElasticsearchRestTemplate или ElasticsearchOperations @Bean, при условии, что он называется "elasticsearchTemplate". То же самое относится к ReactiveElasticsearchTemplate и ReactiveElasticsearchOperations, с именем бина "reactiveElasticsearchTemplate".

Вы можете отключить поддержку репозиториев с помощью следующего свойства:

Свойства
spring.data.elasticsearch.repositories.enabled=false
Yaml
spring:
  data:
    elasticsearch:
      repositories:
        enabled: false

2.5. Cassandra

Cassandra — это открытая система управления распределённой базой данных, предназначенная для обработки больших объёмов данных на множестве обычных серверов. Spring Boot предлагает автоматическую настройку для Cassandra и абстракций поверх неё, предоставляемых Spring Data Cassandra. Существует spring-boot-starter-data-cassandra «Starter» для удобного сбора зависимостей.

2.5.1. Подключение к Cassandra

Вы можете ввести автоматически настроенный CassandraTemplate или экземпляр Cassandra CqlSession так же, как и любой другой Bean Spring. Свойства spring.cassandra.* могут быть использованы для настройки подключения. Обычно вы предоставляете keyspace-name и contact-points, а также имя локального дата-центра, как показано в следующем примере:

Свойства
spring.cassandra.keyspace-name=mykeyspace
spring.cassandra.contact-points=cassandrahost1:9042,cassandrahost2:9042
spring.cassandra.local-datacenter=datacenter1
Yaml
spring:
  cassandra:
    keyspace-name: "mykeyspace"
    contact-points: "cassandrahost1:9042,cassandrahost2:9042"
    local-datacenter: "datacenter1"

Если порт одинаков для всех точек контакта, можно использовать сокращение и указать только имена хостов, как показано в следующем примере:

Свойства
spring.cassandra.keyspace-name=mykeyspace
spring.cassandra.contact-points=cassandrahost1,cassandrahost2
spring.cassandra.local-datacenter=datacenter1
Yaml
spring:
  cassandra:
    keyspace-name: "mykeyspace"
    contact-points: "cassandrahost1,cassandrahost2"
    local-datacenter: "datacenter1"
Эти два примера идентичны, так как порт по умолчанию 9042. Если вам нужно настроить порт, используйте spring.cassandra.port.

Автоматически настроенный CqlSession можно настроить для использования SSL для связи с сервером, установив свойства, как показано в этом примере:

Свойства
spring.cassandra.keyspace-name=mykeyspace
spring.cassandra.contact-points=cassandrahost1,cassandrahost2
spring.cassandra.local-datacenter=datacenter1
spring.cassandra.ssl.enabled=true
Yaml
spring:
  cassandra:
    keyspace-name: "mykeyspace"
    contact-points: "cassandrahost1,cassandrahost2"
    local-datacenter: "datacenter1"
    ssl:
      enabled: true

Пользовательские данные сертификата доверия SSL могут быть настроены в сборке SSL и применены к CqlSession как показано в этом примере:

Свойства
spring.cassandra.keyspace-name=mykeyspace
spring.cassandra.contact-points=cassandrahost1,cassandrahost2
spring.cassandra.local-datacenter=datacenter1
spring.cassandra.ssl.bundle=example
Yaml
spring:
  cassandra:
    keyspace-name: "mykeyspace"
    contact-points: "cassandrahost1,cassandrahost2"
    local-datacenter: "datacenter1"
    ssl:
      bundle: "example"

Драйвер Cassandra имеет собственную инфраструктуру конфигурации, которая загружает application.conf в корне каталога класса.

Spring Boot по умолчанию не ищет такой файл, но может загрузить его, используя spring.cassandra.config. Если свойство присутствует как в spring.cassandra.*, так и в файле конфигурации, значение в spring.cassandra.* имеет приоритет.

Для более продвинутых настроек драйвера вы можете зарегистрировать любое количество бинов, реализующих DriverConfigLoaderBuilderCustomizer. CqlSession можно настроить с помощью бина типа CqlSessionBuilderCustomizer.
Если вы используете CqlSessionBuilder для создания нескольких CqlSession бинов, имейте в виду, что билдер является изменяемым, поэтому убедитесь, что для каждой сессии вводится свежая копия.

Следующий фрагмент кода демонстрирует, как ввести бин Cassandra:

Java
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);
    }

}
Kotlin
import org.springframework.data.cassandra.core.CassandraTemplate
import org.springframework.stereotype.Component

@Component
class MyBean(private val template: CassandraTemplate) {

    // ...

    fun someMethod(): Long {
        return template.count(User::class.java)
    }

}

Если вы добавите свой собственный @Bean типа CassandraTemplate, он заменит значение по умолчанию.

2.5.2. Репозитории Spring Data Cassandra

Spring Data включает базовые репозитории поддержки Cassandra. В настоящее время это ограничено по сравнению с репозиториями JPA, обсуждаемыми ранее, и требует методов поиска, помеченных @Query.

Репозитории и сущности находятся через сканирование. По умолчанию сканируется пакет, содержащий ваш главный класс конфигурации (заметенный @EnableAutoConfiguration или @SpringBootApplication) и все пакеты ниже него. Вы можете настроить места поиска репозиториев и сущностей с помощью @EnableCassandraRepositories и @EntityScan соответственно.

Более подробную информацию о Spring Data Cassandra см. в документации.

2.6. Couchbase

Couchbase — это открытая, распределённая база данных NoSQL с поддержкой нескольких моделей, ориентированная на документы, оптимизированная для интерактивных приложений. Spring Boot предоставляет автоматическую конфигурацию для Couchbase и абстракции поверх неё, предоставляемые Spring Data Couchbase. Существуют spring-boot-starter-data-couchbase и spring-boot-starter-data-couchbase-reactive «Starters» для удобного сбора зависимостей.

2.6.1. Подключение к Couchbase

Вы можете получить Cluster, добавив Couchbase SDK и немного конфигурации. Свойства spring.couchbase.* могут быть использованы для настройки подключения. Обычно вы предоставляете строку подключения, имя пользователя и пароль, как показано в следующем примере:

Свойства
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 со ссылкой на настроенную сборку SSL:

Свойства
spring.couchbase.env.timeouts.connect=3s
spring.couchbase.env.ssl.bundle=example
Yaml
spring:
  couchbase:
    env:
      timeouts:
        connect: "3s"
      ssl:
        bundle: "example"
Проверьте spring.couchbase.env.* свойства для получения дополнительной информации. Для более тонкого управления можно использовать один или несколько ClusterEnvironmentBuilderCustomizer бинов.

2.6.2. Репозитории Spring Data Couchbase

Spring Data включает поддержку репозиториев для Couchbase.

Репозитории и документы находятся через сканирование. По умолчанию сканируется пакет, содержащий ваш главный класс конфигурации (заметенный @EnableAutoConfiguration или @SpringBootApplication) и все пакеты ниже него. Вы можете настроить места поиска репозиториев и документов с помощью @EnableCouchbaseRepositories и @EntityScan соответственно.

Более подробную информацию о Spring Data Couchbase см. в документации.

Вы можете ввести автоматически настроенный CouchbaseTemplate экземпляр, как и любой другой Spring Bean, при условии наличия CouchbaseClientFactory бина. Это происходит, когда Cluster доступен, как описано выше, и указано имя ведра:

Свойства
spring.data.couchbase.bucket-name=my-bucket
Yaml
spring:
  data:
    couchbase:
      bucket-name: "my-bucket"

Следующие примеры показывают, как ввести CouchbaseTemplate бин:

Java
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();
    }

}
Kotlin
import org.springframework.data.couchbase.core.CouchbaseTemplate
import org.springframework.stereotype.Component

@Component
class MyBean(private val template: CouchbaseTemplate) {

    // ...

    fun someMethod(): String {
        return template.bucketName
    }

}

Существует несколько бинов, которые вы можете определить в вашей собственной конфигурации, чтобы переопределить те, что предоставляются автоматической конфигурацией:

  • A CouchbaseMappingContext @Bean с именем couchbaseMappingContext.

  • A CustomConversions @Bean с именем couchbaseCustomConversions.

  • A CouchbaseTemplate @Bean с именем couchbaseTemplate.

Чтобы избежать жесткого кодирования этих имён в вашей собственной конфигурации, вы можете повторно использовать BeanNames предоставляемый Spring Data Couchbase. Например, вы можете настроить используемые преобразователи следующим образом:

Java
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()));
    }

}
Kotlin
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)
class MyCouchbaseConfiguration {

    @Bean(BeanNames.COUCHBASE_CUSTOM_CONVERSIONS)
    fun myCustomConversions(): CouchbaseCustomConversions {
        return CouchbaseCustomConversions(Arrays.asList(MyConverter()))
    }

}

2.7. LDAP

LDAP (Lightweight Directory Access Protocol) — это открытый, независимый от поставщика отраслевой стандартный протокол приложения для доступа и поддержки распределённых сервисов каталогов информации по сети IP. Spring Boot предлагает автоконфигурацию для любого совместимого сервера LDAP, а также поддержку встроенного сервера LDAP в памяти от UnboundID.

Абстракции LDAP предоставляются Spring Data LDAP. Есть spring-boot-starter-data-ldap «Starter» для удобного сбора зависимостей.

2.7.1. Подключение к серверу LDAP

Для подключения к серверу LDAP убедитесь, что вы объявили зависимость от spring-boot-starter-data-ldap «Starter» или spring-ldap-core , а затем объявите URL вашего сервера в application.properties, как показано в следующем примере:

Свойства
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 автоматически настраивается на основе этих параметров. Если доступен bean DirContextAuthenticationStrategy, он ассоциируется с автоматически настроенным LdapContextSource. Если вам нужно его настроить, например, для использования PooledContextSource, вы всё равно можете ввести автоматически настроенный LdapContextSource. Убедитесь, что вы пометили свой настроенный ContextSource как @Primary, чтобы автоматически настроенный LdapTemplate его использовал.

2.7.2. Репозитории Spring Data LDAP

Spring Data включает поддержку репозиториев для LDAP.

Репозитории и документы находятся посредством сканирования. По умолчанию ищется пакет, содержащий ваш основной класс конфигурации (тот, который аннотирован @EnableAutoConfiguration или @SpringBootApplication ) и все вложенные. Вы можете настроить расположения для поиска репозиториев и документов, используя @EnableLdapRepositories и @EntityScan соответственно.

Для получения полной информации о Spring Data LDAP обратитесь к документации по справке.

Вы также можете ввести автоматически настроенный LdapTemplate экземпляр, как и любой другой bean Spring, как показано в следующем примере:

Java
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);
    }

}
Kotlin
import org.springframework.ldap.core.LdapTemplate
import org.springframework.stereotype.Component

@Component
class MyBean(private val template: LdapTemplate) {

    // ...

    fun someMethod(): List<User> {
        return template.findAll(User::class.java)
    }

}

2.7.3. Встроенный сервер LDAP в памяти

Для целей тестирования Spring Boot поддерживает автоматическую настройку встроенного сервера LDAP в памяти от UnboundID. Для настройки сервера добавьте зависимость от com.unboundid:unboundid-ldapsdk и объявите свойство spring.ldap.embedded.base-dn, как показано ниже:

Свойства
spring.ldap.embedded.base-dn=dc=spring,dc=io
Yaml
spring:
  ldap:
    embedded:
      base-dn: "dc=spring,dc=io"

Можно определить несколько значений base-dn, однако, поскольку имена различающихся имён обычно содержат запятые, их необходимо определить с использованием правильной записи.

В файлах yaml можно использовать запись списка yaml. В файлах properties необходимо включить индекс в качестве части имени свойства:

Свойства
spring.ldap.embedded.base-dn[0]=dc=spring,dc=io
spring.ldap.embedded.base-dn[1]=dc=vmware,dc=com
Yaml
spring.ldap.embedded.base-dn:
  - "dc=spring,dc=io"
  - "dc=vmware,dc=com"

По умолчанию сервер запускается на случайном порту и запускает стандартную поддержку LDAP. Не нужно указывать свойство spring.ldap.urls.

Если в вашей classpath есть файл schema.ldif, он используется для инициализации сервера. Если вы хотите загрузить скрипт инициализации из другого ресурса, вы также можете использовать свойство spring.ldap.embedded.ldif.

По умолчанию используется стандартная схема для проверки LDIF файлов. Вы можете отключить проверку полностью, установив свойство spring.ldap.embedded.validation.enabled. Если у вас есть пользовательские атрибуты, вы можете использовать spring.ldap.embedded.validation.schema для определения ваших типов пользовательских атрибутов или классов объектов.

2.8. InfluxDB

InfluxDB — это открытая база данных временных рядов, оптимизированная для быстрого и высокодоступного хранения и извлечения данных временных рядов в таких областях, как мониторинг работы, метрики приложений, данные датчиков Интернета вещей и аналитика в реальном времени.

2.8.1. Подключение к InfluxDB

Spring Boot автоматически настраивает экземпляр InfluxDB , при условии, что клиент influxdb-java находится в classpath и URL базы данных установлен, как показано в следующем примере:

Свойства
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 использует за кулисами, вы можете зарегистрировать bean InfluxDbOkHttpClientBuilderProvider.

Если вам нужен больший контроль над конфигурацией, рассмотрите возможность регистрации bean InfluxDbCustomizer.

3. Что читать дальше

Теперь у вас должно сложиться представление о том, как использовать Spring Boot с различными технологиями данных. Отсюда вы можете прочитать о поддержке Spring Boot для различных технологий обмена сообщениями и о том, как включить их в своё приложение.

Copyright © 2012-2023 VMware, Inc.
Licensed under the Apache License, Version 2.0.
https://docs.spring.io/spring-boot/docs/3.1.3/reference/html/data.html

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API