此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Boot 3.3.4！spring-doc.cn

此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Boot 3.3.4！spring-doc.cn

Spring Boot 包含许多用于处理数据源的 Starter。 本节回答与执行此操作相关的问题。spring-doc.cn

配置自定义数据源

要配置您自己的 ，请在您的配置中定义该类型的 。 Spring Boot 在需要的地方重用你，包括数据库初始化。 如果需要外部化某些设置，可以将 your 绑定到环境（请参阅 第三方配置）。DataSource@BeanDataSourceDataSourcespring-doc.cn

以下示例显示了如何在 Bean 中定义数据源：spring-doc.cn

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class MyDataSourceConfiguration {

	@Bean
	@ConfigurationProperties(prefix = "app.datasource")
	public SomeDataSource dataSource() {
		return new SomeDataSource();
	}

}
import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration

@Configuration(proxyBeanMethods = false)
class MyDataSourceConfiguration {

	@Bean
	@ConfigurationProperties(prefix = "app.datasource")
	fun dataSource(): SomeDataSource {
		return SomeDataSource()
	}

}

以下示例显示如何通过设置数据源的属性来定义数据源：spring-doc.cn

app.datasource.url=jdbc:h2:mem:mydb
app.datasource.username=sa
app.datasource.pool-size=30
app:
  datasource:
    url: "jdbc:h2:mem:mydb"
    username: "sa"
    pool-size: 30

假设 具有 URL、用户名和池大小的常规 JavaBean 属性，则这些设置将在 可用于其他组件之前自动绑定。SomeDataSourceDataSourcespring-doc.cn

Spring Boot 还提供了一个名为 的 Util builder 类，该类可用于创建标准数据源之一（如果它在 Classpath 上）。 构建器可以根据 Classpath 上可用的内容来检测要使用的 Classpath。 它还会根据 JDBC URL 自动检测驱动程序。DataSourceBuilderspring-doc.cn

以下示例演示如何使用 ：DataSourceBuilderspring-doc.cn

import javax.sql.DataSource;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class MyDataSourceConfiguration {

	@Bean
	@ConfigurationProperties("app.datasource")
	public DataSource dataSource() {
		return DataSourceBuilder.create().build();
	}

}
import javax.sql.DataSource

import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.boot.jdbc.DataSourceBuilder
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration

@Configuration(proxyBeanMethods = false)
class MyDataSourceConfiguration {

	@Bean
	@ConfigurationProperties("app.datasource")
	fun dataSource(): DataSource {
		return DataSourceBuilder.create().build()
	}

}

要使用 该 运行应用程序，您只需要连接信息。 还可以提供特定于池的设置。 检查将在运行时使用的实现以获取更多详细信息。DataSourcespring-doc.cn

以下示例演示如何通过设置属性来定义 JDBC 数据源：spring-doc.cn

app.datasource.url=jdbc:mysql://localhost/test
app.datasource.username=dbuser
app.datasource.password=dbpass
app.datasource.pool-size=30
app:
  datasource:
    url: "jdbc:mysql://localhost/test"
    username: "dbuser"
    password: "dbpass"
    pool-size: 30

但是，有一个问题。 由于未公开连接池的实际类型，因此不会在自定义的元数据中生成任何键，并且 IDE 中也没有可用的完成（因为接口没有公开任何属性）。 此外，如果您碰巧在 Classpath 上有 Hikari，则此基本设置不起作用，因为 Hikari 没有属性（但确实有属性）。 在这种情况下，您必须按如下方式重写配置：DataSourceDataSourceurljdbcUrlspring-doc.cn

app.datasource.jdbc-url=jdbc:mysql://localhost/test
app.datasource.username=dbuser
app.datasource.password=dbpass
app.datasource.pool-size=30
app:
  datasource:
    jdbc-url: "jdbc:mysql://localhost/test"
    username: "dbuser"
    password: "dbpass"
    pool-size: 30

您可以通过强制连接池使用并返回专用实现而不是 . 您无法在运行时更改实现，但选项列表将是显式的。DataSourcespring-doc.cn

以下示例演示如何创建 with ：HikariDataSourceDataSourceBuilderspring-doc.cn

