Replace "via" with words more suited to an international audience

See gh-28464

spring-boot-project/spring-boot-docs/src/docs/asciidoc/actuator/metrics.adoc

@@ -434,7 +434,11 @@ You can also change the interval at which metrics are sent to New Relic:
 	        step: "30s"
 ----
 
+<<<<<<< HEAD
 By default, metrics are published through REST calls, but you can also use the Java Agent API if you have it on the classpath:
+=======
+By default, metrics are published through REST calls but it is also possible to use the Java Agent API if you have it on the classpath:
+>>>>>>> Replace "via" with English words
 
 [source,yaml,indent=0,subs="verbatim",configprops,configblocks]
 ----

spring-boot-project/spring-boot-docs/src/docs/asciidoc/data/sql.adoc

@@ -425,7 +425,7 @@ You can also create your own `org.jooq.Configuration` `@Bean` if you want to tak
 === Using R2DBC
 The Reactive Relational Database Connectivity (https://r2dbc.io[R2DBC]) project brings reactive programming APIs to relational databases.
 R2DBC's `io.r2dbc.spi.Connection` provides a standard method of working with non-blocking database connections.
-Connections are provided via a `ConnectionFactory`, similar to a `DataSource` with jdbc.
+Connections are provided by using a `ConnectionFactory`, similar to a `DataSource` with jdbc.
 
 `ConnectionFactory` configuration is controlled by external configuration properties in `+spring.r2dbc.*+`.
 For example, you might declare the following section in `application.properties`:

spring-boot-project/spring-boot-docs/src/docs/asciidoc/deployment/cloud.adoc

@@ -122,7 +122,7 @@ Because this shutdown processing happens in parallel (and due to the nature of d
 
 You can configure a sleep execution in a preStop handler to avoid requests being routed to a pod that has already begun shutting down.
 This sleep should be long enough for new requests to stop being routed to the pod and its duration will vary from deployment to deployment.
-The preStop handler can be configured via the PodSpec in the pod's configuration file as follows:
+The preStop handler can be configured by using the PodSpec in the pod's configuration file as follows:
 
 [source,yml,indent=0,subs="verbatim"]
 ----

spring-boot-project/spring-boot-docs/src/docs/asciidoc/documentation/container-images.adoc

@@ -4,4 +4,4 @@ Spring Boot provides first-class support for building efficient container images
 
 * *Efficient Container Images:* <<container-images#container-images.efficient-images, Tips to optimize container images such as Docker images>>
 * *Dockerfiles:* <<container-images#container-images.dockerfiles, Building container images using dockerfiles>>
-* *Cloud Native Buildpacks:* <<container-images#container-images.buildpacks, Support for Cloud Native Buildpacks via Maven and Gradle>>
+* *Cloud Native Buildpacks:* <<container-images#container-images.buildpacks, Support for Cloud Native Buildpacks with Maven and Gradle>>

spring-boot-project/spring-boot-docs/src/docs/asciidoc/documentation/messaging.adoc

@@ -2,8 +2,8 @@
 == Messaging
 If your application uses any messaging protocol, check out this section:
 
-* *JMS:* <<messaging#messaging.jms, Auto-configuration for ActiveMQ and Artemis, Sending and Receiving messages via JMS>>
+* *JMS:* <<messaging#messaging.jms, Auto-configuration for ActiveMQ and Artemis, Sending and Receiving messages through JMS>>
 * *AMQP:* <<messaging#messaging.amqp, Auto-configuration for RabbitMQ>>
 * *Kafka:* <<messaging#messaging.kafka, Auto-configuration for Spring Kafka>>
 * *RSocket:* <<messaging#messaging.rsocket, Auto-configuration for Spring Framework's RSocket Support>>
-* *Spring Integration:* <<messaging#messaging.spring-integration, Auto-configuration for Spring Integration>>
+* *Spring Integration:* <<messaging#messaging.spring-integration, Auto-configuration for Spring Integration>>

spring-boot-project/spring-boot-docs/src/docs/asciidoc/features/external-config.adoc

@@ -675,7 +675,7 @@ The preceding POJO defines the following properties:
 * `my.service.security.password`.
 * `my.service.security.roles`, with a collection of `String` that defaults to `USER`.
 
-NOTE: The properties that map to `@ConfigurationProperties` classes available in Spring Boot, which are configured via properties files, YAML files, environment variables, etc., are public API but the accessors (getters/setters) of the class itself are not meant to be used directly.
+NOTE: The properties that map to `@ConfigurationProperties` classes available in Spring Boot, which are configured through properties files, YAML files, environment variables etc., are public API but the accessors (getters/setters) of the class itself are not meant to be used directly.
 
 [NOTE]
 ====
@@ -712,7 +712,7 @@ This means that the binder will expect to find a constructor with the parameters
 If you are using Java 16 or later, constructor binding can be used with records.
 In this case, unless your record has multiple constructors, there is no need to use `@ConstructorBinding`.
 
-Nested members of a `@ConstructorBinding` class (such as `Security` in the example above) will also be bound via their constructor.
+Nested members of a `@ConstructorBinding` class (such as `Security` in the example above) will also be bound through their constructor.
 
 Default values can be specified using `@DefaultValue` and the same conversion service will be applied to coerce the `String` value to the target type of a missing property.
 By default, if no properties are bound to `Security`, the `MyProperties` instance will contain a `null` value for `security`.
@@ -725,7 +725,7 @@ include::{docs-java}/features/externalconfig/typesafeconfigurationproperties/con
 
 
 NOTE: To use constructor binding the class must be enabled using `@EnableConfigurationProperties` or configuration property scanning.
-You cannot use constructor binding with beans that are created by the regular Spring mechanisms (for example `@Component` beans, beans created via `@Bean` methods or beans loaded using `@Import`)
+You cannot use constructor binding with beans that are created by the regular Spring mechanisms (e.g. `@Component` beans, beans created by using `@Bean` methods or beans loaded by using `@Import`)
 
 TIP: If you have more than one constructor for your class you can also use `@ConstructorBinding` directly on the constructor that should be bound.
 
@@ -761,7 +761,7 @@ include::{docs-java}/features/externalconfig/typesafeconfigurationproperties/ena
 
 [NOTE]
 ====
-When the `@ConfigurationProperties` bean is registered using configuration property scanning or via `@EnableConfigurationProperties`, the bean has a conventional name: `<prefix>-<fqn>`, where `<prefix>` is the environment key prefix specified in the `@ConfigurationProperties` annotation and `<fqn>` is the fully qualified name of the bean.
+When the `@ConfigurationProperties` bean is registered using configuration property scanning or through `@EnableConfigurationProperties`, the bean has a conventional name: `<prefix>-<fqn>`, where `<prefix>` is the environment key prefix specified in the `@ConfigurationProperties` annotation and `<fqn>` is the fully qualified name of the bean.
 If the annotation does not provide any prefix, only the fully qualified name of the bean is used.
 
 The bean name in the example above is `com.example.app-com.example.app.SomeProperties`.
@@ -1215,4 +1215,4 @@ Doing so will provide you with structured, type-safe object that you can inject
 
 `SpEL` expressions from  <<features#features.external-config.files,application property files>> are not processed at time of parsing these files and populating the environment.
 However, it is possible to write a `SpEL` expression in `@Value`.
-If the value of a property from an application property file is a `SpEL` expression, it will be evaluated when consumed via `@Value`.
+If the value of a property from an application property file is a `SpEL` expression, it will be evaluated when consumed through `@Value`.

spring-boot-project/spring-boot-docs/src/docs/asciidoc/features/kotlin.adoc

@@ -6,14 +6,14 @@ Spring Boot provides Kotlin support by leveraging the support in other Spring pr
 See the {spring-framework-docs}/languages.html#kotlin[Spring Framework Kotlin support documentation] for more information.
 
 The easiest way to start with Spring Boot and Kotlin is to follow https://spring.io/guides/tutorials/spring-boot-kotlin/[this comprehensive tutorial].
-You can create new Kotlin projects via https://start.spring.io/#!language=kotlin[start.spring.io].
+You can create new Kotlin projects by using https://start.spring.io/#!language=kotlin[start.spring.io].
 Feel free to join the #spring channel of https://slack.kotlinlang.org/[Kotlin Slack] or ask a question with the `spring` and `kotlin` tags on https://stackoverflow.com/questions/tagged/spring+kotlin[Stack Overflow] if you need support.
 
 
 
 [[features.kotlin.requirements]]
 === Requirements
-Spring Boot requires at least Kotlin 1.3.x and manages a suitable Kotlin version via dependency management.
+Spring Boot requires at least Kotlin 1.3.x and manages a suitable Kotlin version through dependency management.
 To use Kotlin, `org.jetbrains.kotlin:kotlin-stdlib` and `org.jetbrains.kotlin:kotlin-reflect` must be present on the classpath.
 The `kotlin-stdlib` variants `kotlin-stdlib-jdk7` and `kotlin-stdlib-jdk8` can also be used.
 
@@ -34,7 +34,7 @@ It deals with `null` values at compile time rather than deferring the problem to
 This helps to eliminate a common source of bugs without paying the cost of wrappers like `Optional`.
 Kotlin also allows using functional constructs with nullable values as described in this https://www.baeldung.com/kotlin-null-safety[comprehensive guide to null-safety in Kotlin].
 
-Although Java does not allow one to express null-safety in its type system, Spring Framework, Spring Data, and Reactor now provide null-safety of their API via tooling-friendly annotations.
+Although Java does not allow one to express null-safety in its type system, Spring Framework, Spring Data, and Reactor now provide null-safety of their API through tooling-friendly annotations.
 By default, types from Java APIs used in Kotlin are recognized as {kotlin-docs}java-interop.html#null-safety-and-platform-types[platform types] for which null-checks are relaxed.
 {kotlin-docs}java-interop.html#jsr-305-support[Kotlin's support for JSR 305 annotations] combined with nullability annotations provide null-safety for the related Spring API in Kotlin.
 
@@ -96,11 +96,11 @@ Among other things, the extensions make it possible to take advantage of Kotlin
 === Dependency management
 In order to avoid mixing different versions of Kotlin dependencies on the classpath, Spring Boot imports the Kotlin BOM.
 
-With Maven, the Kotlin version can be customized via the `kotlin.version` property and plugin management is provided for `kotlin-maven-plugin`.
+With Maven, the Kotlin version can be customized by setting the `kotlin.version` property and plugin management is provided for `kotlin-maven-plugin`.
 With Gradle, the Spring Boot plugin automatically aligns the `kotlin.version` with the version of the Kotlin plugin.
 
 Spring Boot also manages the version of Coroutines dependencies by importing the Kotlin Coroutines BOM.
-The version can be customized via the `kotlin-coroutines.version` property.
+The version can be customized by setting the `kotlin-coroutines.version` property.
 
 TIP: `org.jetbrains.kotlinx:kotlinx-coroutines-reactor` dependency is provided by default if one bootstraps a Kotlin project with at least one reactive dependency on https://start.spring.io/#!language=kotlin[start.spring.io].
 

spring-boot-project/spring-boot-docs/src/docs/asciidoc/features/logging.adoc

@@ -11,7 +11,7 @@ TIP: There are a lot of logging frameworks available for Java.
 Do not worry if the above list seems confusing.
 Generally, you do not need to change your logging dependencies and the Spring Boot defaults work just fine.
 
-TIP: When you deploy your application to a servlet container or application server, logging performed via the Java Util Logging API is not routed into your application's logs.
+TIP: When you deploy your application to a servlet container or application server, logging performed with the Java Util Logging API is not routed into your application's logs.
 This prevents logging performed by the container or other applications that have been deployed to it from appearing in your application's logs.
 
 
@@ -288,7 +288,7 @@ The value should be the fully qualified class name of a `LoggingSystem` implemen
 You can also disable Spring Boot's logging configuration entirely by using a value of `none`.
 
 NOTE: Since logging is initialized *before* the `ApplicationContext` is created, it is not possible to control logging from `@PropertySources` in Spring `@Configuration` files.
-The only way to change the logging system or disable it entirely is via System properties.
+The only way to change the logging system or disable it entirely is through System properties.
 
 Depending on your logging system, the following files are loaded:
 

spring-boot-project/spring-boot-docs/src/docs/asciidoc/features/profiles.adoc

@@ -8,7 +8,7 @@ Any `@Component`, `@Configuration` or `@ConfigurationProperties` can be marked w
 include::{docs-java}/features/profiles/ProductionConfiguration.java[]
 ----
 
-NOTE: If `@ConfigurationProperties` beans are registered via `@EnableConfigurationProperties` instead of automatic scanning, the `@Profile` annotation needs to be specified on the `@Configuration` class that has the `@EnableConfigurationProperties` annotation.
+NOTE: If `@ConfigurationProperties` beans are registered through `@EnableConfigurationProperties` instead of automatic scanning, the `@Profile` annotation needs to be specified on the `@Configuration` class that has the `@EnableConfigurationProperties` annotation.
 In the case where `@ConfigurationProperties` are scanned, `@Profile` can be specified on the `@ConfigurationProperties` class itself.
 
 You can use a configprop:spring.profiles.active[] `Environment` property to specify which profiles are active.

spring-boot-project/spring-boot-docs/src/docs/asciidoc/features/testing.adoc

@@ -438,11 +438,11 @@ include::{docs-java}/features/testing/springbootapplications/springwebfluxtests/
 
 TIP: This setup is only supported by WebFlux applications as using `WebTestClient` in a mocked web application only works with WebFlux at the moment.
 
-NOTE: `@WebFluxTest` cannot detect routes registered via the functional web framework.
-For testing `RouterFunction` beans in the context, consider importing your `RouterFunction` yourself via `@Import` or using `@SpringBootTest`.
+NOTE: `@WebFluxTest` cannot detect routes registered through the functional web framework.
+For testing `RouterFunction` beans in the context, consider importing your `RouterFunction` yourself by using `@Import` or by using `@SpringBootTest`.
 
-NOTE: `@WebFluxTest` cannot detect custom security configuration registered via a `@Bean` of type `SecurityWebFilterChain`.
-To include that in your test, you will need to import the configuration that registers the bean via `@Import` or use `@SpringBootTest`.
+NOTE: `@WebFluxTest` cannot detect custom security configuration registered as a `@Bean` of type `SecurityWebFilterChain`.
+To include that in your test, you will need to import the configuration that registers the bean by using `@Import` or by using `@SpringBootTest`.
 
 TIP: Sometimes writing Spring WebFlux tests is not enough; Spring Boot can help you run <<features#features.testing.spring-boot-applications.with-running-server, full end-to-end tests with an actual server>>.
 
@@ -966,7 +966,7 @@ include::{docs-java}/features/testing/utilities/outputcapture/MyOutputCaptureTes
 You can get a vanilla template or one that sends Basic HTTP authentication (with a username and password).
 In either case, the template is fault tolerant.
 This means that it behaves in a test-friendly way by not throwing exceptions on 4xx and 5xx errors.
-Instead, such errors can be detected via the returned `ResponseEntity` and its status code.
+Instead, such errors can be detected through the returned `ResponseEntity` and its status code.
 
 TIP: Spring Framework 5.0 provides a new `WebTestClient` that works for <<features#features.testing.spring-boot-applications.spring-webflux-tests, WebFlux integration tests>> and both <<features#features.testing.spring-boot-applications.with-running-server, WebFlux and MVC end-to-end testing>>.
 It provides a fluent API for assertions, unlike `TestRestTemplate`.

spring-boot-project/spring-boot-docs/src/docs/asciidoc/howto/actuator.adoc

@@ -61,7 +61,7 @@ Alternatively, additional patterns can be configured using configprop:management
 [[howto.actuator.map-health-indicators-to-metrics]]
 === Map Health Indicators to Micrometer Metrics
 Spring Boot health indicators return a `Status` type to indicate the overall system health.
-If you want to monitor or alert on levels of health for a particular application, you can export these statuses as metrics via Micrometer.
+If you want to monitor or alert on levels of health for a particular application, you can export these statuses as metrics with Micrometer.
 By default, the status codes "`UP`", "`DOWN`", "`OUT_OF_SERVICE`" and "`UNKNOWN`" are used by Spring Boot.
 To export these, you will need to convert these states to some set of numbers so that they can be used with a Micrometer `Gauge`.
 

spring-boot-project/spring-boot-docs/src/docs/asciidoc/howto/webserver.adoc

@@ -469,7 +469,7 @@ include::{docs-java}/howto/webserver/usetomcatlegacycookieprocessor/MyLegacyCook
 === Enable Tomcat's MBean Registry
 Embedded Tomcat's MBean registry is disabled by default.
 This minimizes Tomcat's memory footprint.
-If you want to use Tomcat's MBeans, for example so that they can be used to expose metrics via Micrometer, you must use the configprop:server.tomcat.mbeanregistry.enabled[] property to do so, as shown in the following example:
+If you want to use Tomcat's MBeans, for example so that they can be used by Micrometer to expose metrics, you must use the configprop:server.tomcat.mbeanregistry.enabled[] property to do so, as shown in the following example:
 
 [source,yaml,indent=0,subs="verbatim",configprops,configblocks]
 ----

spring-boot-project/spring-boot-docs/src/docs/asciidoc/io/caching.adoc

@@ -3,7 +3,7 @@
 The Spring Framework provides support for transparently adding caching to an application.
 At its core, the abstraction applies caching to methods, thus reducing the number of executions based on the information available in the cache.
 The caching logic is applied transparently, without any interference to the invoker.
-Spring Boot auto-configures the cache infrastructure as long as caching support is enabled via the `@EnableCaching` annotation.
+Spring Boot auto-configures the cache infrastructure as long as caching support is enabled by using the `@EnableCaching` annotation.
 
 NOTE: Check the {spring-framework-docs}/integration.html#cache[relevant section] of the Spring Framework reference for more details.
 

spring-boot-project/spring-boot-docs/src/docs/asciidoc/io/quartz.adoc

@@ -44,7 +44,7 @@ To enable overwriting existing job definitions set the configprop:spring.quartz.
 Quartz Scheduler configuration can be customized using `spring.quartz` properties and `SchedulerFactoryBeanCustomizer` beans, which allow programmatic `SchedulerFactoryBean` customization.
 Advanced Quartz configuration properties can be customized using `spring.quartz.properties.*`.
 
-NOTE: In particular, an `Executor` bean is not associated with the scheduler as Quartz offers a way to configure the scheduler via `spring.quartz.properties`.
+NOTE: In particular, an `Executor` bean is not associated with the scheduler as Quartz offers a way to configure the scheduler through `spring.quartz.properties`.
 If you need to customize the task executor, consider implementing `SchedulerFactoryBeanCustomizer`.
 
 Jobs can define setters to inject data map properties.

spring-boot-project/spring-boot-docs/src/docs/asciidoc/messaging/kafka.adoc

@@ -60,7 +60,7 @@ TIP: A custom `ChainedKafkaTransactionManager` must be marked `@Primary` as it u
 [[messaging.kafka.streams]]
 === Kafka Streams
 Spring for Apache Kafka provides a factory bean to create a `StreamsBuilder` object and manage the lifecycle of its streams.
-Spring Boot auto-configures the required `KafkaStreamsConfiguration` bean as long as `kafka-streams` is on the classpath and Kafka Streams is enabled via the `@EnableKafkaStreams` annotation.
+Spring Boot auto-configures the required `KafkaStreamsConfiguration` bean as long as `kafka-streams` is on the classpath and Kafka Streams is enabled by the `@EnableKafkaStreams` annotation.
 
 Enabling Kafka Streams means that the application id and bootstrap servers must be set.
 The former can be configured using `spring.kafka.streams.application-id`, defaulting to `spring.application.name` if not set.

spring-boot-project/spring-boot-docs/src/docs/asciidoc/messaging/rsocket.adoc

@@ -1,7 +1,7 @@
 [[messaging.rsocket]]
 == RSocket
 https://rsocket.io[RSocket] is a binary protocol for use on byte stream transports.
-It enables symmetric interaction models via async message passing over a single connection.
+It enables symmetric interaction models through async message passing over a single connection.
 
 
 The `spring-messaging` module of the Spring Framework provides support for RSocket requesters and responders, both on the client and on the server side.

spring-boot-project/spring-boot-docs/src/docs/asciidoc/web/spring-security.adoc

@@ -209,7 +209,7 @@ The same properties are applicable for both servlet and reactive applications.
 
 Alternatively, you can define your own `JwtDecoder` bean for servlet applications or a `ReactiveJwtDecoder` for reactive applications.
 
-In cases where opaque tokens are used instead of JWTs, you can configure the following properties to validate tokens via introspection:
+In cases where opaque tokens are used instead of JWTs, you can configure the following properties to validate tokens through introspection:
 
 [source,yaml,indent=0,subs="verbatim",configprops,configblocks]
 ----