## Uses of Interface
org.springframework.core.env.EnvironmentCapable

- Packages that use EnvironmentCapable
  Package | Description
  --- | ---
  org.springframework.beans.factory.groovy | Support package for Groovy-based bean definitions.
  org.springframework.beans.factory.support | Classes supporting the `org.springframework.beans.factory` package.
  org.springframework.beans.factory.xml | Contains an abstract XML-based `BeanFactory` implementation, including a standard "spring-beans" XSD.
  org.springframework.context | This package builds on the beans package to add support for message sources and for the Observer design pattern, and the ability for application objects to obtain resources using a consistent API.
  org.springframework.context.annotation | Annotation support for the Application Context, including JSR-250 "common" annotations, component-scanning, and Java-based metadata for creating Spring-managed objects.
  org.springframework.context.support | Classes supporting the org.springframework.context package, such as abstract base classes for ApplicationContext implementations and a MessageSource implementation.
  org.springframework.jca.context | Integration package that allows for deploying a Spring application context as a JCA 1.7 compliant RAR file.
  org.springframework.orm.hibernate5.support | Classes supporting the `org.springframework.orm.hibernate5` package.
  org.springframework.orm.jpa.support | Classes supporting the `org.springframework.orm.jpa` package.
  org.springframework.web.context | Contains a variant of the application context interface for web applications, and the ContextLoaderListener that bootstraps a root web application context.
  org.springframework.web.context.support | Classes supporting the `org.springframework.web.context` package, such as WebApplicationContext implementations and various utility classes.
  org.springframework.web.filter | Provides generic filter base classes allowing for bean-style configuration.
  org.springframework.web.multipart.support | Support classes for the multipart resolution framework.
  org.springframework.web.servlet | Provides servlets that integrate with the application context infrastructure, and the core interfaces and classes for the Spring web MVC framework.
  org.springframework.web.servlet.resource | Support classes for serving static resources.