import com.zaxxer.hikari.HikariDataSource;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class MyDataSourceConfiguration {

	@Bean
	@ConfigurationProperties("app.datasource")
	public HikariDataSource dataSource() {
		return DataSourceBuilder.create().type(HikariDataSource.class).build();
	}

}
import com.zaxxer.hikari.HikariDataSource
import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.boot.jdbc.DataSourceBuilder
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration

@Configuration(proxyBeanMethods = false)
class MyDataSourceConfiguration {

	@Bean
	@ConfigurationProperties("app.datasource")
	fun dataSource(): HikariDataSource {
		return DataSourceBuilder.create().type(HikariDataSource::class.java).build()
	}

}

您甚至可以利用为您服务的功能来更进一步 — 也就是说，如果未提供 URL，则为默认嵌入式数据库提供合理的用户名和密码。 你可以轻松地从任何对象的 state 初始化一个，因此你也可以注入 Spring Boot 自动创建的DataSource。 但是，这会将您的配置拆分为两个命名空间： 、 、 、 和 on ，其余的在您的自定义命名空间 （） 上。 为避免这种情况，您可以在自定义命名空间上重新定义自定义，如以下示例所示：DataSourcePropertiesDataSourceBuilderDataSourcePropertiesurlusernamepasswordtypedriverspring.datasourceapp.datasourceDataSourcePropertiesspring-doc.cn

import com.zaxxer.hikari.HikariDataSource;

import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

@Configuration(proxyBeanMethods = false)
public class MyDataSourceConfiguration {

	@Bean
	@Primary
	@ConfigurationProperties("app.datasource")
	public DataSourceProperties dataSourceProperties() {
		return new DataSourceProperties();
	}

	@Bean
	@ConfigurationProperties("app.datasource.configuration")
	public HikariDataSource dataSource(DataSourceProperties properties) {
		return properties.initializeDataSourceBuilder().type(HikariDataSource.class).build();
	}

}
import com.zaxxer.hikari.HikariDataSource
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties
import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.Primary

@Configuration(proxyBeanMethods = false)
class MyDataSourceConfiguration {

	@Bean
	@Primary
	@ConfigurationProperties("app.datasource")
	fun dataSourceProperties(): DataSourceProperties {
		return DataSourceProperties()
	}

	@Bean
	@ConfigurationProperties("app.datasource.configuration")
	fun dataSource(properties: DataSourceProperties): HikariDataSource {
		return properties.initializeDataSourceBuilder().type(HikariDataSource::class.java).build()
	}

}

此设置使您与 Spring Boot 默认为您执行的操作同步，除了选择了专用连接池（在代码中）并且其设置在子名称空间中公开。 因为 is 会为您处理 / 翻译，所以您可以按如下方式配置它：app.datasource.configurationDataSourcePropertiesurljdbcUrlspring-doc.cn

app.datasource.url=jdbc:mysql://localhost/test
app.datasource.username=dbuser
app.datasource.password=dbpass
app.datasource.configuration.maximum-pool-size=30
app:
  datasource:
    url: "jdbc:mysql://localhost/test"
    username: "dbuser"
    password: "dbpass"
    configuration:
      maximum-pool-size: 30
Spring Boot 会将特定于 Hikari 的设置公开给 . 此示例使用更通用的子命名空间，因为该示例不支持多个数据源实施。spring.datasource.hikariconfiguration
因为您的自定义配置选择与 Hikari 一起使用，所以没有效果。 在实践中，构建器会使用您可能在此处设置的任何值进行初始化，然后被对 .app.datasource.type.type()

有关更多详细信息，请参见“Spring Boot 功能”部分中的配置DataSource和DataSourceAutoConfiguration类。spring-doc.cn

Spring Boot 会将特定于 Hikari 的设置公开给 . 此示例使用更通用的子命名空间，因为该示例不支持多个数据源实施。spring.datasource.hikariconfiguration
因为您的自定义配置选择与 Hikari 一起使用，所以没有效果。 在实践中，构建器会使用您可能在此处设置的任何值进行初始化，然后被对 .app.datasource.type.type()

配置两个数据源

要定义 additional ，可以使用与上一节类似的方法。 一个关键区别是 必须使用 . 这可以防止 auto-configured 后退。 要允许在需要的地方注入 extra，还要对其进行注释，如以下示例所示：DataSourceDataSource@BeandefaultCandidate=falseDataSourceDataSource@Qualifierspring-doc.cn

