Replace 'e.g.' with 'for example' in documentation and comments

Closes gh-33515

CONTRIBUTING.md

@@ -86,7 +86,7 @@ multiple edits or corrections of the same logical change. See
 for an overview of streamlining the commit history.
 
 1. Format commit messages using 55 characters for the subject line, 72 characters per line
-for the description, followed by the issue fixed, e.g. `Closes gh-22276`. See the
+for the description, followed by the issue fixed, for example, `Closes gh-22276`. See the
 [Commit Guidelines section of Pro Git](https://git-scm.com/book/en/Distributed-Git-Contributing-to-a-Project#Commit-Guidelines)
 for best practices around commit messages, and use `git log` to see some examples.
 

framework-docs/modules/ROOT/pages/core/aop/ataspectj/introductions.adoc

@@ -9,7 +9,7 @@ You can make an introduction by using the `@DeclareParents` annotation. This ann
 is used to declare that matching types have a new parent (hence the name). For example,
 given an interface named `UsageTracked` and an implementation of that interface named
 `DefaultUsageTracked`, the following aspect declares that all implementors of service
-interfaces also implement the `UsageTracked` interface (e.g. for statistics via JMX):
+interfaces also implement the `UsageTracked` interface (for example, for statistics via JMX):
 
 [tabs]
 ======

framework-docs/modules/ROOT/pages/core/aop/introduction-defn.adoc

@@ -65,7 +65,7 @@ with less potential for errors. For example, you do not need to invoke the `proc
 method on the `JoinPoint` used for around advice, and, hence, you cannot fail to invoke it.
 
 All advice parameters are statically typed so that you work with advice parameters of
-the appropriate type (e.g. the type of the return value from a method execution) rather
+the appropriate type (for example, the type of the return value from a method execution) rather
 than `Object` arrays.
 
 The concept of join points matched by pointcuts is the key to AOP, which distinguishes

framework-docs/modules/ROOT/pages/core/beans/annotation-config.adoc

@@ -20,7 +20,7 @@ can be found in the xref:core/beans/standard-annotations.adoc[relevant section].
 [NOTE]
 ====
 Annotation injection is performed before external property injection. Thus, external
-configuration (e.g. XML-specified bean properties) effectively overrides the annotations
+configuration (for example, XML-specified bean properties) effectively overrides the annotations
 for properties when wired through mixed approaches.
 ====
 

framework-docs/modules/ROOT/pages/core/beans/context-introduction.adoc

@@ -484,7 +484,7 @@ You can register as many event listeners as you wish, but note that, by default,
 This means that the `publishEvent()` method blocks until all listeners have finished processing the event.
 One advantage of this synchronous and single-threaded approach is that, when a listener receives an event,
 it operates inside the transaction context of the publisher if a transaction context is available.
-If another strategy for event publication becomes necessary, e.g. asynchronous event processing by default,
+If another strategy for event publication becomes necessary, for example, asynchronous event processing by default,
 see the javadoc for Spring's {spring-framework-api}/context/event/ApplicationEventMulticaster.html[`ApplicationEventMulticaster`] interface
 and {spring-framework-api}/context/event/SimpleApplicationEventMulticaster.html[`SimpleApplicationEventMulticaster`] implementation
 for configuration options which can be applied to a custom "applicationEventMulticaster" bean definition.
@@ -864,7 +864,7 @@ Finally, as with classic `ApplicationListener` implementations, the actual multi
 happens via a context-wide `ApplicationEventMulticaster` at runtime. By default, this is a
 `SimpleApplicationEventMulticaster` with synchronous event publication in the caller thread.
 This can be replaced/customized through an "applicationEventMulticaster" bean definition,
-e.g. for processing all events asynchronously and/or for handling listener exceptions:
+for example, for processing all events asynchronously and/or for handling listener exceptions:
 
 [source,java,indent=0,subs="verbatim,quotes"]
 ----

framework-docs/modules/ROOT/pages/core/beans/factory-nature.adoc

@@ -144,7 +144,7 @@ based on the given configuration but no further activity with external bean acce
 Otherwise there is a risk for an initialization deadlock.
 
 For a scenario where expensive post-initialization activity is to be triggered,
-e.g. asynchronous database preparation steps, your bean should either implement
+for example, asynchronous database preparation steps, your bean should either implement
 `SmartInitializingSingleton.afterSingletonsInstantiated()` or rely on the context
 refresh event: implementing `ApplicationListener<ContextRefreshedEvent>` or
 declaring its annotation equivalent `@EventListener(ContextRefreshedEvent.class)`.
@@ -607,7 +607,7 @@ bean creation phase and its subsequent initial publication, they need to be decl
 `volatile` or guarded by a common lock whenever accessed.
 
 Note that concurrent access to such configuration state in singleton bean instances,
-e.g. for controller instances or repository instances, is perfectly thread-safe after
+for example, for controller instances or repository instances, is perfectly thread-safe after
 such safe initial publication from the container side. This includes common singleton
 `FactoryBean` instances which are processed within the general singleton lock as well.
 
@@ -617,7 +617,7 @@ structures (or in `volatile` fields for simple cases) as per common Java guideli
 
 Deeper `Lifecycle` integration as shown above involves runtime-mutable state such as
 a `runnable` field which will have to be declared as `volatile`. While the common
-lifecycle callbacks follow a certain order, e.g. a start callback is guaranteed to
+lifecycle callbacks follow a certain order, for example, a start callback is guaranteed to
 only happen after full initialization and a stop callback only after an initial start,
 there is a special case with the common stop before destroy arrangement: It is strongly
 recommended that the internal state in any such bean also allows for an immediate

framework-docs/modules/ROOT/pages/core/beans/java/composing-configuration-classes.adoc

@@ -219,7 +219,7 @@ parameter-based injection, as in the preceding example.
 Avoid access to locally defined beans within a `@PostConstruct` method on the same configuration
 class. This effectively leads to a circular reference since non-static `@Bean` methods semantically
 require a fully initialized configuration class instance to be called on. With circular references
-disallowed (e.g. in Spring Boot 2.6+), this may trigger a `BeanCurrentlyInCreationException`.
+disallowed (for example, in Spring Boot 2.6+), this may trigger a `BeanCurrentlyInCreationException`.
 
 Also, be particularly careful with `BeanPostProcessor` and `BeanFactoryPostProcessor` definitions
 through `@Bean`. Those should usually be declared as `static @Bean` methods, not triggering the

framework-docs/modules/ROOT/pages/core/databuffer-codec.adoc

@@ -29,7 +29,7 @@ a `DataBuffer` implementation and that does not involve allocation.
 
 Note that WebFlux applications do not create a `DataBufferFactory` directly but instead
 access it through the `ServerHttpResponse` or the `ClientHttpRequest` on the client side.
-The type of factory depends on the underlying client or server, e.g.
+The type of factory depends on the underlying client or server, for example,
 `NettyDataBufferFactory` for Reactor Netty, `DefaultDataBufferFactory` for others.
 
 
@@ -82,7 +82,7 @@ to use the convenience methods in `DataBufferUtils` that apply release or retain
 
 `DataBufferUtils` offers a number of utility methods to operate on data buffers:
 
-* Join a stream of data buffers into a single buffer possibly with zero copy, e.g. via
+* Join a stream of data buffers into a single buffer possibly with zero copy, for example, via
 composite buffers, if that's supported by the underlying byte buffer API.
 * Turn `InputStream` or NIO `Channel` into `Flux<DataBuffer>`, and vice versa a
 `Publisher<DataBuffer>` into `OutputStream` or NIO `Channel`.

framework-docs/modules/ROOT/pages/core/validation/beans-beans.adoc

@@ -38,7 +38,7 @@ manner, but through a nested property path. That means constructor binding creat
 the target object and any objects it contains.
 
 Constructor binding supports `List`, `Map`, and array arguments either converted from
-a single string, e.g. comma-separated list, or based on indexed keys such as
+a single string, for example, comma-separated list, or based on indexed keys such as
 `accounts[2].name` or `account[KEY].name`.
 
 Binding and conversion errors are reflected in the `BindingResult` of the `DataBinder`.

framework-docs/modules/ROOT/pages/core/validation/format.adoc

@@ -318,7 +318,7 @@ Kotlin::
 The `FormatterRegistry` is an SPI for registering formatters and converters.
 `FormattingConversionService` is an implementation of `FormatterRegistry` suitable for
 most environments. You can programmatically or declaratively configure this variant
-as a Spring bean, e.g. by using `FormattingConversionServiceFactoryBean`. Because this
+as a Spring bean, for example, by using `FormattingConversionServiceFactoryBean`. Because this
 implementation also implements `ConversionService`, you can directly configure it
 for use with Spring's `DataBinder` and the Spring Expression Language (SpEL).
 

framework-docs/modules/ROOT/pages/core/validation/validator.adoc

@@ -200,7 +200,7 @@ not involving a binding process. As of 6.1, this has been simplified through a n
 `Validator.validateObject(Object)` method which is available by default now, returning
 a simple ´Errors` representation which can be inspected: typically calling `hasErrors()`
 or the new `failOnError` method for turning the error summary message into an exception
-(e.g. `validator.validateObject(myObject).failOnError(IllegalArgumentException::new)`).
+(for example, `validator.validateObject(myObject).failOnError(IllegalArgumentException::new)`).
 
 
 

framework-docs/modules/ROOT/pages/data-access/jdbc/advanced.adoc

@@ -223,7 +223,7 @@ As of 6.1.2, Spring bypasses the default `getParameterType` resolution on Postgr
 MS SQL Server. This is a common optimization to avoid further roundtrips to the DBMS just
 for parameter type resolution which is known to make a very significant difference on
 PostgreSQL and MS SQL Server specifically, in particular for batch operations. If you
-happen to see a side effect e.g. when setting a byte array to null without specific type
+happen to see a side effect, for example, when setting a byte array to null without specific type
 indication, you may explicitly set the `spring.jdbc.getParameterType.ignore=false` flag
 as a system property (see above) to restore full `getParameterType` resolution.
 

framework-docs/modules/ROOT/pages/data-access/jdbc/connections.adoc

@@ -177,7 +177,7 @@ corresponding `DataSource` proxy class for the target connection pool: see
 This is particularly useful for potentially empty transactions without actual statement
 execution (never fetching an actual resource in such a scenario), and also in front of
 a routing `DataSource` which means to take the transaction-synchronized read-only flag
-and/or isolation level into account (e.g. `IsolationLevelDataSourceRouter`).
+and/or isolation level into account (for example, `IsolationLevelDataSourceRouter`).
 
 `LazyConnectionDataSourceProxy` also provides special support for a read-only connection
 pool to use during a read-only transaction, avoiding the overhead of switching the JDBC

framework-docs/modules/ROOT/pages/data-access/orm/jpa.adoc

@@ -175,7 +175,7 @@ a context-wide `LoadTimeWeaver` by using the `@EnableLoadTimeWeaving` annotation
 `context:load-time-weaver` XML element. Such a global weaver is automatically picked up
 by all JPA `LocalContainerEntityManagerFactoryBean` instances. The following example
 shows the preferred way of setting up a load-time weaver, delivering auto-detection
-of the platform (e.g. Tomcat's weaving-capable class loader or Spring's JVM agent)
+of the platform (for example, Tomcat's weaving-capable class loader or Spring's JVM agent)
 and automatic propagation of the weaver to all weaver-aware beans:
 
 [source,xml,indent=0,subs="verbatim,quotes"]
@@ -469,7 +469,7 @@ a non-invasiveness perspective and can feel more natural to JPA developers.
 What about providing JPA resources via constructors and other `@Autowired` injection points?
 
 `EntityManagerFactory` can easily be injected via constructors and `@Autowired` fields/methods
-as long as the target is defined as a bean, e.g. via `LocalContainerEntityManagerFactoryBean`.
+as long as the target is defined as a bean, for example, via `LocalContainerEntityManagerFactoryBean`.
 The injection point matches the original `EntityManagerFactory` definition by type as-is.
 
 However, an `@PersistenceContext`-style shared `EntityManager` reference is not available for

framework-docs/modules/ROOT/pages/data-access/r2dbc.adoc

@@ -469,10 +469,10 @@ Kotlin::
 
 NOTE: R2DBC itself does not support Collection-like values. Nevertheless,
 expanding a given `List` in the example above works for named parameters
-in Spring's R2DBC support, e.g. for use in `IN` clauses as shown above.
-However, inserting or updating array-typed columns (e.g. in Postgres)
+in Spring's R2DBC support, for example, for use in `IN` clauses as shown above.
+However, inserting or updating array-typed columns (for example, in Postgres)
 requires an array type that is supported by the underlying R2DBC driver:
-typically a Java array, e.g. `String[]` to update a `text[]` column.
+typically a Java array, for example, `String[]` to update a `text[]` column.
 Do not pass `Collection<String>` or the like as an array parameter.
 
 [[r2dbc-DatabaseClient-filter]]

framework-docs/modules/ROOT/pages/data-access/transaction/declarative/annotations.adoc

@@ -250,7 +250,7 @@ the proxy are intercepted. This means that self-invocation (in effect, a method
 the target object calling another method of the target object) does not lead to an actual
 transaction at runtime even if the invoked method is marked with `@Transactional`. Also,
 the proxy must be fully initialized to provide the expected behavior, so you should not
-rely on this feature in your initialization code -- e.g. in a `@PostConstruct` method.
+rely on this feature in your initialization code -- for example, in a `@PostConstruct` method.
 
 Consider using AspectJ mode (see the `mode` attribute in the following table) if you
 expect self-invocations to be wrapped with transactions as well. In this case, there is
@@ -564,7 +564,7 @@ transaction definitions from a base class as well. This effectively overrides
 the default transaction manager choice for any unqualified base class methods.
 
 Last but not least, such a type-level bean qualifier can serve multiple purposes,
-e.g. with a value of "order" it can be used for autowiring purposes (identifying
+for example, with a value of "order" it can be used for autowiring purposes (identifying
 the order repository) as well as transaction manager selection, as long as the
 target beans for autowiring as well as the associated transaction manager
 definitions declare the same qualifier value. Such a qualifier value only needs

framework-docs/modules/ROOT/pages/data-access/transaction/declarative/tx-decl-explained.adoc

@@ -41,7 +41,7 @@ operations need to execute within the same Reactor context in the same reactive
 
 When configured with a `ReactiveTransactionManager`, all transaction-demarcated methods
 are expected to return a reactive pipeline. Void methods or regular return types need
-to be associated with a regular `PlatformTransactionManager`, e.g. through the
+to be associated with a regular `PlatformTransactionManager`, for example, through the
 `transactionManager` attribute of the corresponding `@Transactional` declarations.
 ====
 

framework-docs/modules/ROOT/pages/integration/cache/annotations.adoc

@@ -501,12 +501,12 @@ Placing this annotation on the class does not turn on any caching operation.
 An operation-level customization always overrides a customization set on `@CacheConfig`.
 Therefore, this gives three levels of customizations for each cache operation:
 
-* Globally configured, e.g. through `CachingConfigurer`: see next section.
+* Globally configured, for example, through `CachingConfigurer`: see next section.
 * At the class level, using `@CacheConfig`.
 * At the operation level.
 
 NOTE: Provider-specific settings are typically available on the `CacheManager` bean,
-e.g. on `CaffeineCacheManager`. These are effectively also global.
+for example, on `CaffeineCacheManager`. These are effectively also global.
 
 
 [[cache-annotation-enable]]

framework-docs/modules/ROOT/pages/integration/rest-clients.adoc

@@ -433,7 +433,7 @@ If no request factory is specified when the `RestClient` was built, it will use
 Otherwise, if the `java.net.http` module is loaded, it will use Java's `HttpClient`.
 Finally, it will resort to the simple default.
 
-TIP: Note that the `SimpleClientHttpRequestFactory` may raise an exception when accessing the status of a response that represents an error (e.g. 401).
+TIP: Note that the `SimpleClientHttpRequestFactory` may raise an exception when accessing the status of a response that represents an error (for example, 401).
 If this is an issue, use any of the alternative request factories.
 
 [[rest-webclient]]
@@ -966,7 +966,7 @@ method parameters:
 
 | `@RequestPart`
 | Add a request part, which may be a String (form field), `Resource` (file part),
-  Object (entity to be encoded, e.g. as JSON), `HttpEntity` (part content and headers),
+  Object (entity to be encoded, for example, as JSON), `HttpEntity` (part content and headers),
   a Spring `Part`, or Reactive Streams `Publisher` of any of the above.
 
 | `MultipartFile`

framework-docs/modules/ROOT/pages/integration/scheduling.adoc

@@ -483,7 +483,7 @@ seconds:
 ====
 When destroying the annotated bean or closing the application context, Spring Framework cancels
 scheduled tasks, which includes the next scheduled subscription to the `Publisher` as well
-as any past subscription that is still currently active (e.g. for long-running publishers
+as any past subscription that is still currently active (for example, for long-running publishers
 or even infinite publishers).
 ====
 

framework-docs/modules/ROOT/pages/languages/dynamic.adoc

@@ -10,7 +10,7 @@ objects.
 Spring's scripting support primarily targets Groovy and BeanShell. Beyond those
 specifically supported languages, the JSR-223 scripting mechanism is supported
 for integration with any JSR-223 capable language provider (as of Spring 4.2),
-e.g. JRuby.
+for example, JRuby.
 
 You can find fully working examples of where this dynamic language support can be
 immediately useful in xref:languages/dynamic.adoc#dynamic-language-scenarios[Scenarios].
@@ -179,7 +179,7 @@ Each of the supported languages has a corresponding `<lang:language/>` element:
 
 * `<lang:groovy/>` (Groovy)
 * `<lang:bsh/>` (BeanShell)
-* `<lang:std/>` (JSR-223, e.g. with JRuby)
+* `<lang:std/>` (JSR-223, for example, with JRuby)
 
 The exact attributes and child elements that are available for configuration depends on
 exactly which language the bean has been defined in (the language-specific sections

framework-docs/modules/ROOT/pages/overview.adoc

@@ -73,7 +73,7 @@ developers may choose to use instead of the Spring-specific mechanisms provided
 by the Spring Framework. Originally, those were based on common `javax` packages.
 
 As of Spring Framework 6.0, Spring has been upgraded to the Jakarta EE 9 level
-(e.g. Servlet 5.0+, JPA 3.0+), based on the `jakarta` namespace instead of the
+(for example, Servlet 5.0+, JPA 3.0+), based on the `jakarta` namespace instead of the
 traditional `javax` packages. With EE 9 as the minimum and EE 10 supported already,
 Spring is prepared to provide out-of-the-box support for the further evolution of
 the Jakarta EE APIs. Spring Framework 6.0 is fully compatible with Tomcat 10.1,

framework-docs/modules/ROOT/pages/rsocket.adoc

@@ -113,7 +113,7 @@ a natural fit to use `Flux` and `Mono` with declarative operators and transparen
 pressure support.
 
 The API in RSocket Java is intentionally minimal and basic. It focuses on protocol
-features and leaves the application programming model (e.g. RPC codegen vs other) as a
+features and leaves the application programming model (for example, RPC codegen vs other) as a
 higher level, independent concern.
 
 The main contract
@@ -271,7 +271,7 @@ Kotlin::
 ----
 ======
 
-`RSocketStrategies` is designed for re-use. In some scenarios, e.g. client and server in
+`RSocketStrategies` is designed for re-use. In some scenarios, for example, client and server in
 the same application, it may be preferable to declare it in Spring configuration.
 
 
@@ -361,7 +361,7 @@ Kotlin::
 ======
 
 For the above you may also need to use `setHandlerPredicate` in `RSocketMessageHandler` to
-switch to a different strategy for detecting client responders, e.g. based on a custom
+switch to a different strategy for detecting client responders, for example, based on a custom
 annotation such as `@RSocketClientResponder` vs the default `@Controller`. This
 is necessary in scenarios with client and server, or multiple clients in the same
 application.
@@ -798,7 +798,7 @@ use the following method arguments:
 | Requester for making requests to the remote end.
 
 | `@DestinationVariable`
-| Value extracted from the route based on variables in the mapping pattern, e.g.
+| Value extracted from the route based on variables in the mapping pattern, for example,
   pass:q[`@MessageMapping("find.radar.{id}")`].
 
 | `@Header`
@@ -955,7 +955,7 @@ xref:rsocket.adoc#rsocket-requester-server[Server Requester] for details.
 
 Responders must interpret metadata.
 {rsocket-protocol-extensions}/CompositeMetadata.md[Composite metadata] allows independently
-formatted metadata values (e.g. for routing, security, tracing) each with its own mime
+formatted metadata values (for example, for routing, security, tracing) each with its own mime
 type. Applications need a way to configure metadata mime types to support, and a way
 to access extracted values.
 

framework-docs/modules/ROOT/pages/testing/spring-mvc-test-client.adoc

@@ -193,7 +193,7 @@ Then we define expectations with two kinds of responses:
  * a response obtained through a call to the `/quoteOfTheDay` endpoint
 
 In the second case, the request is executed through the `ClientHttpRequestFactory` that was
-captured earlier. This generates a response that could e.g. come from an actual remote server,
+captured earlier. This generates a response that could, for example, come from an actual remote server,
 depending on how the `RestTemplate` was originally configured.
 
 [[spring-mvc-test-client-static-imports]]

framework-docs/modules/ROOT/pages/testing/webtestclient.adoc

@@ -403,7 +403,7 @@ Java::
 			.expectStatus().isOk()
 			.expectBody(Person.class)
 			.consumeWith(result -> {
-				// custom assertions (e.g. AssertJ)...
+				// custom assertions (for example, AssertJ)...
 			});
 ----
 
@@ -416,7 +416,7 @@ Kotlin::
 			.expectStatus().isOk()
 			.expectBody<Person>()
 			.consumeWith {
-				// custom assertions (e.g. AssertJ)...
+				// custom assertions (for example, AssertJ)...
 			}
 ----
 ======

framework-docs/modules/ROOT/pages/web/integration.adoc

@@ -103,7 +103,7 @@ on its specific integration strategies.
 
 JavaServer Faces (JSF) is the JCP's standard component-based, event-driven web
 user interface framework. It is an official part of the Jakarta EE umbrella but also
-individually usable, e.g. through embedding Mojarra or MyFaces within Tomcat.
+individually usable, for example, through embedding Mojarra or MyFaces within Tomcat.
 
 Please note that recent versions of JSF became closely tied to CDI infrastructure
 in application servers, with some new JSF functionality only working in such an

framework-docs/modules/ROOT/pages/web/webflux-webclient/client-context.adoc

@@ -3,8 +3,8 @@
 
 xref:web/webflux-webclient/client-attributes.adoc[Attributes] provide a convenient way to pass information to the filter
 chain but they only influence the current request. If you want to pass information that
-propagates to additional requests that are nested, e.g. via `flatMap`, or executed after,
-e.g. via `concatMap`, then you'll need to use the Reactor `Context`.
+propagates to additional requests that are nested, for example, via `flatMap`, or executed after,
+for example, via `concatMap`, then you'll need to use the Reactor `Context`.
 
 The Reactor `Context` needs to be populated at the end of a reactive chain in order to
 apply to all operations. For example:

framework-docs/modules/ROOT/pages/web/webflux/ann-rest-exceptions.adoc

@@ -64,7 +64,7 @@ this `Map`.
 
 You can also extend `ProblemDetail` to add dedicated non-standard properties.
 The copy constructor in `ProblemDetail` allows a subclass to make it easy to be created
-from an existing `ProblemDetail`. This could be done centrally, e.g. from an
+from an existing `ProblemDetail`. This could be done centrally, for example, from an
 `@ControllerAdvice` such as `ResponseEntityExceptionHandler` that re-creates the
 `ProblemDetail` of an exception into a subclass with the additional non-standard fields.
 
@@ -107,7 +107,7 @@ Message codes and arguments for each error are also resolved via `MessageSource`
 
 | `MissingRequestValueException`
 | (default)
-| `+{0}+` a label for the value (e.g. "request header", "cookie value", ...), `+{1}+` the value name
+| `+{0}+` a label for the value (for example, "request header", "cookie value", ...), `+{1}+` the value name
 
 | `NotAcceptableStatusException`
 | (default)

framework-docs/modules/ROOT/pages/web/webflux/config.adoc

@@ -657,7 +657,7 @@ include the version of the jar and can also match against incoming URLs without
 -- for example, from `/webjars/jquery/jquery.min.js` to `/webjars/jquery/1.2.0/jquery.min.js`.
 
 TIP: The Java configuration based on `ResourceHandlerRegistry` provides further options
-for fine-grained control, e.g. last-modified behavior and optimized resource resolution.
+for fine-grained control, for example, last-modified behavior and optimized resource resolution.
 
 
 

framework-docs/modules/ROOT/pages/web/webflux/controller/ann-methods/modelattrib-method-args.adoc

@@ -82,10 +82,10 @@ parameters. While `@BindParam` is supported out of the box, you can also use a
 different annotation by setting a `DataBinder.NameResolver` on `DataBinder`
 
 Constructor binding supports `List`, `Map`, and array arguments either converted from
-a single string, e.g. comma-separated list, or based on indexed keys such as
+a single string, for example, comma-separated list, or based on indexed keys such as
 `accounts[2].name` or `account[KEY].name`.
 
-WebFlux, unlike Spring MVC, supports reactive types in the model, e.g. `Mono<Account>`.
+WebFlux, unlike Spring MVC, supports reactive types in the model, for example, `Mono<Account>`.
 You can declare a `@ModelAttribute` argument with or without a reactive type wrapper, and
 it will be resolved accordingly to the actual value.
 

framework-docs/modules/ROOT/pages/web/webflux/controller/ann-requestmapping.adoc

@@ -343,7 +343,7 @@ You can declare a shared `produces` attribute at the class level. Unlike most ot
 mapping attributes, however, when used at the class level, a method-level `produces` attribute
 overrides rather than extend the class level declaration.
 
-TIP: `MediaType` provides constants for commonly used media types -- e.g.
+TIP: `MediaType` provides constants for commonly used media types -- for example,
 `APPLICATION_JSON_VALUE`, `APPLICATION_XML_VALUE`.
 
 

framework-docs/modules/ROOT/pages/web/webflux/dispatcher-handler.adoc

@@ -170,7 +170,7 @@ A `HandlerAdapter` may expose its exception handling mechanism as a
 
 A `HandlerAdapter` may also choose to implement `DispatchExceptionHandler`. In that case
 `DispatcherHandler` will apply it to exceptions that arise before a handler is mapped,
-e.g. during handler mapping, or earlier, e.g. in a `WebFilter`.
+for example, during handler mapping, or earlier, for example, in a `WebFilter`.
 
 See also xref:web/webflux/controller/ann-exceptions.adoc[Exceptions] in the "`Annotated Controller`" section or
 xref:web/webflux/reactive-spring.adoc#webflux-exception-handler[Exceptions] in the WebHandler API section.

framework-docs/modules/ROOT/pages/web/webflux/reactive-spring.adoc

@@ -468,7 +468,7 @@ to encode and decode HTTP message content.
 * An `Encoder` can be wrapped with `EncoderHttpMessageWriter` to adapt it for use in a web
 application, while a `Decoder` can be wrapped with `DecoderHttpMessageReader`.
 * {spring-framework-api}/core/io/buffer/DataBuffer.html[`DataBuffer`] abstracts different
-byte buffer representations (e.g. Netty `ByteBuf`, `java.nio.ByteBuffer`, etc.) and is
+byte buffer representations (for example, Netty `ByteBuf`, `java.nio.ByteBuffer`, etc.) and is
 what all codecs work on. See xref:core/databuffer-codec.adoc[Data Buffers and Codecs] in the
 "Spring Core" section for more on this topic.
 
@@ -493,8 +493,8 @@ The `Jackson2Decoder` works as follows:
 * Jackson's asynchronous, non-blocking parser is used to aggregate a stream of byte chunks
 into ``TokenBuffer``'s each representing a JSON object.
 * Each `TokenBuffer` is passed to Jackson's `ObjectMapper` to create a higher level object.
-* When decoding to a single-value publisher (e.g. `Mono`), there is one `TokenBuffer`.
-* When decoding to a multi-value publisher (e.g. `Flux`), each `TokenBuffer` is passed to
+* When decoding to a single-value publisher (for example, `Mono`), there is one `TokenBuffer`.
+* When decoding to a multi-value publisher (for example, `Flux`), each `TokenBuffer` is passed to
 the `ObjectMapper` as soon as enough bytes are received for a fully formed object. The
 input content can be a JSON array, or any
 https://en.wikipedia.org/wiki/JSON_streaming[line-delimited JSON] format such as NDJSON,
@@ -502,7 +502,7 @@ JSON Lines, or JSON Text Sequences.
 
 The `Jackson2Encoder` works as follows:
 
-* For a single value publisher (e.g. `Mono`), simply serialize it through the
+* For a single value publisher (for example, `Mono`), simply serialize it through the
 `ObjectMapper`.
 * For a multi-value publisher with `application/json`, by default collect the values with
 `Flux#collectToList()` and then serialize the resulting collection.

framework-docs/modules/ROOT/pages/web/webmvc-cors.adoc

@@ -88,7 +88,7 @@ class- or method-level `@CrossOrigin` annotations (other handlers can implement
 
 The rules for combining global and local configuration are generally additive -- for example,
 all global and all local origins. For those attributes where only a single value can be
-accepted, e.g. `allowCredentials` and `maxAge`, the local overrides the global value. See
+accepted, for example, `allowCredentials` and `maxAge`, the local overrides the global value. See
 {spring-framework-api}/web/cors/CorsConfiguration.html#combine-org.springframework.web.cors.CorsConfiguration-[`CorsConfiguration#combine(CorsConfiguration)`]
 for more details.
 

framework-docs/modules/ROOT/pages/web/webmvc/mvc-ann-rest-exceptions.adoc

@@ -64,7 +64,7 @@ this `Map`.
 
 You can also extend `ProblemDetail` to add dedicated non-standard properties.
 The copy constructor in `ProblemDetail` allows a subclass to make it easy to be created
-from an existing `ProblemDetail`. This could be done centrally, e.g. from an
+from an existing `ProblemDetail`. This could be done centrally, for example, from an
 `@ControllerAdvice` such as `ResponseEntityExceptionHandler` that re-creates the
 `ProblemDetail` of an exception into a subclass with the additional non-standard fields.
 

framework-docs/modules/ROOT/pages/web/webmvc/mvc-config/static-resources.adoc

@@ -58,7 +58,7 @@ include the version of the jar and can also match against incoming URLs without
 -- for example, from `/webjars/jquery/jquery.min.js` to `/webjars/jquery/1.2.0/jquery.min.js`.
 
 TIP: The Java configuration based on `ResourceHandlerRegistry` provides further options
-for fine-grained control, e.g. last-modified behavior and optimized resource resolution.
+for fine-grained control, for example, last-modified behavior and optimized resource resolution.
 
 
 

framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-exceptionhandler.adoc

@@ -13,8 +13,8 @@ include-code::./SimpleController[indent=0]
 [[mvc-ann-exceptionhandler-exc]]
 == Exception Mapping
 
-The exception may match against a top-level exception being propagated (e.g. a direct
-`IOException` being thrown) or against a nested cause within a wrapper exception (e.g.
+The exception may match against a top-level exception being propagated (for example, a direct
+`IOException` being thrown) or against a nested cause within a wrapper exception (for example,
 an `IOException` wrapped inside an `IllegalStateException`). As of 5.3, this can match
 at arbitrary cause levels, whereas previously only an immediate cause was considered.
 

framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-methods/modelattrib-method-args.adoc

@@ -117,7 +117,7 @@ parameters. While `@BindParam` is supported out of the box, you can also use a
 different annotation by setting a `DataBinder.NameResolver` on `DataBinder`
 
 Constructor binding supports `List`, `Map`, and array arguments either converted from
-a single string, e.g. comma-separated list, or based on indexed keys such as
+a single string, for example, comma-separated list, or based on indexed keys such as
 `accounts[2].name` or `account[KEY].name`.
 
 In some cases, you may want access to a model attribute without data binding. For such

framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-methods/responsebody.adoc

@@ -42,7 +42,7 @@ content of the provided resource to the response `OutputStream`. Note that the
 `InputStream` should be lazily retrieved by the `Resource` handle in order to reliably
 close it after it has been copied to the response. If you are using `InputStreamResource`
 for such a purpose, make sure to construct it with an on-demand `InputStreamSource`
-(e.g. through a lambda expression that retrieves the actual `InputStream`).
+(for example, through a lambda expression that retrieves the actual `InputStream`).
 
 You can use `@ResponseBody` with reactive types.
 See xref:web/webmvc/mvc-ann-async.adoc[Asynchronous Requests] and xref:web/webmvc/mvc-ann-async.adoc#mvc-ann-async-reactive-types[Reactive Types] for more details.

framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-methods/responseentity.adoc

@@ -33,14 +33,14 @@ Kotlin::
 ======
 
 The body will usually be provided as a value object to be rendered to a corresponding
-response representation (e.g. JSON) by one of the registered `HttpMessageConverters`.
+response representation (for example, JSON) by one of the registered `HttpMessageConverters`.
 
 A `ResponseEntity<Resource>` can be returned for file content, copying the `InputStream`
 content of the provided resource to the response `OutputStream`. Note that the
 `InputStream` should be lazily retrieved by the `Resource` handle in order to reliably
 close it after it has been copied to the response. If you are using `InputStreamResource`
 for such a purpose, make sure to construct it with an on-demand `InputStreamSource`
-(e.g. through a lambda expression that retrieves the actual `InputStream`). Also, custom
+(for example, through a lambda expression that retrieves the actual `InputStream`). Also, custom
 subclasses of `InputStreamResource` are only supported in combination with a custom
 `contentLength()` implementation which avoids consuming the stream for that purpose.
 

framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-methods/return-types.adoc

@@ -93,9 +93,9 @@ supported for all return values.
   `ResponseEntity`. See xref:web/webmvc/mvc-ann-async.adoc[Asynchronous Requests] and xref:web/webmvc/mvc-ann-async.adoc#mvc-ann-async-http-streaming[HTTP Streaming].
 
 | Reactor and other reactive types registered via `ReactiveAdapterRegistry`
-| A single value type, e.g. `Mono`, is comparable to returning `DeferredResult`.
-  A multi-value type, e.g. `Flux`, may be treated as a stream depending on the requested
-  media type, e.g. "text/event-stream", "application/json+stream", or otherwise is
+| A single value type, for example, `Mono`, is comparable to returning `DeferredResult`.
+  A multi-value type, for example, `Flux`, may be treated as a stream depending on the requested
+  media type, for example, "text/event-stream", "application/json+stream", or otherwise is
   collected to a List and rendered as a single value. See xref:web/webmvc/mvc-ann-async.adoc[Asynchronous Requests] and
   xref:web/webmvc/mvc-ann-async.adoc#mvc-ann-async-reactive-types[Reactive Types].
 

framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-methods/typeconversion.adoc

@@ -26,7 +26,7 @@ method intends to accept a null value as well, either declare your argument as `
 or mark it as `required=false` in the corresponding `@RequestParam`, etc. annotation. This is
 a best practice and the recommended solution for regressions encountered in a 5.3 upgrade.
 
-Alternatively, you may specifically handle e.g. the resulting `MissingPathVariableException`
+Alternatively, you may specifically handle, for example, the resulting `MissingPathVariableException`
 in the case of a required `@PathVariable`. A null value after conversion will be treated like
 an empty original value, so the corresponding `Missing...Exception` variants will be thrown.
 ====

framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-requestmapping.adoc

@@ -105,7 +105,7 @@ default from version 6.0. See xref:web/webmvc/mvc-config/path-matching.adoc[MVC
 customizations of path matching options.
 
 `PathPattern` supports the same pattern syntax as `AntPathMatcher`. In addition, it also
-supports the capturing pattern, e.g. `+{*spring}+`, for matching 0 or more path segments
+supports the capturing pattern, for example, `+{*spring}+`, for matching 0 or more path segments
 at the end of a path. `PathPattern` also restricts the use of `+**+` for matching multiple
 path segments such that it's only allowed at the end of a pattern. This eliminates many
 cases of ambiguity when choosing the best matching pattern for a given request.
@@ -272,7 +272,7 @@ To completely disable the use of path extensions in versions prior to 5.3, set t
 * `favorPathExtension(false)`, see xref:web/webmvc/mvc-config/content-negotiation.adoc[ContentNegotiationConfigurer]
 
 Having a way to request content types other than through the `"Accept"` header can still
-be useful, e.g. when typing a URL in a browser. A safe alternative to path extensions is
+be useful, for example, when typing a URL in a browser. A safe alternative to path extensions is
 to use the query parameter strategy. If you must use file extensions, consider restricting
 them to a list of explicitly registered extensions through the `mediaTypes` property of
 xref:web/webmvc/mvc-config/content-negotiation.adoc[ContentNegotiationConfigurer].

framework-docs/modules/ROOT/pages/web/webmvc/mvc-servlet/viewresolver.adoc

@@ -47,7 +47,7 @@ The following table provides more details on the `ViewResolver` hierarchy:
 | Implementation of the `ViewResolver` interface that interprets a view name as a
   bean name in the current application context. This is a very flexible variant which
   allows for mixing and matching different view types based on distinct view names.
-  Each such `View` can be defined as a bean e.g. in XML or in configuration classes.
+  Each such `View` can be defined as a bean, for example, in XML or in configuration classes.
 |===
 
 

framework-docs/modules/ROOT/pages/web/websocket/server.adoc

@@ -29,7 +29,7 @@ WebSocket support does not depend on Spring MVC. It is relatively simple to
 integrate a `WebSocketHandler` into other HTTP-serving environments with the help of
 {spring-framework-api}/web/socket/server/support/WebSocketHttpRequestHandler.html[`WebSocketHttpRequestHandler`].
 
-When using the `WebSocketHandler` API directly vs indirectly, e.g. through the
+When using the `WebSocketHandler` API directly vs indirectly, for example, through the
 xref:web/websocket/stomp.adoc[STOMP] messaging, the application must synchronize the sending of messages
 since the underlying standard WebSocket session (JSR-356) does not allow concurrent
 sending. One option is to wrap the `WebSocketSession` with

framework-docs/modules/ROOT/partials/web/forwarded-headers.adoc

@@ -38,7 +38,7 @@ to inform the server that the original port was `443`.
 ==== X-Forwarded-Proto
 
 While not standard, https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-Proto[`X-Forwarded-Proto: (https|http)`]
-is a de-facto standard header that is used to communicate the original protocol (e.g. https / https)
+is a de-facto standard header that is used to communicate the original protocol (for example, https / https)
 to a downstream server. For example, if a request of `https://example.com/resource` is sent to
 a proxy which forwards the request to `http://localhost:8080/resource`, then a header of
 `X-Forwarded-Proto: https` can be sent to inform the server that the original protocol was `https`.
@@ -48,7 +48,7 @@ a proxy which forwards the request to `http://localhost:8080/resource`, then a h
 ==== X-Forwarded-Ssl
 
 While not standard, `X-Forwarded-Ssl: (on|off)` is a de-facto standard header that is used to communicate the
-original protocol (e.g. https / https) to a downstream server. For example, if a request of
+original protocol (for example, https / https) to a downstream server. For example, if a request of
 `https://example.com/resource` is sent to a proxy which forwards the request to
 `http://localhost:8080/resource`, then a header of `X-Forwarded-Ssl: on` to inform the server that the
 original protocol was `https`.
@@ -103,7 +103,7 @@ applications on the same server. However, this should not be visible in URL path
 the public API where applications may use different subdomains that provides benefits
 such as:
 
-* Added security, e.g. same origin policy
+* Added security, for example, same origin policy
 * Independent scaling of applications (different domain points to different IP address)
 ====
 

framework-docs/modules/ROOT/partials/web/websocket-intro.adoc

@@ -46,7 +46,7 @@ A complete introduction of how WebSockets work is beyond the scope of this docum
 See RFC 6455, the WebSocket chapter of HTML5, or any of the many introductions and
 tutorials on the Web.
 
-Note that, if a WebSocket server is running behind a web server (e.g. nginx), you
+Note that, if a WebSocket server is running behind a web server (for example, nginx), you
 likely need to configure it to pass WebSocket upgrade requests on to the WebSocket
 server. Likewise, if the application runs in a cloud environment, check the
 instructions of the cloud provider related to WebSocket support.

spring-aop/src/main/java/org/aopalliance/intercept/ConstructorInterceptor.java

@@ -23,7 +23,7 @@ import javax.annotation.Nonnull;
  *
  * <p>The user should implement the {@link
  * #construct(ConstructorInvocation)} method to modify the original
- * behavior. E.g. the following class implements a singleton
+ * behavior. For example, the following class implements a singleton
  * interceptor (allows only one unique instance for the intercepted
  * class):
  *

spring-aop/src/main/java/org/aopalliance/intercept/MethodInterceptor.java

@@ -24,7 +24,7 @@ import javax.annotation.Nullable;
  * are nested "on top" of the target.
  *
  * <p>The user should implement the {@link #invoke(MethodInvocation)}
- * method to modify the original behavior. E.g. the following class
+ * method to modify the original behavior. For example, the following class
  * implements a tracing interceptor (traces all the calls on the
  * intercepted method(s)):
  *

spring-aop/src/main/java/org/springframework/aop/Pointcut.java

@@ -21,7 +21,7 @@ package org.springframework.aop;
  *
  * <p>A pointcut is composed of a {@link ClassFilter} and a {@link MethodMatcher}.
  * Both these basic terms and a Pointcut itself can be combined to build up combinations
- * (e.g. through {@link org.springframework.aop.support.ComposablePointcut}).
+ * (for example, through {@link org.springframework.aop.support.ComposablePointcut}).
  *
  * @author Rod Johnson
  * @see ClassFilter

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/AnnotationAwareAspectJAutoProxyCreator.java

@@ -103,7 +103,7 @@ public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorA
 		// broad an impact. Instead we now override isInfrastructureClass to avoid proxying
 		// aspects. I'm not entirely happy with that as there is no good reason not
 		// to advise aspects, except that it causes advice invocation to go through a
-		// proxy, and if the aspect implements e.g the Ordered interface it will be
+		// proxy, and if the aspect implements, for example, the Ordered interface it will be
 		// proxied by that interface and fail at runtime as the advice method is not
 		// defined on the interface. We could potentially relax the restriction about
 		// not advising aspects in the future.

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/AspectMetadata.java

@@ -160,7 +160,7 @@ public class AspectMetadata implements Serializable {
 
 	/**
 	 * Return a Spring pointcut expression for a singleton aspect.
-	 * (e.g. {@code Pointcut.TRUE} if it's a singleton).
+	 * (for example, {@code Pointcut.TRUE} if it's a singleton).
 	 */
 	public Pointcut getPerClausePointcut() {
 		return this.perClausePointcut;

spring-aop/src/main/java/org/springframework/aop/framework/AbstractAdvisingBeanPostProcessor.java

@@ -135,7 +135,7 @@ public abstract class AbstractAdvisingBeanPostProcessor extends ProxyProcessorSu
 	 * Check whether the given bean is eligible for advising with this
 	 * post-processor's {@link Advisor}.
 	 * <p>Delegates to {@link #isEligible(Class)} for target class checking.
-	 * Can be overridden e.g. to specifically exclude certain beans by name.
+	 * Can be overridden, for example, to specifically exclude certain beans by name.
 	 * <p>Note: Only called for regular bean instances but not for existing
 	 * proxy instances which implement {@link Advised} and allow for adding
 	 * the local {@link Advisor} to the existing proxy's {@link Advisor} chain.

spring-aop/src/main/java/org/springframework/aop/framework/AbstractSingletonProxyFactoryBean.java

@@ -91,7 +91,7 @@ public abstract class AbstractSingletonProxyFactoryBean extends ProxyConfig
 
 	/**
 	 * Set additional interceptors (or advisors) to be applied before the
-	 * implicit transaction interceptor, e.g. a PerformanceMonitorInterceptor.
+	 * implicit transaction interceptor, for example, a PerformanceMonitorInterceptor.
 	 * <p>You may specify any AOP Alliance MethodInterceptors or other
 	 * Spring AOP Advices, as well as Spring AOP Advisors.
 	 * @see org.springframework.aop.interceptor.PerformanceMonitorInterceptor

spring-aop/src/main/java/org/springframework/aop/framework/ReflectiveMethodInvocation.java

@@ -47,7 +47,7 @@ import org.springframework.lang.Nullable;
  *
  * <p><b>NOTE:</b> This class is considered internal and should not be
  * directly accessed. The sole reason for it being public is compatibility
- * with existing framework integrations (e.g. Pitchfork). For any other
+ * with existing framework integrations (for example, Pitchfork). For any other
  * purposes, use the {@link ProxyMethodInvocation} interface instead.
  *
  * @author Rod Johnson

spring-aop/src/main/java/org/springframework/aop/framework/autoproxy/AbstractAutoProxyCreator.java

@@ -71,7 +71,7 @@ import org.springframework.util.StringUtils;
  * Instead of x repetitive proxy definitions for x target beans, you can register
  * one single such post processor with the bean factory to achieve the same effect.
  *
- * <p>Subclasses can apply any strategy to decide if a bean is to be proxied, e.g. by type,
+ * <p>Subclasses can apply any strategy to decide if a bean is to be proxied, for example, by type,
  * by name, by definition details, etc. They can also return additional interceptors that
  * should just be applied to the specific bean instance. A simple concrete implementation is
  * {@link BeanNameAutoProxyCreator}, identifying the beans to be proxied via given names.
@@ -403,7 +403,7 @@ public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
 	/**
 	 * Subclasses should override this method to return {@code true} if the
 	 * given bean should not be considered for auto-proxying by this post-processor.
-	 * <p>Sometimes we need to be able to avoid this happening, e.g. if it will lead to
+	 * <p>Sometimes we need to be able to avoid this happening, for example, if it will lead to
 	 * a circular reference or if the existing target instance needs to be preserved.
 	 * This implementation returns {@code false} unless the bean name indicates an
 	 * "original instance" according to {@code AutowireCapableBeanFactory} conventions.
@@ -619,7 +619,7 @@ public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
 
 	/**
 	 * Return whether the given bean is to be proxied, what additional
-	 * advices (e.g. AOP Alliance interceptors) and advisors to apply.
+	 * advices (for example, AOP Alliance interceptors) and advisors to apply.
 	 * @param beanClass the class of the bean to advise
 	 * @param beanName the name of the bean
 	 * @param customTargetSource the TargetSource returned by the

spring-aop/src/main/java/org/springframework/aop/framework/autoproxy/AutoProxyUtils.java

@@ -47,7 +47,7 @@ public abstract class AutoProxyUtils {
 
 	/**
 	 * Bean definition attribute that indicates the original target class of an
-	 * auto-proxied bean, e.g. to be used for the introspection of annotations
+	 * auto-proxied bean, for example, to be used for the introspection of annotations
 	 * on the target class behind an interface-based proxy.
 	 * @since 4.2.3
 	 * @see #determineTargetClass

spring-aop/src/main/java/org/springframework/aop/framework/autoproxy/BeanNameAutoProxyCreator.java

@@ -54,13 +54,13 @@ public class BeanNameAutoProxyCreator extends AbstractAutoProxyCreator {
 
 	/**
 	 * Set the names of the beans that should automatically get wrapped with proxies.
-	 * A name can specify a prefix to match by ending with "*", e.g. "myBean,tx*"
+	 * A name can specify a prefix to match by ending with "*", for example, "myBean,tx*"
 	 * will match the bean named "myBean" and all beans whose name start with "tx".
 	 * <p><b>NOTE:</b> In case of a FactoryBean, only the objects created by the
 	 * FactoryBean will get proxied. This default behavior applies as of Spring 2.0.
 	 * If you intend to proxy a FactoryBean instance itself (a rare use case, but
 	 * Spring 1.2's default behavior), specify the bean name of the FactoryBean
-	 * including the factory-bean prefix "&amp;": e.g. "&amp;myFactoryBean".
+	 * including the factory-bean prefix "&amp;": for example, "&amp;myFactoryBean".
 	 * @see org.springframework.beans.factory.FactoryBean
 	 * @see org.springframework.beans.factory.BeanFactory#FACTORY_BEAN_PREFIX
 	 */

spring-aop/src/main/java/org/springframework/aop/interceptor/AsyncExecutionAspectSupport.java

@@ -52,7 +52,7 @@ import org.springframework.util.function.SingletonSupplier;
  * <p>Provides support for <i>executor qualification</i> on a method-by-method basis.
  * {@code AsyncExecutionAspectSupport} objects must be constructed with a default {@code
  * Executor}, but each individual method may further qualify a specific {@code Executor}
- * bean to be used when executing it, e.g. through an annotation attribute.
+ * bean to be used when executing it, for example, through an annotation attribute.
  *
  * @author Chris Beams
  * @author Juergen Hoeller

spring-aop/src/main/java/org/springframework/aop/interceptor/AsyncExecutionInterceptor.java

@@ -148,7 +148,7 @@ public class AsyncExecutionInterceptor extends AsyncExecutionAspectSupport imple
 	/**
 	 * This implementation searches for a unique {@link org.springframework.core.task.TaskExecutor}
 	 * bean in the context, or for an {@link Executor} bean named "taskExecutor" otherwise.
-	 * If neither of the two is resolvable (e.g. if no {@code BeanFactory} was configured at all),
+	 * If neither of the two is resolvable (for example, if no {@code BeanFactory} was configured at all),
 	 * this implementation falls back to a newly created {@link SimpleAsyncTaskExecutor} instance
 	 * for local use if no default could be found.
 	 * @see #DEFAULT_TASK_EXECUTOR_BEAN_NAME

spring-aop/src/main/java/org/springframework/aop/interceptor/ConcurrencyThrottleInterceptor.java

@@ -31,7 +31,7 @@ import org.springframework.util.ConcurrencyThrottleSupport;
  * <p>Can be applied to methods of local services that involve heavy use
  * of system resources, in a scenario where it is more efficient to
  * throttle concurrency for a specific service rather than restricting
- * the entire thread pool (e.g. the web container's thread pool).
+ * the entire thread pool (for example, the web container's thread pool).
  *
  * <p>The default concurrency limit of this interceptor is 1.
  * Specify the "concurrencyLimit" bean property to change this value.

spring-aop/src/main/java/org/springframework/aop/interceptor/ExposeInvocationInterceptor.java

@@ -30,7 +30,7 @@ import org.springframework.lang.Nullable;
 /**
  * Interceptor that exposes the current {@link org.aopalliance.intercept.MethodInvocation}
  * as a thread-local object. We occasionally need to do this; for example, when a pointcut
- * (e.g. an AspectJ expression pointcut) needs to know the full invocation context.
+ * (for example, an AspectJ expression pointcut) needs to know the full invocation context.
  *
  * <p>Don't use this interceptor unless this is really necessary. Target objects should
  * not normally know about Spring AOP, as this creates a dependency on Spring API.

spring-aop/src/main/java/org/springframework/aop/support/AbstractRegexpMethodPointcut.java

@@ -29,7 +29,7 @@ import org.springframework.util.ObjectUtils;
  * Abstract base regular expression pointcut bean. JavaBean properties are:
  * <ul>
  * <li>pattern: regular expression for the fully-qualified method names to match.
- * The exact regexp syntax will depend on the subclass (e.g. Perl5 regular expressions)
+ * The exact regexp syntax will depend on the subclass (for example, Perl5 regular expressions)
  * <li>patterns: alternative property taking a String array of patterns.
  * The result will be the union of these patterns.
  * </ul>

spring-aop/src/main/java/org/springframework/aop/support/AopUtils.java

@@ -194,7 +194,7 @@ public abstract class AopUtils {
 	/**
 	 * Given a method, which may come from an interface, and a target class used
 	 * in the current AOP invocation, find the corresponding target method if there
-	 * is one. E.g. the method may be {@code IFoo.bar()} and the target class
+	 * is one. For example, the method may be {@code IFoo.bar()} and the target class
 	 * may be {@code DefaultFoo}. In this case, the method may be
 	 * {@code DefaultFoo.bar()}. This enables attributes on that method to be found.
 	 * <p><b>NOTE:</b> In contrast to {@link org.springframework.util.ClassUtils#getMostSpecificMethod},

spring-aop/src/test/java/org/springframework/aop/support/ControlFlowPointcutTests.java

@@ -93,7 +93,7 @@ class ControlFlowPointcutTests {
 
 	/**
 	 * Check that we can use a cflow pointcut in conjunction with
-	 * a static pointcut: e.g. all setter methods that are invoked under
+	 * a static pointcut: for example, all setter methods that are invoked under
 	 * a particular class. This greatly reduces the number of calls
 	 * to the cflow pointcut, meaning that it's not so prohibitively
 	 * expensive.

spring-beans/src/main/java/org/springframework/beans/AbstractNestablePropertyAccessor.java

@@ -474,7 +474,7 @@ public abstract class AbstractNestablePropertyAccessor extends AbstractPropertyA
 			else {
 				Throwable cause = ex.getTargetException();
 				if (cause instanceof UndeclaredThrowableException) {
-					// May happen e.g. with Groovy-generated methods
+					// May happen, for example, with Groovy-generated methods
 					cause = cause.getCause();
 				}
 				throw new MethodInvocationException(propertyChangeEvent, cause);

spring-beans/src/main/java/org/springframework/beans/BeanInfoFactory.java

@@ -23,7 +23,7 @@ import org.springframework.lang.Nullable;
 
 /**
  * Strategy interface for creating {@link BeanInfo} instances for Spring beans.
- * Can be used to plug in custom bean property resolution strategies (e.g. for other
+ * Can be used to plug in custom bean property resolution strategies (for example, for other
  * languages on the JVM) or more efficient {@link BeanInfo} retrieval algorithms.
  *
  * <p>BeanInfoFactories are instantiated by the {@link CachedIntrospectionResults},

spring-beans/src/main/java/org/springframework/beans/BeanUtils.java

@@ -125,7 +125,7 @@ public abstract class BeanUtils {
 	 * The cause may notably indicate a {@link NoSuchMethodException} if no
 	 * primary/default constructor was found, a {@link NoClassDefFoundError}
 	 * or other {@link LinkageError} in case of an unresolvable class definition
-	 * (e.g. due to a missing dependency at runtime), or an exception thrown
+	 * (for example, due to a missing dependency at runtime), or an exception thrown
 	 * from the constructor invocation itself.
 	 * @see Constructor#newInstance
 	 */
@@ -248,7 +248,7 @@ public abstract class BeanUtils {
 			// No public constructors -> check non-public
 			ctors = clazz.getDeclaredConstructors();
 			if (ctors.length == 1) {
-				// A single non-public constructor, e.g. from a non-public record type
+				// A single non-public constructor, for example, from a non-public record type
 				return (Constructor<T>) ctors[0];
 			}
 		}
@@ -538,7 +538,7 @@ public abstract class BeanUtils {
 
 	/**
 	 * Find a JavaBeans PropertyEditor following the 'Editor' suffix convention
-	 * (e.g. "mypackage.MyDomainClass" &rarr; "mypackage.MyDomainClassEditor").
+	 * (for example, "mypackage.MyDomainClass" &rarr; "mypackage.MyDomainClassEditor").
 	 * <p>Compatible to the standard JavaBeans convention as implemented by
 	 * {@link java.beans.PropertyEditorManager} but isolated from the latter's
 	 * registered default editors for primitive types.
@@ -560,7 +560,7 @@ public abstract class BeanUtils {
 				}
 			}
 			catch (Throwable ex) {
-				// e.g. AccessControlException on Google App Engine
+				// for example, AccessControlException on Google App Engine
 				return null;
 			}
 		}

spring-beans/src/main/java/org/springframework/beans/CachedIntrospectionResults.java

@@ -107,7 +107,7 @@ public final class CachedIntrospectionResults {
 	 * Accept the given ClassLoader as cache-safe, even if its classes would
 	 * not qualify as cache-safe in this CachedIntrospectionResults class.
 	 * <p>This configuration method is only relevant in scenarios where the Spring
-	 * classes reside in a 'common' ClassLoader (e.g. the system ClassLoader)
+	 * classes reside in a 'common' ClassLoader (for example, the system ClassLoader)
 	 * whose lifecycle is not coupled to the application. In such a scenario,
 	 * CachedIntrospectionResults would by default not cache any of the application's
 	 * classes, since they would create a leak in the common ClassLoader.
@@ -290,7 +290,7 @@ public final class CachedIntrospectionResults {
 				currClass = currClass.getSuperclass();
 			}
 
-			// Check for record-style accessors without prefix: e.g. "lastName()"
+			// Check for record-style accessors without prefix: for example, "lastName()"
 			// - accessor method directly referring to instance field of same name
 			// - same convention for component accessors of Java 15 record classes
 			introspectPlainAccessors(beanClass, readMethodNames);

spring-beans/src/main/java/org/springframework/beans/ExtendedBeanInfo.java

@@ -41,7 +41,7 @@ import org.springframework.lang.Nullable;
 import org.springframework.util.ObjectUtils;
 
 /**
- * Decorator for a standard {@link BeanInfo} object, e.g. as created by
+ * Decorator for a standard {@link BeanInfo} object, for example, as created by
  * {@link Introspector#getBeanInfo(Class)}, designed to discover and register
  * static and/or non-void returning setter methods. For example:
  *

spring-beans/src/main/java/org/springframework/beans/FatalBeanException.java

@@ -20,7 +20,7 @@ import org.springframework.lang.Nullable;
 
 /**
  * Thrown on an unrecoverable problem encountered in the
- * beans packages or sub-packages, e.g. bad class or field.
+ * beans packages or sub-packages, for example, bad class or field.
  *
  * @author Rod Johnson
  */

spring-beans/src/main/java/org/springframework/beans/factory/BeanDefinitionStoreException.java

@@ -21,7 +21,7 @@ import org.springframework.lang.Nullable;
 
 /**
  * Exception thrown when a BeanFactory encounters an invalid bean definition:
- * e.g. in case of incomplete or contradictory bean metadata.
+ * for example, in case of incomplete or contradictory bean metadata.
  *
  * @author Rod Johnson
  * @author Juergen Hoeller

spring-beans/src/main/java/org/springframework/beans/factory/BeanFactory.java

@@ -36,7 +36,7 @@ import org.springframework.lang.Nullable;
  * singleton in the scope of the factory). Which type of instance will be returned
  * depends on the bean factory configuration: the API is the same. Since Spring
  * 2.0, further scopes are available depending on the concrete application
- * context (e.g. "request" and "session" scopes in a web environment).
+ * context (for example, "request" and "session" scopes in a web environment).
  *
  * <p>The point of this approach is that the BeanFactory is a central registry
  * of application components, and centralizes configuration of application

spring-beans/src/main/java/org/springframework/beans/factory/InitializingBean.java

@@ -18,7 +18,7 @@ package org.springframework.beans.factory;
 
 /**
  * Interface to be implemented by beans that need to react once all their properties
- * have been set by a {@link BeanFactory}: e.g. to perform custom initialization,
+ * have been set by a {@link BeanFactory}: for example, to perform custom initialization,
  * or merely to check that all mandatory properties have been set.
  *
  * <p>An alternative to implementing {@code InitializingBean} is specifying a custom

spring-beans/src/main/java/org/springframework/beans/factory/ObjectProvider.java

@@ -38,10 +38,10 @@ import org.springframework.lang.Nullable;
  * iteration and allows for collection-style {@link #stream} access.
  *
  * <p>As of 6.2, this interface declares default implementations for all methods.
- * This makes it easier to implement in a custom fashion, e.g. for unit tests.
+ * This makes it easier to implement in a custom fashion, for example, for unit tests.
  * For typical purposes, implement {@link #stream()} to enable all other methods.
  * Alternatively, you may implement the specific methods that your callers expect,
- * e.g. just {@link #getObject()} or {@link #getIfAvailable()}.
+ * for example, just {@link #getObject()} or {@link #getIfAvailable()}.
  *
  * @author Juergen Hoeller
  * @since 4.3

spring-beans/src/main/java/org/springframework/beans/factory/SmartInitializingSingleton.java

@@ -21,7 +21,7 @@ package org.springframework.beans.factory;
  * during {@link BeanFactory} bootstrap. This interface can be implemented by
  * singleton beans in order to perform some initialization after the regular
  * singleton instantiation algorithm, avoiding side effects with accidental early
- * initialization (e.g. from {@link ListableBeanFactory#getBeansOfType} calls).
+ * initialization (for example, from {@link ListableBeanFactory#getBeansOfType} calls).
  * In that sense, it is an alternative to {@link InitializingBean} which gets
  * triggered right at the end of a bean's local construction phase.
  *

spring-beans/src/main/java/org/springframework/beans/factory/annotation/BeanFactoryAnnotationUtils.java

@@ -50,7 +50,7 @@ public abstract class BeanFactoryAnnotationUtils {
 
 	/**
 	 * Retrieve all beans of type {@code T} from the given {@code BeanFactory} declaring a
-	 * qualifier (e.g. via {@code <qualifier>} or {@code @Qualifier}) matching the given
+	 * qualifier (for example, via {@code <qualifier>} or {@code @Qualifier}) matching the given
 	 * qualifier, or having a bean name matching the given qualifier.
 	 * @param beanFactory the factory to get the target beans from (also searching ancestors)
 	 * @param beanType the type of beans to retrieve
@@ -75,7 +75,7 @@ public abstract class BeanFactoryAnnotationUtils {
 
 	/**
 	 * Obtain a bean of type {@code T} from the given {@code BeanFactory} declaring a
-	 * qualifier (e.g. via {@code <qualifier>} or {@code @Qualifier}) matching the given
+	 * qualifier (for example, via {@code <qualifier>} or {@code @Qualifier}) matching the given
 	 * qualifier, or having a bean name matching the given qualifier.
 	 * @param beanFactory the factory to get the target bean from (also searching ancestors)
 	 * @param beanType the type of bean to retrieve
@@ -109,7 +109,7 @@ public abstract class BeanFactoryAnnotationUtils {
 
 	/**
 	 * Obtain a bean of type {@code T} from the given {@code BeanFactory} declaring a qualifier
-	 * (e.g. {@code <qualifier>} or {@code @Qualifier}) matching the given qualifier).
+	 * (for example, {@code <qualifier>} or {@code @Qualifier}) matching the given qualifier).
 	 * @param bf the factory to get the target bean from
 	 * @param beanType the type of bean to retrieve
 	 * @param qualifier the qualifier for selecting between multiple bean matches

spring-beans/src/main/java/org/springframework/beans/factory/annotation/ParameterResolutionDelegate.java

@@ -153,7 +153,7 @@ public final class ParameterResolutionDelegate {
 	 * an empty {@code AnnotatedElement}.
 	 * <h4>WARNING</h4>
 	 * <p>The {@code AnnotatedElement} returned by this method should never be cast and
-	 * treated as a {@code Parameter} since the metadata (e.g., {@link Parameter#getName()},
+	 * treated as a {@code Parameter} since the metadata (for example, {@link Parameter#getName()},
 	 * {@link Parameter#getType()}, etc.) will not match those for the declared parameter
 	 * at the given index in an inner class constructor.
 	 * @return the supplied {@code parameter} or the <em>effective</em> {@code Parameter}

spring-beans/src/main/java/org/springframework/beans/factory/config/AutowireCapableBeanFactory.java

@@ -105,7 +105,7 @@ public interface AutowireCapableBeanFactory extends BeanFactory {
 	/**
 	 * Suffix for the "original instance" convention when initializing an existing
 	 * bean instance: to be appended to the fully-qualified bean class name,
-	 * e.g. "com.mypackage.MyClass.ORIGINAL", in order to enforce the given instance
+	 * for example, "com.mypackage.MyClass.ORIGINAL", in order to enforce the given instance
 	 * to be returned, i.e. no proxies etc.
 	 * @since 5.1
 	 * @see #initializeBean(Object, String)
@@ -128,7 +128,7 @@ public interface AutowireCapableBeanFactory extends BeanFactory {
 	 * Constructor resolution is based on Kotlin primary / single public / single non-public,
 	 * with a fallback to the default constructor in ambiguous scenarios, also influenced
 	 * by {@link SmartInstantiationAwareBeanPostProcessor#determineCandidateConstructors}
-	 * (e.g. for annotation-driven constructor selection).
+	 * (for example, for annotation-driven constructor selection).
 	 * @param beanClass the class of the bean to create
 	 * @return the new bean instance
 	 * @throws BeansException if instantiation or wiring failed
@@ -137,7 +137,7 @@ public interface AutowireCapableBeanFactory extends BeanFactory {
 
 	/**
 	 * Populate the given bean instance through applying after-instantiation callbacks
-	 * and bean property post-processing (e.g. for annotation-driven injection).
+	 * and bean property post-processing (for example, for annotation-driven injection).
 	 * <p>Note: This is essentially intended for (re-)populating annotated fields and
 	 * methods, either for new instances or for deserialized instances. It does
 	 * <i>not</i> imply traditional by-name or by-type autowiring of properties;
@@ -196,7 +196,7 @@ public interface AutowireCapableBeanFactory extends BeanFactory {
 	 * Instantiate a new bean instance of the given class with the specified autowire
 	 * strategy. All constants defined in this interface are supported here.
 	 * Can also be invoked with {@code AUTOWIRE_NO} in order to just apply
-	 * before-instantiation callbacks (e.g. for annotation-driven injection).
+	 * before-instantiation callbacks (for example, for annotation-driven injection).
 	 * <p>Does <i>not</i> apply standard {@link BeanPostProcessor BeanPostProcessors}
 	 * callbacks or perform any further initialization of the bean. This interface
 	 * offers distinct, fine-grained operations for those purposes, for example
@@ -223,7 +223,7 @@ public interface AutowireCapableBeanFactory extends BeanFactory {
 	/**
 	 * Autowire the bean properties of the given bean instance by name or type.
 	 * Can also be invoked with {@code AUTOWIRE_NO} in order to just apply
-	 * after-instantiation callbacks (e.g. for annotation-driven injection).
+	 * after-instantiation callbacks (for example, for annotation-driven injection).
 	 * <p>Does <i>not</i> apply standard {@link BeanPostProcessor BeanPostProcessors}
 	 * callbacks or perform any further initialization of the bean. This interface
 	 * offers distinct, fine-grained operations for those purposes, for example

spring-beans/src/main/java/org/springframework/beans/factory/config/ConfigurableBeanFactory.java

@@ -241,7 +241,7 @@ public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, Single
 	boolean hasEmbeddedValueResolver();
 
 	/**
-	 * Resolve the given embedded value, e.g. an annotation attribute.
+	 * Resolve the given embedded value, for example, an annotation attribute.
 	 * @param value the value to resolve
 	 * @return the resolved value (may be the original value as-is)
 	 * @since 3.0
@@ -255,7 +255,7 @@ public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, Single
 	 * <p>Note: Post-processors submitted here will be applied in the order of
 	 * registration; any ordering semantics expressed through implementing the
 	 * {@link org.springframework.core.Ordered} interface will be ignored. Note
-	 * that autodetected post-processors (e.g. as beans in an ApplicationContext)
+	 * that autodetected post-processors (for example, as beans in an ApplicationContext)
 	 * will always be applied after programmatically registered ones.
 	 * @param beanPostProcessor the post-processor to register
 	 */

spring-beans/src/main/java/org/springframework/beans/factory/config/ConfigurableListableBeanFactory.java

@@ -66,13 +66,13 @@ public interface ConfigurableListableBeanFactory
 	 * Register a special dependency type with corresponding autowired value.
 	 * <p>This is intended for factory/context references that are supposed
 	 * to be autowirable but are not defined as beans in the factory:
-	 * e.g. a dependency of type ApplicationContext resolved to the
+	 * for example, a dependency of type ApplicationContext resolved to the
 	 * ApplicationContext instance that the bean is living in.
 	 * <p>Note: There are no such default types registered in a plain BeanFactory,
 	 * not even for the BeanFactory interface itself.
 	 * @param dependencyType the dependency type to register. This will typically
 	 * be a base interface such as BeanFactory, with extensions of it resolved
-	 * as well if declared as an autowiring dependency (e.g. ListableBeanFactory),
+	 * as well if declared as an autowiring dependency (for example, ListableBeanFactory),
 	 * as long as the given value actually implements the extended interface.
 	 * @param autowiredValue the corresponding autowired value. This may also be an
 	 * implementation of the {@link org.springframework.beans.factory.ObjectFactory}
@@ -126,7 +126,7 @@ public interface ConfigurableListableBeanFactory
 	 * Clear the merged bean definition cache, removing entries for beans
 	 * which are not considered eligible for full metadata caching yet.
 	 * <p>Typically triggered after changes to the original bean definitions,
-	 * e.g. after applying a {@link BeanFactoryPostProcessor}. Note that metadata
+	 * for example, after applying a {@link BeanFactoryPostProcessor}. Note that metadata
 	 * for beans which have already been created at this point will be kept around.
 	 * @since 4.2
 	 * @see #getBeanDefinition

spring-beans/src/main/java/org/springframework/beans/factory/config/CustomEditorConfigurer.java

@@ -76,7 +76,7 @@ import org.springframework.util.ClassUtils;
  *
  * <p>
  * Also supports "java.lang.String[]"-style array class names and primitive
- * class names (e.g. "boolean"). Delegates to {@link ClassUtils} for actual
+ * class names (for example, "boolean"). Delegates to {@link ClassUtils} for actual
  * class name resolution.
  *
  * <p><b>NOTE:</b> Custom property editors registered with this configurer do

spring-beans/src/main/java/org/springframework/beans/factory/config/DependencyDescriptor.java

@@ -180,7 +180,7 @@ public class DependencyDescriptor extends InjectionPoint implements Serializable
 
 	/**
 	 * Check whether the underlying field is annotated with any variant of a
-	 * {@code Nullable} annotation, e.g. {@code jakarta.annotation.Nullable} or
+	 * {@code Nullable} annotation, for example, {@code jakarta.annotation.Nullable} or
 	 * {@code edu.umd.cs.findbugs.annotations.Nullable}.
 	 */
 	private boolean hasNullableAnnotation() {
@@ -381,7 +381,7 @@ public class DependencyDescriptor extends InjectionPoint implements Serializable
 
 	/**
 	 * Determine whether this dependency supports lazy resolution,
-	 * e.g. through extra proxying. The default is {@code true}.
+	 * for example, through extra proxying. The default is {@code true}.
 	 * @since 6.1.2
 	 * @see org.springframework.beans.factory.support.AutowireCandidateResolver#getLazyResolutionProxyIfNecessary
 	 */

spring-beans/src/main/java/org/springframework/beans/factory/config/DestructionAwareBeanPostProcessor.java

@@ -31,7 +31,7 @@ public interface DestructionAwareBeanPostProcessor extends BeanPostProcessor {
 
 	/**
 	 * Apply this BeanPostProcessor to the given bean instance before its
-	 * destruction, e.g. invoking custom destruction callbacks.
+	 * destruction, for example, invoking custom destruction callbacks.
 	 * <p>Like DisposableBean's {@code destroy} and a custom destroy method, this
 	 * callback will only apply to beans which the container fully manages the
 	 * lifecycle for. This is usually the case for singletons and scoped beans.

spring-beans/src/main/java/org/springframework/beans/factory/config/FieldRetrievingFactoryBean.java

@@ -140,7 +140,7 @@ public class FieldRetrievingFactoryBean
 
 	/**
 	 * Set a fully qualified static field name to retrieve,
-	 * e.g. "example.MyExampleClass.MY_EXAMPLE_FIELD".
+	 * for example, "example.MyExampleClass.MY_EXAMPLE_FIELD".
 	 * Convenient alternative to specifying targetClass and targetField.
 	 * @see #setTargetClass
 	 * @see #setTargetField
@@ -190,7 +190,7 @@ public class FieldRetrievingFactoryBean
 			if (lastDotIndex == -1 || lastDotIndex == this.staticField.length()) {
 				throw new IllegalArgumentException(
 						"staticField must be a fully qualified class plus static field name: " +
-						"e.g. 'example.MyExampleClass.MY_EXAMPLE_FIELD'");
+						"for example, 'example.MyExampleClass.MY_EXAMPLE_FIELD'");
 			}
 			String className = this.staticField.substring(0, lastDotIndex);
 			String fieldName = this.staticField.substring(lastDotIndex + 1);

spring-beans/src/main/java/org/springframework/beans/factory/config/PlaceholderConfigurerSupport.java

@@ -180,7 +180,7 @@ public abstract class PlaceholderConfigurerSupport extends PropertyResourceConfi
 
 	/**
 	 * Set a value that should be treated as {@code null} when resolved
-	 * as a placeholder value: e.g. "" (empty String) or "null".
+	 * as a placeholder value: for example, "" (empty String) or "null".
 	 * <p>Note that this will only apply to full property values,
 	 * not to parts of concatenated values.
 	 * <p>By default, no such null value is defined. This means that

spring-beans/src/main/java/org/springframework/beans/factory/config/PropertyPathFactoryBean.java

@@ -121,7 +121,7 @@ public class PropertyPathFactoryBean implements FactoryBean<Object>, BeanNameAwa
 	 * Specify the name of a target bean to apply the property path to.
 	 * Alternatively, specify a target object directly.
 	 * @param targetBeanName the bean name to be looked up in the
-	 * containing bean factory (e.g. "testBean")
+	 * containing bean factory (for example, "testBean")
 	 * @see #setTargetObject
 	 */
 	public void setTargetBeanName(String targetBeanName) {
@@ -131,7 +131,7 @@ public class PropertyPathFactoryBean implements FactoryBean<Object>, BeanNameAwa
 	/**
 	 * Specify the property path to apply to the target.
 	 * @param propertyPath the property path, potentially nested
-	 * (e.g. "age" or "spouse.age")
+	 * (for example, "age" or "spouse.age")
 	 */
 	public void setPropertyPath(String propertyPath) {
 		this.propertyPath = StringUtils.trimAllWhitespace(propertyPath);

spring-beans/src/main/java/org/springframework/beans/factory/config/PropertyPlaceholderConfigurer.java

@@ -93,7 +93,7 @@ public class PropertyPlaceholderConfigurer extends PlaceholderConfigurerSupport
 
 	/**
 	 * Set the system property mode by the name of the corresponding constant,
-	 * e.g. "SYSTEM_PROPERTIES_MODE_OVERRIDE".
+	 * for example, "SYSTEM_PROPERTIES_MODE_OVERRIDE".
 	 * @param constantName name of the constant
 	 * @see #setSystemPropertiesMode
 	 */

spring-beans/src/main/java/org/springframework/beans/factory/config/Scope.java

@@ -31,7 +31,7 @@ import org.springframework.lang.Nullable;
  * <p>{@link org.springframework.context.ApplicationContext} implementations
  * such as a {@link org.springframework.web.context.WebApplicationContext}
  * may register additional standard scopes specific to their environment,
- * e.g. {@link org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST "request"}
+ * for example, {@link org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST "request"}
  * and {@link org.springframework.web.context.WebApplicationContext#SCOPE_SESSION "session"},
  * based on this Scope SPI.
  *
@@ -125,7 +125,7 @@ public interface Scope {
 
 	/**
 	 * Resolve the contextual object for the given key, if any.
-	 * E.g. the HttpServletRequest object for key "request".
+	 * For example, the HttpServletRequest object for key "request".
 	 * @param key the contextual key
 	 * @return the corresponding object, or {@code null} if none found
 	 * @throws IllegalStateException if the underlying scope is not currently active

spring-beans/src/main/java/org/springframework/beans/factory/config/YamlProcessor.java

@@ -77,7 +77,7 @@ public abstract class YamlProcessor {
 	 * A map of document matchers allowing callers to selectively use only
 	 * some of the documents in a YAML resource. In YAML documents are
 	 * separated by {@code ---} lines, and each document is converted
-	 * to properties before the match is made. E.g.
+	 * to properties before the match is made. For example,
 	 * <pre class="code">
 	 * environment: dev
 	 * url: https://dev.bar.com

spring-beans/src/main/java/org/springframework/beans/factory/config/YamlPropertiesFactoryBean.java

@@ -32,7 +32,7 @@ import org.springframework.lang.Nullable;
  * has a lot of similar features.
  *
  * <p><b>Note: All exposed values are of type {@code String}</b> for access through
- * the common {@link Properties#getProperty} method (e.g. in configuration property
+ * the common {@link Properties#getProperty} method (for example, in configuration property
  * resolution through {@link PropertyResourceConfigurer#setProperties(Properties)}).
  * If this is not desirable, use {@link YamlMapFactoryBean} instead.
  *

spring-beans/src/main/java/org/springframework/beans/factory/parsing/ComponentDefinition.java

@@ -28,7 +28,7 @@ import org.springframework.beans.factory.config.BeanReference;
  * it is now possible for a single logical configuration entity, in this case an XML tag, to
  * create multiple {@link BeanDefinition BeanDefinitions} and {@link BeanReference RuntimeBeanReferences}
  * in order to provide more succinct configuration and greater convenience to end users. As such, it can
- * no longer be assumed that each configuration entity (e.g. XML tag) maps to one {@link BeanDefinition}.
+ * no longer be assumed that each configuration entity (for example, XML tag) maps to one {@link BeanDefinition}.
  * For tool vendors and other users who wish to present visualization or support for configuring Spring
  * applications it is important that there is some mechanism in place to tie the {@link BeanDefinition BeanDefinitions}
  * in the {@link org.springframework.beans.factory.BeanFactory} back to the configuration data in a way

spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java

@@ -205,7 +205,7 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
 
 	/**
 	 * Set the ParameterNameDiscoverer to use for resolving method parameter
-	 * names if needed (e.g. for constructor names).
+	 * names if needed (for example, for constructor names).
 	 * <p>Default is a {@link DefaultParameterNameDiscoverer}.
 	 */
 	public void setParameterNameDiscoverer(@Nullable ParameterNameDiscoverer parameterNameDiscoverer) {
@@ -539,7 +539,7 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
 
 	/**
 	 * Actually create the specified bean. Pre-creation processing has already happened
-	 * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.
+	 * at this point, for example, checking {@code postProcessBeforeInstantiation} callbacks.
 	 * <p>Differentiates between default bean instantiation, use of a
 	 * factory method, and autowiring a constructor.
 	 * @param beanName the name of the bean
@@ -821,7 +821,7 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
 			return cachedReturnType.resolve();
 		}
 		catch (LinkageError err) {
-			// E.g. a NoClassDefFoundError for a generic method return type
+			// For example, a NoClassDefFoundError for a generic method return type
 			if (logger.isDebugEnabled()) {
 				logger.debug("Failed to resolve type for factory method of bean '" + beanName + "': " +
 						(uniqueCandidate != null ? uniqueCandidate : commonType), err);

spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanDefinition.java

@@ -1075,7 +1075,7 @@ public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccess
 	 * Specify whether the configured initializer method is the default.
 	 * <p>The default value is {@code true} for a locally specified init method
 	 * but switched to {@code false} for a shared setting in a defaults section
-	 * (e.g. {@code bean init-method} versus {@code beans default-init-method}
+	 * (for example, {@code bean init-method} versus {@code beans default-init-method}
 	 * level in XML) which might not apply to all contained bean definitions.
 	 * @see #setInitMethodName
 	 * @see #applyDefaults
@@ -1135,7 +1135,7 @@ public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccess
 	 * Specify whether the configured destroy method is the default.
 	 * <p>The default value is {@code true} for a locally specified destroy method
 	 * but switched to {@code false} for a shared setting in a defaults section
-	 * (e.g. {@code bean destroy-method} versus {@code beans default-destroy-method}
+	 * (for example, {@code bean destroy-method} versus {@code beans default-destroy-method}
 	 * level in XML) which might not apply to all contained bean definitions.
 	 * @see #setDestroyMethodName
 	 * @see #applyDefaults
@@ -1241,7 +1241,7 @@ public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccess
 	}
 
 	/**
-	 * Set the originating (e.g. decorated) BeanDefinition, if any.
+	 * Set the originating (for example, decorated) BeanDefinition, if any.
 	 */
 	public void setOriginatingBeanDefinition(BeanDefinition originatingBd) {
 		this.resource = new BeanDefinitionResource(originatingBd);

spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanFactory.java

@@ -147,7 +147,7 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
 	@Nullable
 	private TypeConverter typeConverter;
 
-	/** String resolvers to apply e.g. to annotation attribute values. */
+	/** String resolvers to apply, for example, to annotation attribute values. */
 	private final List<StringValueResolver> embeddedValueResolvers = new CopyOnWriteArrayList<>();
 
 	/** BeanPostProcessors to apply. */
@@ -1511,7 +1511,7 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
 	 * Clear the merged bean definition cache, removing entries for beans
 	 * which are not considered eligible for full metadata caching yet.
 	 * <p>Typically triggered after changes to the original bean definitions,
-	 * e.g. after applying a {@code BeanFactoryPostProcessor}. Note that metadata
+	 * for example, after applying a {@code BeanFactoryPostProcessor}. Note that metadata
 	 * for beans which have already been created at this point will be kept around.
 	 * @since 4.2
 	 */
@@ -1570,7 +1570,7 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
 
 		if (!ObjectUtils.isEmpty(typesToMatch)) {
 			// When just doing type checks (i.e. not creating an actual instance yet),
-			// use the specified temporary class loader (e.g. in a weaving scenario).
+			// use the specified temporary class loader (for example, in a weaving scenario).
 			ClassLoader tempClassLoader = getTempClassLoader();
 			if (tempClassLoader != null) {
 				dynamicLoader = tempClassLoader;

spring-beans/src/main/java/org/springframework/beans/factory/support/AutowireCandidateResolver.java

@@ -50,7 +50,7 @@ public interface AutowireCandidateResolver {
 	 * <p>The default implementation checks {@link DependencyDescriptor#isRequired()}.
 	 * @param descriptor the descriptor for the target method parameter or field
 	 * @return whether the descriptor is marked as required or possibly indicating
-	 * non-required status some other way (e.g. through a parameter annotation)
+	 * non-required status some other way (for example, through a parameter annotation)
 	 * @since 5.0
 	 * @see DependencyDescriptor#isRequired()
 	 */

spring-beans/src/main/java/org/springframework/beans/factory/support/AutowireUtils.java

@@ -122,7 +122,7 @@ abstract class AutowireUtils {
 
 	/**
 	 * Resolve the given autowiring value against the given required type,
-	 * e.g. an {@link ObjectFactory} value to its actual object result.
+	 * for example, an {@link ObjectFactory} value to its actual object result.
 	 * @param autowiringValue the value to resolve
 	 * @param requiredType the type to assign the result to
 	 * @return the resolved value
@@ -157,7 +157,7 @@ abstract class AutowireUtils {
 	 * the given {@code method} does not declare any {@linkplain
 	 * Method#getTypeParameters() formal type variables}</li>
 	 * <li>the {@linkplain Method#getReturnType() standard return type}, if the
-	 * target return type cannot be inferred (e.g., due to type erasure)</li>
+	 * target return type cannot be inferred (for example, due to type erasure)</li>
 	 * <li>{@code null}, if the length of the given arguments array is shorter
 	 * than the length of the {@linkplain
 	 * Method#getGenericParameterTypes() formal argument list} for the given
@@ -182,8 +182,8 @@ abstract class AutowireUtils {
 		Type[] methodParameterTypes = method.getGenericParameterTypes();
 		Assert.isTrue(args.length == methodParameterTypes.length, "Argument array does not match parameter count");
 
-		// Ensure that the type variable (e.g., T) is declared directly on the method
-		// itself (e.g., via <T>), not on the enclosing class or interface.
+		// Ensure that the type variable (for example, T) is declared directly on the method
+		// itself (for example, via <T>), not on the enclosing class or interface.
 		boolean locallyDeclaredTypeVariableMatchesReturnType = false;
 		for (TypeVariable<Method> currentTypeVariable : declaredTypeVariables) {
 			if (currentTypeVariable.equals(genericReturnType)) {

spring-beans/src/main/java/org/springframework/beans/factory/support/ConstructorResolver.java

@@ -918,7 +918,7 @@ class ConstructorResolver {
 		catch (NoSuchBeanDefinitionException ex) {
 			if (fallback) {
 				// Single constructor or factory method -> let's return an empty array/collection
-				// for e.g. a vararg or a non-null List/Set/Map parameter.
+				// for example, a vararg or a non-null List/Set/Map parameter.
 				if (paramType.isArray()) {
 					return Array.newInstance(paramType.componentType(), 0);
 				}
@@ -1323,7 +1323,7 @@ class ConstructorResolver {
 			// No public constructors -> check non-public
 			ctors = clazz.getDeclaredConstructors();
 			if (ctors.length == 1) {
-				// A single non-public constructor, e.g. from a non-public record type
+				// A single non-public constructor, for example, from a non-public record type
 				return ctors;
 			}
 		}

spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java

@@ -349,7 +349,7 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 			this.dependencyComparator = otherListableFactory.dependencyComparator;
 			// A clone of the AutowireCandidateResolver since it is potentially BeanFactoryAware
 			setAutowireCandidateResolver(otherListableFactory.getAutowireCandidateResolver().cloneIfNecessary());
-			// Make resolvable dependencies (e.g. ResourceLoader) available here as well
+			// Make resolvable dependencies (for example, ResourceLoader) available here as well
 			this.resolvableDependencies.putAll(otherListableFactory.resolvableDependencies);
 		}
 	}
@@ -772,7 +772,7 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 		}
 		if (containsBeanDefinition(beanName)) {
 			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
-			// Check raw bean class, e.g. in case of a proxy.
+			// Check raw bean class, for example, in case of a proxy.
 			if (bd.hasBeanClass() && bd.getFactoryMethodName() == null) {
 				Class<?> beanClass = bd.getBeanClass();
 				if (beanClass != beanType) {
@@ -811,7 +811,7 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 		}
 		if (containsBeanDefinition(beanName)) {
 			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
-			// Check raw bean class, e.g. in case of a proxy.
+			// Check raw bean class, for example, in case of a proxy.
 			if (bd.hasBeanClass() && bd.getFactoryMethodName() == null) {
 				Class<?> beanClass = bd.getBeanClass();
 				if (beanClass != beanType) {
@@ -1211,7 +1211,7 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 
 		boolean explicitBeanOverride = (this.allowBeanDefinitionOverriding != null);
 		if (existingDefinition.getRole() < beanDefinition.getRole()) {
-			// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
+			// for example, was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
 			if (logger.isInfoEnabled()) {
 				logger.info("Overriding user-defined bean definition for bean '" + beanName +
 						"' with a framework-generated bean definition: replacing [" +
@@ -1290,7 +1290,7 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 
 		// Remove corresponding bean from singleton cache, if any. Shouldn't usually
 		// be necessary, rather just meant for overriding a context's default beans
-		// (e.g. the default StaticMessageSource in a StaticApplicationContext).
+		// (for example, the default StaticMessageSource in a StaticApplicationContext).
 		destroySingleton(beanName);
 
 		// Remove a cached primary marker for the given bean.
@@ -1521,7 +1521,7 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 
 		InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
 		try {
-			// Step 1: pre-resolved shortcut for single bean match, e.g. from @Autowired
+			// Step 1: pre-resolved shortcut for single bean match, for example, from @Autowired
 			Object shortcut = descriptor.resolveShortcut(this);
 			if (shortcut != null) {
 				return shortcut;
@@ -1529,7 +1529,7 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 
 			Class<?> type = descriptor.getDependencyType();
 
-			// Step 2: pre-defined value or expression, e.g. from @Value
+			// Step 2: pre-defined value or expression, for example, from @Value
 			Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
 			if (value != null) {
 				if (value instanceof String strValue) {

spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultSingletonBeanRegistry.java

@@ -157,7 +157,7 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
 	/**
 	 * Add the given singleton factory for building the specified singleton
 	 * if necessary.
-	 * <p>To be called for early exposure purposes, e.g. to be able to
+	 * <p>To be called for early exposure purposes, for example, to be able to
 	 * resolve circular references.
 	 * @param beanName the name of the bean
 	 * @param singletonFactory the factory for the singleton object
@@ -340,7 +340,7 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
 
 	/**
 	 * Register an exception that happened to get suppressed during the creation of a
-	 * singleton bean instance, e.g. a temporary circular reference resolution problem.
+	 * singleton bean instance, for example, a temporary circular reference resolution problem.
 	 * <p>The default implementation preserves any given exception in this registry's
 	 * collection of suppressed exceptions, up to a limit of 100 exceptions, adding
 	 * them as related causes to an eventual top-level {@link BeanCreationException}.
@@ -451,7 +451,7 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
 
 	/**
 	 * Register a containment relationship between two beans,
-	 * e.g. between an inner bean and its containing outer bean.
+	 * for example, between an inner bean and its containing outer bean.
 	 * <p>Also registers the containing bean as dependent on the contained bean
 	 * in terms of destruction order.
 	 * @param containedBeanName the name of the contained (inner) bean