此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Boot 3.3.1！Spring中文文档

此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Boot 3.3.1！Spring中文文档

Spring Boot 包含许多用于处理数据源的启动器。 本节回答与此相关的问题。Spring中文文档

配置自定义数据源

要配置自己的配置，请在配置中定义该类型的。 Spring Boot 在需要的任何地方重用，包括数据库初始化。 如果需要将某些设置外部化，可以将您的设置绑定到环境（请参阅“第三方配置”）。DataSource@BeanDataSourceDataSourceSpring中文文档

下面的示例演示如何在 Bean 中定义数据源：Spring中文文档

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中文文档

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中文文档

Spring Boot 还提供了一个名为 的实用程序构建器类，可用于创建标准数据源之一（如果它位于类路径上）。 构建器可以根据类路径上可用的内容来检测要使用哪一个。 它还会根据 JDBC URL 自动检测驱动程序。DataSourceBuilderSpring中文文档

下面的示例演示如何使用：DataSourceBuilderSpring中文文档

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中文文档

以下示例演示如何通过设置属性来定义 JDBC 数据源：Spring中文文档

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 中不会提供补全功能（因为接口不公开任何属性）。 此外，如果您碰巧在类路径上有 Hikari，则此基本设置不起作用，因为 Hikari 没有属性（但确实有属性）。 在这种情况下，您必须按如下方式重写配置：DataSourceDataSourceurljdbcUrlSpring中文文档

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中文文档

以下示例演示如何创建具有以下功能的 ：HikariDataSourceDataSourceBuilderSpring中文文档

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，则为默认嵌入式数据库提供合理的用户名和密码。 您可以轻松地从任何对象的状态初始化 a，因此您还可以注入 Spring Boot 自动创建的 DataSource。 但是，这会将您的配置拆分为两个命名空间：、 、 、 和 on，其余部分位于您的自定义命名空间 （） 上。 若要避免这种情况，可以在自定义命名空间上重新定义自定义项，如以下示例所示：DataSourcePropertiesDataSourceBuilderDataSourcePropertiesurlusernamepasswordtypedriverspring.datasourceapp.datasourceDataSourcePropertiesSpring中文文档

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为您执行的操作保持同步，只是选择了专用连接池（在代码中），并且其设置在子命名空间中公开。 因为正在为您处理 / 翻译，您可以按如下方式配置它：app.datasource.configurationDataSourcePropertiesurljdbcUrlSpring中文文档

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中文文档

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

配置两个数据源

如果需要配置多个数据源，可以应用上一节中介绍的相同技巧。 但是，您必须将其中一个实例标记为 ，因为以后的各种自动配置都希望能够按类型获取一个实例。DataSource@PrimarySpring中文文档

如果您创建自己的 ，自动配置会回退。 在以下示例中，我们提供的功能集与自动配置在主数据源上提供的功能集完全相同：DataSourceSpring中文文档

import com.zaxxer.hikari.HikariDataSource;
import org.apache.commons.dbcp2.BasicDataSource;

import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
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;
import org.springframework.context.annotation.Primary;

@Configuration(proxyBeanMethods = false)
public class MyDataSourcesConfiguration {

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

	@Bean
	@Primary
	@ConfigurationProperties("app.datasource.first.configuration")
	public HikariDataSource firstDataSource(DataSourceProperties firstDataSourceProperties) {
		return firstDataSourceProperties.initializeDataSourceBuilder().type(HikariDataSource.class).build();
	}

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

}
import com.zaxxer.hikari.HikariDataSource
import org.apache.commons.dbcp2.BasicDataSource
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties
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
import org.springframework.context.annotation.Primary

@Configuration(proxyBeanMethods = false)
class MyDataSourcesConfiguration {

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

	@Bean
	@Primary
	@ConfigurationProperties("app.datasource.first.configuration")
	fun firstDataSource(firstDataSourceProperties: DataSourceProperties): HikariDataSource {
		return firstDataSourceProperties.initializeDataSourceBuilder().type(HikariDataSource::class.java).build()
	}

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

}
firstDataSourceProperties必须标记为，以便数据库初始值设定项功能使用您的副本（如果使用初始值设定项）。@Primary

这两个数据源也都绑定到高级自定义。 例如，您可以按如下方式配置它们：Spring中文文档

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

    second:
      url: "jdbc:mysql://localhost/second"
      username: "dbuser"
      password: "dbpass"
      max-total: 30

您也可以将相同的概念应用于辅助数据库，如以下示例所示：DataSourceSpring中文文档

import com.zaxxer.hikari.HikariDataSource;
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;
import org.springframework.context.annotation.Primary;

