Use consistent case for 'Servlet' and 'Filter' in documentation

Closes gh-27896

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

@@ -455,7 +455,7 @@ For example, `@WebEndpoint` is exposed only over HTTP and not over JMX.
 You can write technology-specific extensions by using `@EndpointWebExtension` and `@EndpointJmxExtension`.
 These annotations let you provide technology-specific operations to augment an existing endpoint.
 
-Finally, if you need access to web-framework-specific functionality, you can implement Servlet or Spring `@Controller` and `@RestController` endpoints at the cost of them not being available over JMX or when using a different web framework.
+Finally, if you need access to web-framework-specific functionality, you can implement servlet or Spring `@Controller` and `@RestController` endpoints at the cost of them not being available over JMX or when using a different web framework.
 
 
 
@@ -598,9 +598,9 @@ The latter is typically used to perform authorization checks by using its `isUse
 
 [[actuator.endpoints.implementing-custom.servlet]]
 ==== Servlet Endpoints
-A `Servlet` can be exposed as an endpoint by implementing a class annotated with `@ServletEndpoint` that also implements `Supplier<EndpointServlet>`.
+A servlet can be exposed as an endpoint by implementing a class annotated with `@ServletEndpoint` that also implements `Supplier<EndpointServlet>`.
 Servlet endpoints provide deeper integration with the servlet container but at the expense of portability.
-They are intended to be used to expose an existing `Servlet` as an endpoint.
+They are intended to be used to expose an existing servlet as an endpoint.
 For new endpoints, the `@Endpoint` and `@WebEndpoint` annotations should be preferred whenever possible.
 
 

spring-boot-project/spring-boot-docs/src/docs/asciidoc/features/developing-auto-configuration.adoc

@@ -190,7 +190,7 @@ include::{docs-java}/features/developingautoconfiguration/testing/MyConditionEva
 
 [[features.developing-auto-configuration.testing.simulating-a-web-context]]
 ==== Simulating a Web Context
-If you need to test an auto-configuration that only operates in a Servlet or Reactive web application context, use the `WebApplicationContextRunner` or `ReactiveWebApplicationContextRunner` respectively.
+If you need to test an auto-configuration that only operates in a servlet or reactive web application context, use the `WebApplicationContextRunner` or `ReactiveWebApplicationContextRunner` respectively.
 
 
 

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

@@ -192,10 +192,10 @@ include::{docs-java}/features/testing/springbootapplications/withmockenvironment
 
 [TIP]
 ====
-Testing within a mocked environment is usually faster than running with a full Servlet container.
-However, since mocking occurs at the Spring MVC layer, code that relies on lower-level Servlet container behavior cannot be directly tested with MockMvc.
+Testing within a mocked environment is usually faster than running with a full servlet container.
+However, since mocking occurs at the Spring MVC layer, code that relies on lower-level servlet container behavior cannot be directly tested with MockMvc.
 
-For example, Spring Boot's error handling is based on the "`error page`" support provided by the Servlet container.
+For example, Spring Boot's error handling is based on the "`error page`" support provided by the servlet container.
 This means that, whilst you can test your MVC layer throws and handles exceptions as expected, you cannot directly test that a specific <<web#web.servlet.spring-mvc.error-handling.error-pages, custom error page>> is rendered.
 If you need to test these lower-level concerns, you can start a fully running server as described in the next section.
 ====
@@ -708,7 +708,7 @@ It can also be used to configure the host, scheme, and port that appears in any
 
 [[features.testing.spring-boot-applications.autoconfigured-spring-restdocs.with-mock-mvc]]
 ===== Auto-configured Spring REST Docs Tests with Mock MVC
-`@AutoConfigureRestDocs` customizes the `MockMvc` bean to use Spring REST Docs when testing Servlet-based web applications.
+`@AutoConfigureRestDocs` customizes the `MockMvc` bean to use Spring REST Docs when testing servlet-based web applications.
 You can inject it by using `@Autowired` and use it in your tests as you normally would when using Mock MVC and Spring REST Docs, as shown in the following example:
 
 [source,java,indent=0,subs="verbatim"]

spring-boot-project/spring-boot-docs/src/docs/asciidoc/getting-started/system-requirements.adoc

@@ -37,4 +37,4 @@ Spring Boot supports the following embedded servlet containers:
 | 4.0
 |===
 
-You can also deploy Spring Boot applications to any Servlet 3.1+ compatible container.
+You can also deploy Spring Boot applications to any servlet 3.1+ compatible container.

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

@@ -21,7 +21,7 @@ include::{docs-java}/howto/jersey/springsecurity/JerseySetStatusOverSendErrorCon
 [[howto.jersey.alongside-another-web-framework]]
 === Use Jersey Alongside Another Web Framework
 To use Jersey alongside another web framework, such as Spring MVC, it should be configured so that it will allow the other framework to handle requests that it cannot handle.
-First, configure Jersey to use a Filter rather than a Servlet by configuring the configprop:spring.jersey.type[] application property with a value of `filter`.
+First, configure Jersey to use a filter rather than a servlet by configuring the configprop:spring.jersey.type[] application property with a value of `filter`.
 Second, configure your `ResourceConfig` to forward requests that would have resulted in a 404, as shown in the following example.
 
 [source,java,indent=0,subs="verbatim"]

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

@@ -141,7 +141,7 @@ See the {spring-boot-autoconfigure-module-code}/web/servlet/WebMvcAutoConfigurat
 
 [[howto.spring-mvc.multipart-file-uploads]]
 === Handling Multipart File Uploads
-Spring Boot embraces the Servlet 3 `javax.servlet.http.Part` API to support uploading files.
+Spring Boot embraces the servlet 3 `javax.servlet.http.Part` API to support uploading files.
 By default, Spring Boot configures Spring MVC with a maximum size of 1MB per file and a maximum of 10MB of file data in a single request.
 You may override these values, the location to which intermediate data is stored (for example, to the `/tmp` directory), and the threshold past which data is flushed to disk by using the properties exposed in the `MultipartProperties` class.
 For example, if you want to specify that files be unlimited, set the configprop:spring.servlet.multipart.max-file-size[] property to `-1`.

spring-boot-project/spring-boot-docs/src/docs/asciidoc/howto/traditional-deployment.adoc

@@ -8,10 +8,10 @@ This section answers common questions about traditional deployment.
 [[howto.traditional-deployment.war]]
 === Create a Deployable War File
 
-WARNING: Because Spring WebFlux does not strictly depend on the Servlet API and applications are deployed by default on an embedded Reactor Netty server, War deployment is not supported for WebFlux applications.
+WARNING: Because Spring WebFlux does not strictly depend on the servlet API and applications are deployed by default on an embedded Reactor Netty server, War deployment is not supported for WebFlux applications.
 
 The first step in producing a deployable war file is to provide a `SpringBootServletInitializer` subclass and override its `configure` method.
-Doing so makes use of Spring Framework's Servlet 3.0 support and lets you configure your application when it is launched by the servlet container.
+Doing so makes use of Spring Framework's servlet 3.0 support and lets you configure your application when it is launched by the servlet container.
 Typically, you should update your application's main class to extend `SpringBootServletInitializer`, as shown in the following example:
 
 [source,java,indent=0,subs="verbatim"]

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

@@ -41,8 +41,8 @@ The following Maven example shows how to exclude Tomcat and include Jetty for Sp
 	</dependency>
 ----
 
-NOTE: The version of the Servlet API has been overridden as, unlike Tomcat 9 and Undertow 2, Jetty 9.4 does not support Servlet 4.0.
-If you wish to use Jetty 10, which does support Servlet 4.0, override the `jetty.version` property rather than the `servlet-api.version` property.
+NOTE: The version of the servlet API has been overridden as, unlike Tomcat 9 and Undertow 2, Jetty 9.4 does not support servlet 4.0.
+If you wish to use Jetty 10, which does support servlet 4.0, override the `jetty.version` property rather than the `servlet-api.version` property.
 
 The following Gradle example configures the necessary dependencies and a {gradle-docs}/resolution_rules.html#sec:module_replacement[module replacement] to use Undertow in place of Reactor Netty for Spring WebFlux:
 
@@ -239,9 +239,9 @@ See the list of <<application-properties#application-properties>>.
 
 The previous sections covered already many common use cases, such as compression, SSL or HTTP/2.
 However, if a configuration key doesn't exist for your use case, you should then look at {spring-boot-module-api}/web/server/WebServerFactoryCustomizer.html[`WebServerFactoryCustomizer`].
-You can declare such a component and get access to the server factory relevant to your choice: you should select the variant for the chosen Server (Tomcat, Jetty, Reactor Netty, Undertow) and the chosen web stack (Servlet or Reactive).
+You can declare such a component and get access to the server factory relevant to your choice: you should select the variant for the chosen Server (Tomcat, Jetty, Reactor Netty, Undertow) and the chosen web stack (servlet or reactive).
 
-The example below is for Tomcat with the `spring-boot-starter-web` (Servlet stack):
+The example below is for Tomcat with the `spring-boot-starter-web` (servlet stack):
 
 [source,java,indent=0,subs="verbatim"]
 ----
@@ -293,21 +293,21 @@ In a servlet stack application, i.e. with the `spring-boot-starter-web`, there a
 
 [[howto.webserver.add-servlet-filter-listener.spring-bean]]
 ==== Add a Servlet, Filter, or Listener by Using a Spring Bean
-To add a `Servlet`, `Filter`, or Servlet `*Listener` by using a Spring bean, you must provide a `@Bean` definition for it.
+To add a `Servlet`, `Filter`, or servlet `*Listener` by using a Spring bean, you must provide a `@Bean` definition for it.
 Doing so can be very useful when you want to inject configuration or dependencies.
 However, you must be very careful that they do not cause eager initialization of too many other beans, because they have to be installed in the container very early in the application lifecycle.
 (For example, it is not a good idea to have them depend on your `DataSource` or JPA configuration.)
 You can work around such restrictions by initializing the beans lazily when first used instead of on initialization.
 
-In the case of `Filters` and `Servlets`, you can also add mappings and init parameters by adding a `FilterRegistrationBean` or a `ServletRegistrationBean` instead of or in addition to the underlying component.
+In the case of filters and servlets, you can also add mappings and init parameters by adding a `FilterRegistrationBean` or a `ServletRegistrationBean` instead of or in addition to the underlying component.
 
 [NOTE]
 ====
 If no `dispatcherType` is specified on a filter registration, `REQUEST` is used.
-This aligns with the Servlet Specification's default dispatcher type.
+This aligns with the servlet specification's default dispatcher type.
 ====
 
-Like any other Spring bean, you can define the order of Servlet filter beans; please make sure to check the "`<<web#web.servlet.embedded-container.servlets-filters-listeners.beans>>`" section.
+Like any other Spring bean, you can define the order of servlet filter beans; please make sure to check the "`<<web#web.servlet.embedded-container.servlets-filters-listeners.beans>>`" section.
 
 
 