import org.apache.commons.dbcp2.BasicDataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class MyAdditionalDataSourceConfiguration {

	@Qualifier("second")
	@Bean(defaultCandidate = false)
	@ConfigurationProperties("app.datasource")
	public BasicDataSource secondDataSource() {
		return DataSourceBuilder.create().type(BasicDataSource.class).build();
	}

}
import org.apache.commons.dbcp2.BasicDataSource

import org.springframework.beans.factory.annotation.Qualifier
import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.boot.jdbc.DataSourceBuilder
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration

@Configuration(proxyBeanMethods = false)
class MyAdditionalDataSourceConfiguration {

	@Qualifier("second")
	@Bean(defaultCandidate = false)
	@ConfigurationProperties("app.datasource")
	fun secondDataSource(): BasicDataSource {
		return DataSourceBuilder.create().type(BasicDataSource::class.java).build()
	}

}

要使用额外的 ，请使用相同的 .DataSource@Qualifierspring-doc.cn

可以按如下方式配置自动配置的数据源和其他数据源：spring-doc.cn

spring.datasource.url=jdbc:mysql://localhost/first
spring.datasource.username=dbuser
spring.datasource.password=dbpass
spring.datasource.configuration.maximum-pool-size=30
app.datasource.url=jdbc:mysql://localhost/second
app.datasource.username=dbuser
app.datasource.password=dbpass
app.datasource.max-total=30
spring:
  datasource:
    url: "jdbc:mysql://localhost/first"
    username: "dbuser"
    password: "dbpass"
    configuration:
      maximum-pool-size: 30
app:
  datasource:
    url: "jdbc:mysql://localhost/second"
    username: "dbuser"
    password: "dbpass"
    max-total: 30

可通过 properties 获得更高级的、特定于实现的自动配置的配置。 您也可以将相同的概念应用于 additional 以及，如以下示例所示：DataSourcespring.datasource.configuration.*DataSourcespring-doc.cn

import org.apache.commons.dbcp2.BasicDataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class MyCompleteAdditionalDataSourceConfiguration {

	@Qualifier("second")
	@Bean(defaultCandidate = false)
	@ConfigurationProperties("app.datasource")
	public DataSourceProperties secondDataSourceProperties() {
		return new DataSourceProperties();
	}

	@Qualifier("second")
	@Bean(defaultCandidate = false)
	@ConfigurationProperties("app.datasource.configuration")
	public BasicDataSource secondDataSource(
			@Qualifier("secondDataSourceProperties") DataSourceProperties secondDataSourceProperties) {
		return secondDataSourceProperties.initializeDataSourceBuilder().type(BasicDataSource.class).build();
	}

}
import org.apache.commons.dbcp2.BasicDataSource

import org.springframework.beans.factory.annotation.Qualifier
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties
import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration

@Configuration(proxyBeanMethods = false)
class MyCompleteAdditionalDataSourceConfiguration {

	@Qualifier("second")
	@Bean(defaultCandidate = false)
	@ConfigurationProperties("app.datasource")
	fun secondDataSourceProperties(): DataSourceProperties {
		return DataSourceProperties()
	}

	@Qualifier("second")
	@Bean(defaultCandidate = false)
	@ConfigurationProperties("app.datasource.configuration")
	fun secondDataSource(secondDataSourceProperties: DataSourceProperties): BasicDataSource {
		return secondDataSourceProperties.initializeDataSourceBuilder().type(BasicDataSource::class.java).build()
	}

}

前面的示例使用与 Spring Boot 在自动配置中使用的相同逻辑来配置其他数据源。 请注意，这些属性根据所选实施提供高级设置。app.datasource.configuration.*spring-doc.cn

使用 Spring 数据存储库

Spring Data 可以创建各种风格的接口的实现。 Spring Boot 会为您处理所有这些操作，只要这些实现包含在其中一个自动配置包中，通常是主应用程序类的包（或子包），该包用 or 注释。RepositoryRepository@SpringBootApplication@EnableAutoConfigurationspring-doc.cn

对于许多应用程序，您所需要做的就是将正确的 Spring Data 依赖项放在 Classpath 上。 有一个用于 JPA、用于 MongoDB 以及支持技术的各种其他Starters。 要开始使用，请创建一些存储库接口来处理您的对象。spring-boot-starter-data-jpaspring-boot-starter-data-mongodb@Entityspring-doc.cn