@Configuration(proxyBeanMethods = false)
public class MyCompleteDataSourcesConfiguration {

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

	@Bean
	@Primary
	@ConfigurationProperties("app.datasource.first.configuration")
	public HikariDataSource firstDataSource(DataSourceProperties firstDataSourceProperties) {
		return firstDataSourceProperties.initializeDataSourceBuilder().type(HikariDataSource.class).build();
	}

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

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

}
import com.zaxxer.hikari.HikariDataSource
import org.apache.commons.dbcp2.BasicDataSource
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 MyCompleteDataSourcesConfiguration {

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

	@Bean
	@Primary
	@ConfigurationProperties("app.datasource.first.configuration")
	fun firstDataSource(firstDataSourceProperties: DataSourceProperties): HikariDataSource {
		return firstDataSourceProperties.initializeDataSourceBuilder().type(HikariDataSource::class.java).build()
	}

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

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

}

前面的示例在自定义命名空间上配置两个数据源，其逻辑与Spring Boot在自动配置中使用的逻辑相同。 请注意，每个子命名空间都根据所选的实现提供高级设置。configurationSpring中文文档

firstDataSourceProperties必须标记为，以便数据库初始值设定项功能使用您的副本（如果使用初始值设定项）。@Primary

使用 Spring 数据存储库

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

对于许多应用程序，您只需要在类路径上放置正确的 Spring Data 依赖项即可。 有一个用于 JPA、用于 Mongodb 和各种其他受支持技术的启动器。 首先，请创建一些存储库接口来处理您的对象。spring-boot-starter-data-jpaspring-boot-starter-data-mongodb@EntitySpring中文文档

Spring Boot 通过扫描自动配置包来确定定义的位置。 要获得更多控制，请使用 Spring Data 中的注释。@Repository@Enable…RepositoriesSpring中文文档

有关 Spring Data 的更多信息，请参阅 Spring Data 项目页面。Spring中文文档

将 @Entity 定义与 Spring 配置分开

Spring Boot 通过扫描自动配置包来确定定义的位置。 若要进行更多控制，请使用批注，如以下示例所示：@Entity@EntityScanSpring中文文档

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中文文档

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中文文档

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

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

以下示例显示了要设置的最常见选项：Spring中文文档

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

此外，在创建本地时，所有属性都将作为普通 JPA 属性（前缀去掉）传递。spring.jpa.properties.*EntityManagerFactorySpring中文文档

您需要确保 下定义的名称与 JPA 提供程序所期望的名称完全匹配。 Spring Boot 不会尝试对这些条目进行任何形式的宽松绑定。spring.jpa.properties.*Spring中文文档

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

您需要确保 下定义的名称与 JPA 提供程序所期望的名称完全匹配。 Spring Boot 不会尝试对这些条目进行任何形式的宽松绑定。spring.jpa.properties.*Spring中文文档

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

配置 Hibernate 命名策略

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

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

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中文文档

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中文文档

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中文文档

配置休眠二级缓存

可以为一系列缓存提供程序配置休眠二级缓存。 与其将 Hibernate 配置为再次查找缓存提供程序，不如尽可能提供上下文中可用的缓存提供程序。Spring中文文档

要使用 JCache 执行此操作，首先确保它在类路径上可用。 然后，添加一个 Bean，如以下示例所示：org.hibernate.orm:hibernate-jcacheHibernatePropertiesCustomizerSpring中文文档

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中文文档

在 Hibernate 组件中使用依赖注入

默认情况下，Spring Boot 会注册一个使用 以便转换器和实体侦听器可以使用常规依赖注入的实现。BeanContainerBeanFactorySpring中文文档

您可以通过注册删除或更改属性来禁用或调整此行为。HibernatePropertiesCustomizerhibernate.resource.beans.containerSpring中文文档

使用自定义 EntityManagerFactory

要完全控制 的配置，您需要添加一个名为“entityManagerFactory”的配置。 Spring Boot 自动配置会在存在该类型的 Bean 时关闭其实体管理器。EntityManagerFactory@BeanSpring中文文档

使用多个 EntityManagerFactories

如果需要对多个数据源使用 JPA，则可能需要每个数据源使用一个 JPA。 来自 Spring ORM 允许您根据需要配置一个。 您还可以重用以绑定每个 的设置，如以下示例所示：EntityManagerFactoryLocalContainerEntityManagerFactoryBeanEntityManagerFactoryJpaPropertiesEntityManagerFactorySpring中文文档