@@ -393,7 +393,7 @@ If the proxy adds the commonly used `X-Forwarded-For` and `X-Forwarded-Proto` he
 With this option, the Web servers themselves natively support this feature; you can check their specific documentation to learn about specific behavior.
 
 If this is not enough, Spring Framework provides a {spring-framework-docs}/web.html#filters-forwarded-headers[ForwardedHeaderFilter].
-You can register it as a Servlet Filter in your application by setting `server.forward-headers-strategy` is set to `FRAMEWORK`.
+You can register it as a servlet filter in your application by setting `server.forward-headers-strategy` is set to `FRAMEWORK`.
 
 TIP: If you are using Tomcat and terminating SSL at the proxy, configprop:server.tomcat.redirect-context-root[] should be set to `false`.
 This allows the `X-Forwarded-Proto` header to be honored before any redirects are performed.

spring-boot-project/spring-boot-docs/src/docs/asciidoc/web/graceful-shutdown.adoc

@@ -1,6 +1,6 @@
 [[web.graceful-shutdown]]
 == Graceful Shutdown
-Graceful shutdown is supported with all four embedded web servers (Jetty, Reactor Netty, Tomcat, and Undertow) and with both reactive and Servlet-based web applications.
+Graceful shutdown is supported with all four embedded web servers (Jetty, Reactor Netty, Tomcat, and Undertow) and with both reactive and servlet-based web applications.
 It occurs as part of closing the application context and is performed in the earliest phase of stopping `SmartLifecycle` beans.
 This stop processing uses a timeout which provides a grace period during which existing requests will be allowed to complete but no new requests will be permitted.
 The exact way in which new requests are not permitted varies depending on the web server that is being used.

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

