Replace E.g. with For example

Latin abbreviation is not readable for non-native English speakers.

Author: quaff

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).