Spring Boot 通过扫描自动配置包来确定实现的位置。 要获得更多控制，请使用 Spring Data 中的 Comments。Repository@Enable…Repositoriesspring-doc.cn

有关 Spring Data 的更多信息，请参阅 Spring Data 项目页面。spring-doc.cn

将 @Entity 定义与 Spring 配置分开

Spring Boot 通过扫描自动配置包来确定定义的位置。 要获得更多控制，请使用注释，如以下示例所示：@Entity@EntityScanspring-doc.cn

import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
@EnableAutoConfiguration
@EntityScan(basePackageClasses = City.class)
public class MyApplication {

	// ...

}
import org.springframework.boot.autoconfigure.EnableAutoConfiguration
import org.springframework.boot.autoconfigure.domain.EntityScan
import org.springframework.context.annotation.Configuration

@Configuration(proxyBeanMethods = false)
@EnableAutoConfiguration
@EntityScan(basePackageClasses = [City::class])
class MyApplication {

	// ...

}

筛选扫描的 @Entity 定义

可以使用 Bean 过滤定义。 这在只应考虑可用实体的子集的测试中非常有用。 在以下示例中，仅包含包中的实体：@EntityManagedClassNameFiltercom.example.app.customerspring-doc.cn

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.orm.jpa.persistenceunit.ManagedClassNameFilter;

@Configuration(proxyBeanMethods = false)
public class MyEntityScanConfiguration {

	@Bean
	public ManagedClassNameFilter entityScanFilter() {
		return (className) -> className.startsWith("com.example.app.customer");
	}

}
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.orm.jpa.persistenceunit.ManagedClassNameFilter

@Configuration(proxyBeanMethods = false)
class MyEntityScanConfiguration {

	@Bean
	fun entityScanFilter() : ManagedClassNameFilter {
		return ManagedClassNameFilter { className ->
			className.startsWith("com.example.app.customer")
		}
	}
}

配置 JPA 属性

Spring Data JPA 已经提供了一些独立于供应商的配置选项（例如用于 SQL 日志记录的选项），并且 Spring Boot 将这些选项以及 Hibernate 的更多选项公开为外部配置属性。 其中一些是根据上下文自动检测的，因此您不必设置它们。spring-doc.cn

这是一种特殊情况，因为根据运行时条件，它具有不同的默认值。 如果使用嵌入式数据库，并且没有架构管理器（如 Liquibase 或 Flyway）正在处理 ，则默认为 。 在所有其他情况下，它默认为 。spring.jpa.hibernate.ddl-autoDataSourcecreate-dropnonespring-doc.cn

要使用的方言由 JPA 提供程序检测。 如果希望自己设置方言，请设置属性。spring.jpa.database-platformspring-doc.cn

以下示例显示了要设置的最常见选项：spring-doc.cn

spring.jpa.hibernate.naming.physical-strategy=com.example.MyPhysicalNamingStrategy
spring.jpa.show-sql=true
spring:
  jpa:
    hibernate:
      naming:
        physical-strategy: "com.example.MyPhysicalNamingStrategy"
    show-sql: true

此外，在创建 local 时，中的所有属性都作为普通 JPA 属性（去掉前缀）传递。spring.jpa.properties.*EntityManagerFactoryspring-doc.cn

您需要确保 下定义的名称与 JPA 提供程序预期的名称完全匹配。 Spring Boot 不会尝试对这些条目进行任何类型的松散绑定。spring.jpa.properties.*spring-doc.cn

例如，如果要配置 Hibernate 的批处理大小，则必须使用 . 如果使用其他形式（如 或 ），则 Hibernate 将不会应用该设置。spring.jpa.properties.hibernate.jdbc.batch_sizebatchSizebatch-sizespring-doc.cn
如果需要对 Hibernate 属性应用高级自定义，请考虑注册一个 Bean，该 Bean 将在创建 . 这优先于自动配置应用的任何内容。HibernatePropertiesCustomizerEntityManagerFactory

您需要确保 下定义的名称与 JPA 提供程序预期的名称完全匹配。 Spring Boot 不会尝试对这些条目进行任何类型的松散绑定。spring.jpa.properties.*spring-doc.cn