@@ -5,7 +5,7 @@ Spring Boot simplifies development of reactive web applications by providing aut
 [[web.reactive.webflux]]
 === The "`Spring WebFlux Framework`"
 Spring WebFlux is the new reactive web framework introduced in Spring Framework 5.0.
-Unlike Spring MVC, it does not require the Servlet API, is fully asynchronous and non-blocking, and implements the https://www.reactive-streams.org/[Reactive Streams] specification through https://projectreactor.io/[the Reactor project].
+Unlike Spring MVC, it does not require the servlet API, is fully asynchronous and non-blocking, and implements the https://www.reactive-streams.org/[Reactive Streams] specification through https://projectreactor.io/[the Reactor project].
 
 Spring WebFlux comes in two flavors: functional and annotation-based.
 The annotation-based one is quite close to the Spring MVC model, as shown in the following example:
@@ -120,7 +120,7 @@ So, if there is an `index.html` in any of your locations on startup, it is the h
 In addition to the "`standard`" static resource locations listed earlier, a special case is made for https://www.webjars.org/[Webjars content].
 Any resources with a path in `+/webjars/**+` are served from jar files if they are packaged in the Webjars format.
 
-TIP: Spring WebFlux applications do not strictly depend on the Servlet API, so they cannot be deployed as war files and do not use the `src/main/webapp` directory.
+TIP: Spring WebFlux applications do not strictly depend on the servlet API, so they cannot be deployed as war files and do not use the `src/main/webapp` directory.
 
 
 

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