import javax.sql.DataSource;

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 MyEntityManagerFactoryConfiguration {

	@Bean
	@ConfigurationProperties("app.jpa.first")
	public JpaProperties firstJpaProperties() {
		return new JpaProperties();
	}

	@Bean
	public LocalContainerEntityManagerFactoryBean firstEntityManagerFactory(DataSource firstDataSource,
			JpaProperties firstJpaProperties) {
		EntityManagerFactoryBuilder builder = createEntityManagerFactoryBuilder(firstJpaProperties);
		return builder.dataSource(firstDataSource).packages(Order.class).persistenceUnit("firstDs").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.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 MyEntityManagerFactoryConfiguration {

	@Bean
	@ConfigurationProperties("app.jpa.first")
	fun firstJpaProperties(): JpaProperties {
		return JpaProperties()
	}

	@Bean
	fun firstEntityManagerFactory(
		firstDataSource: DataSource?,
		firstJpaProperties: JpaProperties
	): LocalContainerEntityManagerFactoryBean {
		val builder = createEntityManagerFactoryBuilder(firstJpaProperties)
		return builder.dataSource(firstDataSource).packages(Order::class.java).persistenceUnit("firstDs").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()
	}

}

上面的示例使用名为 的 Bean 创建一个 。 它扫描与 . 位于同一包中的实体。 可以使用命名空间映射其他 JPA 属性。EntityManagerFactoryDataSourcefirstDataSourceOrderapp.first.jpaSpring中文文档

当您为自己创建 Bean 时，在创建自动配置期间应用的任何自定义设置都将丢失。 例如，在 Hibernate 的情况下，前缀下的任何属性都不会自动应用于 . 如果您依赖这些属性来配置命名策略或 DDL 模式等内容，则需要在创建 Bean 时显式配置它。LocalContainerEntityManagerFactoryBeanLocalContainerEntityManagerFactoryBeanspring.jpa.hibernateLocalContainerEntityManagerFactoryBeanLocalContainerEntityManagerFactoryBean

您应该为需要 JPA 访问的任何其他数据源提供类似的配置。 要完成图片，您还需要为每个图片配置一个。 或者，您可以使用跨两者的 JTA 事务管理器。JpaTransactionManagerEntityManagerFactorySpring中文文档

如果使用 Spring Data，则需要进行相应的配置，如以下示例所示：@EnableJpaRepositoriesSpring中文文档

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

@Configuration(proxyBeanMethods = false)
@EnableJpaRepositories(basePackageClasses = Order.class, entityManagerFactoryRef = "firstEntityManagerFactory")
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
当您为自己创建 Bean 时，在创建自动配置期间应用的任何自定义设置都将丢失。 例如，在 Hibernate 的情况下，前缀下的任何属性都不会自动应用于 . 如果您依赖这些属性来配置命名策略或 DDL 模式等内容，则需要在创建 Bean 时显式配置它。LocalContainerEntityManagerFactoryBeanLocalContainerEntityManagerFactoryBeanspring.jpa.hibernateLocalContainerEntityManagerFactoryBeanLocalContainerEntityManagerFactoryBean

使用传统 persistence.xml 文件

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

有关默认设置，请参阅 JpaBaseConfiguration。Spring中文文档

使用 Spring Data JPA 和 Mongo 存储库

Spring Data JPA 和 Spring Data Mongo 都可以自动为您创建实现。 如果它们都存在于类路径上，则可能需要进行一些额外的配置才能告诉Spring Boot要创建哪些存储库。 最明确的方法是使用标准的 Spring Data 和注释，并提供接口的位置。Repository@EnableJpaRepositories@EnableMongoRepositoriesRepositorySpring中文文档

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

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

自定义 Spring Data 的 Web 支持

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

将 Spring 数据存储库公开为 REST 端点

Spring Data REST可以将实现公开为REST端点， 前提是已为应用程序启用 Spring MVC。RepositorySpring中文文档

Spring Boot 公开了一组有用的属性（来自命名空间），用于自定义 RepositoryRestConfiguration。 如果需要提供其他定制，则应使用 RepositoryRestConfigurer bean。spring.data.restSpring中文文档

如果您没有在自定义上指定任何顺序，它将在Spring Boot内部使用的顺序之后运行。 如果需要指定订单，请确保它高于 0。RepositoryRestConfigurer
如果您没有在自定义上指定任何顺序，它将在Spring Boot内部使用的顺序之后运行。 如果需要指定订单，请确保它高于 0。RepositoryRestConfigurer

配置 JPA 使用的组件

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

如果要自己配置组件，则可以使用子类作为设置必要依赖项的便捷方式。 例如，如果您将 Hibernate Search 与 Elasticsearch 结合使用作为其索引管理器，则必须将所有 Bean 配置为依赖于 Bean，如以下示例所示：EntityManagerFactoryDependsOnPostProcessorEntityManagerFactoryelasticsearchClientSpring中文文档

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中文文档

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