例如，如果要配置 Hibernate 的批处理大小，则必须使用 . 如果使用其他形式（如 或 ），则 Hibernate 将不会应用该设置。spring.jpa.properties.hibernate.jdbc.batch_sizebatchSizebatch-sizespring-doc.cn
如果需要对 Hibernate 属性应用高级自定义，请考虑注册一个 Bean，该 Bean 将在创建 . 这优先于自动配置应用的任何内容。HibernatePropertiesCustomizerEntityManagerFactory

配置 Hibernate 命名策略

Hibernate 使用两种不同的命名策略将名称从对象模型映射到相应的数据库名称。 物理和隐式策略实现的完全限定类名可以通过分别设置 和 属性来配置。 或者，如果 bean 在应用程序上下文中可用，则 Hibernate 将自动配置为使用它们。spring.jpa.hibernate.naming.physical-strategyspring.jpa.hibernate.naming.implicit-strategyImplicitNamingStrategyPhysicalNamingStrategyspring-doc.cn

默认情况下， Spring Boot 使用 . 使用此策略，所有点都替换为下划线，驼峰大小写也替换为下划线。 此外，默认情况下，所有表名都以小写形式生成。 例如，实体映射到表。 如果您的架构需要大小写混合标识符，请定义自定义 Bean，如以下示例所示：CamelCaseToUnderscoresNamingStrategyTelephoneNumbertelephone_numberCamelCaseToUnderscoresNamingStrategyspring-doc.cn

import org.hibernate.boot.model.naming.CamelCaseToUnderscoresNamingStrategy;
import org.hibernate.engine.jdbc.env.spi.JdbcEnvironment;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class MyHibernateConfiguration {

	@Bean
	public CamelCaseToUnderscoresNamingStrategy caseSensitivePhysicalNamingStrategy() {
		return new CamelCaseToUnderscoresNamingStrategy() {

			@Override
			protected boolean isCaseInsensitive(JdbcEnvironment jdbcEnvironment) {
				return false;
			}

		};
	}

}
import org.hibernate.boot.model.naming.CamelCaseToUnderscoresNamingStrategy
import org.hibernate.engine.jdbc.env.spi.JdbcEnvironment
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration

@Configuration(proxyBeanMethods = false)
class MyHibernateConfiguration {

	@Bean
	fun caseSensitivePhysicalNamingStrategy(): CamelCaseToUnderscoresNamingStrategy {
		return object : CamelCaseToUnderscoresNamingStrategy() {
			override fun isCaseInsensitive(jdbcEnvironment: JdbcEnvironment): Boolean {
				return false
			}
		}
	}

}

如果您更喜欢使用 Hibernate 的默认值，请设置以下属性：spring-doc.cn

spring.jpa.hibernate.naming.physical-strategy=org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
spring:
  jpa:
    hibernate:
      naming:
        physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl

或者，您可以配置以下 Bean：spring-doc.cn

import org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
class MyHibernateConfiguration {

	@Bean
	PhysicalNamingStrategyStandardImpl caseSensitivePhysicalNamingStrategy() {
		return new PhysicalNamingStrategyStandardImpl();
	}

}
import org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration

@Configuration(proxyBeanMethods = false)
internal class MyHibernateConfiguration {

	@Bean
	fun caseSensitivePhysicalNamingStrategy(): PhysicalNamingStrategyStandardImpl {
		return PhysicalNamingStrategyStandardImpl()
	}

}

有关更多详细信息，请参见HibernateJpaAutoConfiguration和JpaBaseConfiguration。spring-doc.cn

配置 Hibernate Second-Level Caching

可以为一系列缓存提供程序配置 Hibernate 二级缓存。 与其配置 Hibernate 再次查找缓存提供程序，不如尽可能提供上下文中可用的缓存提供程序。spring-doc.cn

要使用 JCache 执行此操作，首先确保它在 Classpath 上可用。 然后，添加一个 Bean，如以下示例所示：org.hibernate.orm:hibernate-jcacheHibernatePropertiesCustomizerspring-doc.cn

import org.hibernate.cache.jcache.ConfigSettings;