@@ -124,7 +124,7 @@ For instance, relocating all resources to `/resources/**` can be achieved as fol
 ----
 
 You can also customize the static resource locations by using the configprop:spring.web.resources.static-locations[] property (replacing the default values with a list of directory locations).
-The root Servlet context path, `"/"`, is automatically added as a location as well.
+The root servlet context path, `"/"`, is automatically added as a location as well.
 
 In addition to the "`standard`" static resource locations mentioned earlier, a special case is made for https://www.webjars.org/[Webjars content].
 Any resources with a path in `+/webjars/**+` are served from jar files if they are packaged in the Webjars format.
@@ -287,7 +287,7 @@ NOTE: `PathPatternParser` is an optimized implementation but restricts usage of
 {spring-framework-docs}/web.html#mvc-ann-requestmapping-uri-templates[some path patterns variants]
 and is incompatible with suffix pattern matching (configprop:spring.mvc.pathmatch.use-suffix-pattern[deprecated],
 configprop:spring.mvc.pathmatch.use-registered-suffix-pattern[deprecated]) or mapping the `DispatcherServlet`
-with a Servlet prefix (configprop:spring.mvc.servlet.path[]).
+with a servlet prefix (configprop:spring.mvc.servlet.path[]).
 
 
 
@@ -429,7 +429,7 @@ Note that the default `FilterRegistrationBean` does not include the `ERROR` disp
 [[web.servlet.spring-mvc.error-handling.in-a-war-deployment]]
 ===== Error handling in a war deployment
 When deployed to a servlet container, Spring Boot uses its error page filter to forward a request with an error status to the appropriate error page.
-This is necessary as the Servlet specification does not provide an API for registering error pages.
+This is necessary as the servlet specification does not provide an API for registering error pages.
 Depending on the container that you are deploying your war file to and the technologies that your application uses, some additional configuration may be required.
 
 The error page filter can only forward the request to the correct error page if the response has not already been committed.
@@ -487,12 +487,12 @@ Since the `Endpoint` is a Spring `@Component`, its lifecycle is managed by Sprin
 By default, the Jersey servlet is registered and mapped to `/*`.
 You can change the mapping by adding `@ApplicationPath` to your `ResourceConfig`.
 
-By default, Jersey is set up as a Servlet in a `@Bean` of type `ServletRegistrationBean` named `jerseyServletRegistration`.
+By default, Jersey is set up as a servlet in a `@Bean` of type `ServletRegistrationBean` named `jerseyServletRegistration`.
 By default, the servlet is initialized lazily, but you can customize that behavior by setting `spring.jersey.servlet.load-on-startup`.
 You can disable or override that bean by creating one of your own with the same name.
 You can also use a filter instead of a servlet by setting `spring.jersey.type=filter` (in which case, the `@Bean` to replace or override is `jerseyFilterRegistration`).
 The filter has an `@Order`, which you can set with `spring.jersey.filter.order`.
-When using Jersey as a filter, a Servlet that will handle any requests that are not intercepted by Jersey must be present.
+When using Jersey as a filter, a servlet that will handle any requests that are not intercepted by Jersey must be present.
 If your application does not contain such a servlet, you may want to enable the default servlet by setting configprop:server.servlet.register-default-servlet[] to `true`.
 Both the servlet and the filter registrations can be given init parameters by using `spring.jersey.init.*` to specify a map of properties.
 