- - ### Uses of EnvironmentCapable in org.springframework.beans.factory.groovy

    Classes in org.springframework.beans.factory.groovy that implement EnvironmentCapable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `GroovyBeanDefinitionReader` A Groovy-based reader for Spring bean definitions: like a Groovy builder, but more of a DSL for Spring configuration.

  - ### Uses of EnvironmentCapable in org.springframework.beans.factory.support

    Classes in org.springframework.beans.factory.support that implement EnvironmentCapable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractBeanDefinitionReader` Abstract base class for bean definition readers which implement the `BeanDefinitionReader` interface.
    `class` | `PropertiesBeanDefinitionReader` Deprecated. as of 5.3, in favor of Spring's common bean definition formats and/or custom reader implementations

  - ### Uses of EnvironmentCapable in org.springframework.beans.factory.xml

    Classes in org.springframework.beans.factory.xml that implement EnvironmentCapable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `XmlBeanDefinitionReader` Bean definition reader for XML bean definitions.

  - ### Uses of EnvironmentCapable in org.springframework.context

    Subinterfaces of EnvironmentCapable in org.springframework.context
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `ApplicationContext` Central interface to provide configuration for an application.
    `interface` | `ConfigurableApplicationContext` SPI interface to be implemented by most if not all application contexts.

  - ### Uses of EnvironmentCapable in org.springframework.context.annotation

    Classes in org.springframework.context.annotation that implement EnvironmentCapable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AnnotationConfigApplicationContext` Standalone application context, accepting component classes as input — in particular `@Configuration`-annotated classes, but also plain `@Component` types and JSR-330 compliant classes using `javax.inject` annotations.
    `class` | `ClassPathBeanDefinitionScanner` A bean definition scanner that detects bean candidates on the classpath, registering corresponding bean definitions with a given registry (`BeanFactory` or `ApplicationContext`).
    `class` | `ClassPathScanningCandidateComponentProvider` A component provider that scans for candidate components starting from a specified base package.

  - ### Uses of EnvironmentCapable in org.springframework.context.support

    Classes in org.springframework.context.support that implement EnvironmentCapable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractApplicationContext` Abstract implementation of the `ApplicationContext` interface.
    `class` | `AbstractRefreshableApplicationContext` Base class for `ApplicationContext` implementations which are supposed to support multiple calls to `AbstractApplicationContext.refresh()`, creating a new internal bean factory instance every time.
    `class` | `AbstractRefreshableConfigApplicationContext` `AbstractRefreshableApplicationContext` subclass that adds common handling of specified config locations.
    `class` | `AbstractXmlApplicationContext` Convenient base class for `ApplicationContext` implementations, drawing configuration from XML documents containing bean definitions understood by an `XmlBeanDefinitionReader`.
    `class` | `ClassPathXmlApplicationContext` Standalone XML application context, taking the context definition files from the class path, interpreting plain paths as class path resource names that include the package path (e.g.
    `class` | `FileSystemXmlApplicationContext` Standalone XML application context, taking the context definition files from the file system or from URLs, interpreting plain paths as relative file system locations (e.g.
    `class` | `GenericApplicationContext` Generic ApplicationContext implementation that holds a single internal `DefaultListableBeanFactory` instance and does not assume a specific bean definition format.
    `class` | `GenericGroovyApplicationContext` An `ApplicationContext` implementation that extends `GenericApplicationContext` and implements `GroovyObject` such that beans can be retrieved with the dot de-reference syntax instead of using `AbstractApplicationContext.getBean(java.lang.String)`.
    `class` | `GenericXmlApplicationContext` Convenient application context with built-in XML support.
    `class` | `StaticApplicationContext` `ApplicationContext` implementation which supports programmatic registration of beans and messages, rather than reading bean definitions from external configuration sources.

  - ### Uses of EnvironmentCapable in org.springframework.jca.context

    Classes in org.springframework.jca.context that implement EnvironmentCapable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ResourceAdapterApplicationContext` `ApplicationContext` implementation for a JCA ResourceAdapter.

  - ### Uses of EnvironmentCapable in org.springframework.orm.hibernate5.support

    Classes in org.springframework.orm.hibernate5.support that implement EnvironmentCapable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `OpenSessionInViewFilter` Servlet Filter that binds a Hibernate Session to the thread for the entire processing of the request.

  - ### Uses of EnvironmentCapable in org.springframework.orm.jpa.support

    Classes in org.springframework.orm.jpa.support that implement EnvironmentCapable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `OpenEntityManagerInViewFilter` Servlet Filter that binds a JPA EntityManager to the thread for the entire processing of the request.

  - ### Uses of EnvironmentCapable in org.springframework.web.context

    Subinterfaces of EnvironmentCapable in org.springframework.web.context
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `ConfigurableWebApplicationContext` Interface to be implemented by configurable web application contexts.
    `interface` | `WebApplicationContext` Interface to provide configuration for a web application.

  - ### Uses of EnvironmentCapable in org.springframework.web.context.support

    Classes in org.springframework.web.context.support that implement EnvironmentCapable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractRefreshableWebApplicationContext` `AbstractRefreshableApplicationContext` subclass which implements the `ConfigurableWebApplicationContext` interface for web environments.
    `class` | `AnnotationConfigWebApplicationContext` `WebApplicationContext` implementation which accepts component classes as input — in particular `@Configuration` classes, but also plain `@Component` classes as well as JSR-330 compliant classes using `javax.inject` annotations.
    `class` | `GenericWebApplicationContext` Subclass of `GenericApplicationContext`, suitable for web environments.
    `class` | `GroovyWebApplicationContext` `WebApplicationContext` implementation which takes its configuration from Groovy bean definition scripts and/or XML files, as understood by a `GroovyBeanDefinitionReader`.
    `class` | `StaticWebApplicationContext` Static `WebApplicationContext` implementation for testing.
    `class` | `XmlWebApplicationContext` `WebApplicationContext` implementation which takes its configuration from XML documents, understood by an `XmlBeanDefinitionReader`.

  - ### Uses of EnvironmentCapable in org.springframework.web.filter

    Classes in org.springframework.web.filter that implement EnvironmentCapable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractRequestLoggingFilter` Base class for `Filter`s that perform logging operations before and after a request is processed.
    `class` | `CharacterEncodingFilter` Servlet Filter that allows one to specify a character encoding for requests.
    `class` | `CommonsRequestLoggingFilter` Simple request logging filter that writes the request URI (and optionally the query string) to the Commons Log.
    `class` | `CorsFilter` `Filter` to handle CORS pre-flight requests and intercept CORS simple and actual requests with a `CorsProcessor`, and to update the response, e.g.
    `class` | `DelegatingFilterProxy` Proxy for a standard Servlet Filter, delegating to a Spring-managed bean that implements the Filter interface.
    `class` | `FormContentFilter` `Filter` that parses form data for HTTP PUT, PATCH, and DELETE requests and exposes it as Servlet request parameters.
    `class` | `ForwardedHeaderFilter` Extract values from "Forwarded" and "X-Forwarded-*" headers, wrap the request and response, and make they reflect the client-originated protocol and address in the following methods: `getServerName()` `getServerPort()` `getScheme()` `isSecure()` `sendRedirect(String)`.
    `class` | `GenericFilterBean` Simple base implementation of `Filter` which treats its config parameters (`init-param` entries within the `filter` tag in `web.xml`) as bean properties.
    `class` | `HiddenHttpMethodFilter` `Filter` that converts posted method parameters into HTTP methods, retrievable via `HttpServletRequest.getMethod()`.
    `class` | `HttpPutFormContentFilter` Deprecated. as of 5.1 in favor of `FormContentFilter` which is the same but also handles DELETE.
    `class` | `OncePerRequestFilter` Filter base class that aims to guarantee a single execution per request dispatch, on any servlet container.
    `class` | `RelativeRedirectFilter` Overrides `HttpServletResponse.sendRedirect(String)` and handles it by setting the HTTP status and "Location" headers, which keeps the Servlet container from re-writing relative redirect URLs into absolute ones.
    `class` | `RequestContextFilter` Servlet Filter that exposes the request to the current thread, through both `LocaleContextHolder` and `RequestContextHolder`.
    `class` | `ServletContextRequestLoggingFilter` Simple request logging filter that writes the request URI (and optionally the query string) to the ServletContext log.
    `class` | `ShallowEtagHeaderFilter` `Filter` that generates an `ETag` value based on the content on the response.

  - ### Uses of EnvironmentCapable in org.springframework.web.multipart.support

    Classes in org.springframework.web.multipart.support that implement EnvironmentCapable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `MultipartFilter` Servlet Filter that resolves multipart requests via a `MultipartResolver`.

  - ### Uses of EnvironmentCapable in org.springframework.web.servlet

    Classes in org.springframework.web.servlet that implement EnvironmentCapable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `DispatcherServlet` Central dispatcher for HTTP request handlers/controllers, e.g.
    `class` | `FrameworkServlet` Base servlet for Spring's web framework.
    `class` | `HttpServletBean` Simple extension of `HttpServlet` which treats its config parameters (`init-param` entries within the `servlet` tag in `web.xml`) as bean properties.

  - ### Uses of EnvironmentCapable in org.springframework.web.servlet.resource

    Classes in org.springframework.web.servlet.resource that implement EnvironmentCapable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ResourceUrlEncodingFilter` A filter that wraps the `HttpServletResponse` and overrides its `encodeURL` method in order to translate internal resource request URLs into public URL paths for external use.