import org.springframework.boot.autoconfigure.orm.jpa.HibernatePropertiesCustomizer;
import org.springframework.cache.jcache.JCacheCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class MyHibernateSecondLevelCacheConfiguration {

	@Bean
	public HibernatePropertiesCustomizer hibernateSecondLevelCacheCustomizer(JCacheCacheManager cacheManager) {
		return (properties) -> properties.put(ConfigSettings.CACHE_MANAGER, cacheManager.getCacheManager());
	}

}
import org.hibernate.cache.jcache.ConfigSettings
import org.springframework.boot.autoconfigure.orm.jpa.HibernatePropertiesCustomizer
import org.springframework.cache.jcache.JCacheCacheManager
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration

@Configuration(proxyBeanMethods = false)
class MyHibernateSecondLevelCacheConfiguration {

	@Bean
	fun hibernateSecondLevelCacheCustomizer(cacheManager: JCacheCacheManager): HibernatePropertiesCustomizer {
		return HibernatePropertiesCustomizer { properties ->
			properties[ConfigSettings.CACHE_MANAGER] = cacheManager.cacheManager
		}
	}

}

此定制器将配置 Hibernate 以使用与应用程序使用的相同。 也可以使用单独的实例。 有关详细信息，请参阅 Hibernate 用户指南。CacheManagerCacheManagerspring-doc.cn

在 Hibernate 组件中使用依赖注入

默认情况下， Spring Boot 注册一个使用转换器和实体侦听器的实现，以便转换器和实体侦听器可以使用常规的依赖项注入。BeanContainerBeanFactoryspring-doc.cn

您可以通过注册 来禁用或优化此行为，该 用于删除或更改属性。HibernatePropertiesCustomizerhibernate.resource.beans.containerspring-doc.cn

使用自定义 EntityManagerFactory

要完全控制 的配置，您需要添加一个名为 'entityManagerFactory' 的 。 Spring Boot 自动配置在存在该类型的 bean 时关闭其实体 manager。EntityManagerFactory@Beanspring-doc.cn

当您为自己创建 Bean 时，在创建自动配置的 bean 期间应用的任何自定义都将丢失。 确保使用 auto-configured 来保留 JPA 和 vendor 属性。 如果您依赖属性来配置命名策略或 DDL 模式等内容，这一点尤其重要。LocalContainerEntityManagerFactoryBeanLocalContainerEntityManagerFactoryBeanEntityManagerFactoryBuilderspring.jpa.*
当您为自己创建 Bean 时，在创建自动配置的 bean 期间应用的任何自定义都将丢失。 确保使用 auto-configured 来保留 JPA 和 vendor 属性。 如果您依赖属性来配置命名策略或 DDL 模式等内容，这一点尤其重要。LocalContainerEntityManagerFactoryBeanLocalContainerEntityManagerFactoryBeanEntityManagerFactoryBuilderspring.jpa.*

使用多个 EntityManagerFactories

如果您需要对多个数据源使用 JPA，则可能需要每个数据源一个。 from Spring ORM 允许您根据需要配置 an。 您还可以重复使用以绑定设置一秒钟。 基于配置第二个 DataSource 的示例，可以定义第二个 DataSource，如以下示例所示：EntityManagerFactoryLocalContainerEntityManagerFactoryBeanEntityManagerFactoryJpaPropertiesEntityManagerFactoryEntityManagerFactoryspring-doc.cn

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.orm.jpa.JpaVendorAdapter;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;

@Configuration(proxyBeanMethods = false)
public class MyAdditionalEntityManagerFactoryConfiguration {

	@Qualifier("second")
	@Bean(defaultCandidate = false)
	@ConfigurationProperties("app.jpa")
	public JpaProperties secondJpaProperties() {
		return new JpaProperties();
	}

	@Qualifier("second")
	@Bean(defaultCandidate = false)
	public LocalContainerEntityManagerFactoryBean secondEntityManagerFactory(@Qualifier("second") DataSource dataSource,
			@Qualifier("second") JpaProperties jpaProperties) {
		EntityManagerFactoryBuilder builder = createEntityManagerFactoryBuilder(jpaProperties);
		return builder.dataSource(dataSource).packages(Order.class).persistenceUnit("second").build();
	}

	private EntityManagerFactoryBuilder createEntityManagerFactoryBuilder(JpaProperties jpaProperties) {
		JpaVendorAdapter jpaVendorAdapter = createJpaVendorAdapter(jpaProperties);
		return new EntityManagerFactoryBuilder(jpaVendorAdapter, jpaProperties.getProperties(), null);
	}