@@ -508,7 +508,7 @@ By default, the embedded server listens for HTTP requests on port `8080`.
 
 [[web.servlet.embedded-container.servlets-filters-listeners]]
 ==== Servlets, Filters, and listeners
-When using an embedded servlet container, you can register servlets, filters, and all the listeners (such as `HttpSessionListener`) from the Servlet spec, either by using Spring beans or by scanning for Servlet components.
+When using an embedded servlet container, you can register servlets, filters, and all the listeners (such as `HttpSessionListener`) from the servlet spec, either by using Spring beans or by scanning for servlet components.
 
 
 
@@ -523,12 +523,12 @@ Filters map to `+/*+`.
 
 If convention-based mapping is not flexible enough, you can use the `ServletRegistrationBean`, `FilterRegistrationBean`, and `ServletListenerRegistrationBean` classes for complete control.
 
-It is usually safe to leave Filter beans unordered.
+It is usually safe to leave filter beans unordered.
 If a specific order is required, you should annotate the `Filter` with `@Order` or make it implement `Ordered`.
 You cannot configure the order of a `Filter` by annotating its bean method with `@Order`.
 If you cannot change the `Filter` class to add `@Order` or implement `Ordered`, you must define a `FilterRegistrationBean` for the `Filter` and set the registration bean's order using the `setOrder(int)` method.
-Avoid configuring a Filter that reads the request body at `Ordered.HIGHEST_PRECEDENCE`, since it might go against the character encoding configuration of your application.
-If a Servlet filter wraps the request, it should be configured with an order that is less than or equal to `OrderedFilter.REQUEST_WRAPPER_FILTER_MAX_ORDER`.
+Avoid configuring a filter that reads the request body at `Ordered.HIGHEST_PRECEDENCE`, since it might go against the character encoding configuration of your application.
+If a servlet filter wraps the request, it should be configured with an order that is less than or equal to `OrderedFilter.REQUEST_WRAPPER_FILTER_MAX_ORDER`.
 
 TIP: To see the order of every `Filter` in your application, enable debug level logging for the `web` <<features#features.logging.log-groups,logging group>> (`logging.level.web=debug`).
 Details of the registered filters, including their order and URL patterns, will then be logged at startup.
@@ -540,7 +540,7 @@ If you need to register a `Filter` that interacts with other beans, consider usi
 
 [[web.servlet.embedded-container.context-initializer]]
 ==== Servlet Context Initialization
-Embedded servlet containers do not directly execute the Servlet 3.0+ `javax.servlet.ServletContainerInitializer` interface or Spring's `org.springframework.web.WebApplicationInitializer` interface.
+Embedded servlet containers do not directly execute the servlet 3.0+ `javax.servlet.ServletContainerInitializer` interface or Spring's `org.springframework.web.WebApplicationInitializer` interface.
 This is an intentional design decision intended to reduce the risk that third party libraries designed to run inside a war may break Spring Boot applications.
 
 If you need to perform servlet context initialization in a Spring Boot application, you should register a bean that implements the `org.springframework.boot.web.servlet.ServletContextInitializer` interface.

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

@@ -1,14 +1,14 @@
 [[web.spring-session]]
 == Spring Session
 Spring Boot provides {spring-session}[Spring Session] auto-configuration for a wide range of data stores.
-When building a Servlet web application, the following stores can be auto-configured:
+When building a servlet web application, the following stores can be auto-configured:
 
 * JDBC
 * Redis
 * Hazelcast
 * MongoDB
 
-The Servlet auto-configuration replaces the need to use `@Enable*HttpSession`.
+The servlet auto-configuration replaces the need to use `@Enable*HttpSession`.
 
 When building a reactive web application, the following stores can be auto-configured:
 
@@ -42,9 +42,9 @@ For instance, it is possible to customize the name of the table for the JDBC sto
 ----
 
 For setting the timeout of the session you can use the configprop:spring.session.timeout[] property.
-If that property is not set with a Servlet web application, the auto-configuration falls back to the value of configprop:server.servlet.session.timeout[].
+If that property is not set with a servlet web application, the auto-configuration falls back to the value of configprop:server.servlet.session.timeout[].
 
 
-You can take control over Spring Session's configuration using `@Enable*HttpSession` (Servlet) or `@Enable*WebSession` (Reactive).
+You can take control over Spring Session's configuration using `@Enable*HttpSession` (servlet) or `@Enable*WebSession` (reactive).
 This will cause the auto-configuration to back off.
 Spring Session can then be configured using the annotation's attributes rather than the previously described configuration properties.