	private JpaVendorAdapter createJpaVendorAdapter(JpaProperties jpaProperties) {
		// ... map JPA properties as needed
		return new HibernateJpaVendorAdapter();
	}

}
import javax.sql.DataSource

import org.springframework.beans.factory.annotation.Qualifier
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties
import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.orm.jpa.JpaVendorAdapter
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter

@Configuration(proxyBeanMethods = false)
class MyAdditionalEntityManagerFactoryConfiguration {

	@Qualifier("second")
	@Bean(defaultCandidate = false)
	@ConfigurationProperties("app.jpa")
	fun secondJpaProperties(): JpaProperties {
		return JpaProperties()
	}

	@Qualifier("second")
	@Bean(defaultCandidate = false)
	fun firstEntityManagerFactory(
		@Qualifier("second") dataSource: DataSource,
		@Qualifier("second") jpaProperties: JpaProperties
	): LocalContainerEntityManagerFactoryBean {
		val builder = createEntityManagerFactoryBuilder(jpaProperties)
		return builder.dataSource(dataSource).packages(Order::class.java).persistenceUnit("second").build()
	}

	private fun createEntityManagerFactoryBuilder(jpaProperties: JpaProperties): EntityManagerFactoryBuilder {
		val jpaVendorAdapter = createJpaVendorAdapter(jpaProperties)
		return EntityManagerFactoryBuilder(jpaVendorAdapter, jpaProperties.properties, null)
	}

	private fun createJpaVendorAdapter(jpaProperties: JpaProperties): JpaVendorAdapter {
		// ... map JPA properties as needed
		return HibernateJpaVendorAdapter()
	}

}

上面的示例创建了一个使用 . 它扫描与数据包位于同一包中的实体。 可以使用命名空间映射其他 JPA 属性。 使用 of 允许定义 and bean，而不会干扰相同类型的自动配置的 bean。EntityManagerFactoryDataSource@Qualifier("second")Orderapp.jpa@Bean(defaultCandidate=false)secondJpaPropertiessecondEntityManagerFactoryspring-doc.cn

您应该为需要 JPA 访问权限的任何其他数据源提供类似的配置。 要完成这张图片，您还需要为每个 for each 配置 a。 或者，您可以使用跨越两者的 JTA 事务 Management 器。JpaTransactionManagerEntityManagerFactoryspring-doc.cn

如果使用 Spring Data，则需要进行相应的配置，如以下示例所示：@EnableJpaRepositoriesspring-doc.cn

import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

@Configuration(proxyBeanMethods = false)
@EnableJpaRepositories(basePackageClasses = Order.class, entityManagerFactoryRef = "entityManagerFactory")
public class OrderConfiguration {

}
import org.springframework.context.annotation.Configuration
import org.springframework.data.jpa.repository.config.EnableJpaRepositories

@Configuration(proxyBeanMethods = false)
@EnableJpaRepositories(basePackageClasses = [Order::class], entityManagerFactoryRef = "firstEntityManagerFactory")
class OrderConfiguration
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

@Configuration(proxyBeanMethods = false)
@EnableJpaRepositories(basePackageClasses = Customer.class, entityManagerFactoryRef = "secondEntityManagerFactory")
public class CustomerConfiguration {

}
import org.springframework.context.annotation.Configuration
import org.springframework.data.jpa.repository.config.EnableJpaRepositories

@Configuration(proxyBeanMethods = false)
@EnableJpaRepositories(basePackageClasses = [Customer::class], entityManagerFactoryRef = "secondEntityManagerFactory")
class CustomerConfiguration

使用传统 persistence.xml 文件

Spring Boot 默认情况下不会搜索或使用a。 如果您更喜欢使用传统的 ，则需要定义自己的类型（ID 为 'entityManagerFactory'）并在此处设置持久性单元名称。META-INF/persistence.xmlpersistence.xml@BeanLocalEntityManagerFactoryBeanspring-doc.cn

有关默认设置，请参见JpaBaseConfiguration。spring-doc.cn

使用 Spring Data JPA 和 Mongo 存储库

Spring Data JPA 和 Spring Data Mongo 都可以自动为您创建实现。 如果它们都存在于 Classpath 中，则可能必须进行一些额外的配置以告诉 Spring Boot 要创建哪些存储库。 最明确的方法是使用标准的 Spring Data 和 Comments，并提供接口的位置。Repository@EnableJpaRepositories@EnableMongoRepositoriesRepositoryspring-doc.cn

还有一些标志 （ 和 ） 可用于在外部配置中打开和关闭自动配置的存储库。 这样做很有用，例如，如果您想关闭 Mongo 存储库并仍然使用 auto-configured .spring.data.*.repositories.enabledspring.data.*.repositories.typeMongoTemplatespring-doc.cn

其他自动配置的 Spring Data 存储库类型（Elasticsearch、Redis 等）存在相同的障碍和相同的功能。 要使用它们，请相应地更改注释和标志的名称。spring-doc.cn

自定义 Spring Data 的 Web 支持

Spring Data 提供 Web 支持，可简化 Spring Data 存储库在 Web 应用程序中的使用。 Spring Boot 在名称空间中提供了用于自定义其配置的属性。 请注意，如果您使用的是 Spring Data REST，则必须改用名称空间中的属性。spring.data.webspring.data.restspring-doc.cn

将 Spring Data Repositories 公开为 REST 端点

Spring Data REST 可以为您公开 REST 端点的实现， 前提是已为应用程序启用了 Spring MVC。Repositoryspring-doc.cn

Spring Boot 公开了一组有用的属性（来自命名空间），用于自定义 . 如果需要提供其他自定义，则应使用 Bean。spring.data.restRepositoryRestConfigurationRepositoryRestConfigurerspring-doc.cn

如果未在 custom 上指定任何 order ，它将在 Spring Boot 内部使用的一个之后运行。 如果需要指定顺序，请确保顺序大于 0。RepositoryRestConfigurer
如果未在 custom 上指定任何 order ，它将在 Spring Boot 内部使用的一个之后运行。 如果需要指定顺序，请确保顺序大于 0。RepositoryRestConfigurer

配置 JPA 使用的组件

如果要配置 JPA 使用的组件，则需要确保在 JPA 之前初始化该组件。 当组件被自动配置时， Spring Boot 会为你处理这个问题。 例如，当 Flyway 被自动配置时，Hibernate 被配置为依赖于 Flyway，以便 Flyway 有机会在 Hibernate 尝试使用数据库之前初始化数据库。spring-doc.cn

如果您自己配置组件，则可以使用 subclass 作为设置必要依赖项的便捷方式。 例如，如果你使用 Hibernate Search 和 Elasticsearch 作为其索引管理器，则必须将任何 bean 配置为依赖于该 bean，如以下示例所示：EntityManagerFactoryDependsOnPostProcessorEntityManagerFactoryelasticsearchClientspring-doc.cn

import jakarta.persistence.EntityManagerFactory;

import org.springframework.boot.autoconfigure.orm.jpa.EntityManagerFactoryDependsOnPostProcessor;
import org.springframework.stereotype.Component;

/**
 * {@link EntityManagerFactoryDependsOnPostProcessor} that ensures that
 * {@link EntityManagerFactory} beans depend on the {@code elasticsearchClient} bean.
 */
@Component
public class ElasticsearchEntityManagerFactoryDependsOnPostProcessor
		extends EntityManagerFactoryDependsOnPostProcessor {

	public ElasticsearchEntityManagerFactoryDependsOnPostProcessor() {
		super("elasticsearchClient");
	}

}
import org.springframework.boot.autoconfigure.orm.jpa.EntityManagerFactoryDependsOnPostProcessor
import org.springframework.stereotype.Component

@Component
class ElasticsearchEntityManagerFactoryDependsOnPostProcessor :
	EntityManagerFactoryDependsOnPostProcessor("elasticsearchClient")

使用两个数据源配置 jOOQ

如果您需要将 jOOQ 与多个数据源一起使用，则应为每个数据源创建自己的数据源。 有关更多详细信息，请参阅 JooqAutoConfiguration 。DSLContextspring-doc.cn

特别是，可以重复使用以提供与自动配置对单个 .JooqExceptionTranslatorSpringTransactionProviderDataSource
特别是，可以重复使用以提供与自动配置对单个 .JooqExceptionTranslatorSpringTransactionProviderDataSource