diff --git a/framework-docs/modules/ROOT/nav.adoc b/framework-docs/modules/ROOT/nav.adoc index e51cc221fa3..931133b2d95 100644 --- a/framework-docs/modules/ROOT/nav.adoc +++ b/framework-docs/modules/ROOT/nav.adoc @@ -261,7 +261,6 @@ **** xref:web/websocket/stomp/configuration-performance.adoc[] **** xref:web/websocket/stomp/stats.adoc[] **** xref:web/websocket/stomp/testing.adoc[] -** xref:web/integration.adoc[] * xref:web-reactive.adoc[] ** xref:web/webflux.adoc[] *** xref:web/webflux/new-framework.adoc[] diff --git a/framework-docs/modules/ROOT/pages/web/integration.adoc b/framework-docs/modules/ROOT/pages/web/integration.adoc deleted file mode 100644 index d39a9ff0617..00000000000 --- a/framework-docs/modules/ROOT/pages/web/integration.adoc +++ /dev/null @@ -1,186 +0,0 @@ -[[web-integration]] -= Other Web Frameworks - -This chapter details Spring's integration with third-party web frameworks. - -One of the core value propositions of the Spring Framework is that of enabling -_choice_. In a general sense, Spring does not force you to use or buy into any -particular architecture, technology, or methodology (although it certainly recommends -some over others). This freedom to pick and choose the architecture, technology, or -methodology that is most relevant to a developer and their development team is -arguably most evident in the web area, where Spring provides its own web frameworks -(xref:web/webmvc.adoc#mvc[Spring MVC] and xref:web/webflux.adoc#webflux[Spring WebFlux]) -while, at the same time, supporting integration with a number of popular third-party -web frameworks. - - -[[web-integration-common]] -== Common Configuration - -Before diving into the integration specifics of each supported web framework, let us -first take a look at common Spring configuration that is not specific to any one web -framework. (This section is equally applicable to Spring's own web framework variants.) - -One of the concepts (for want of a better word) espoused by Spring's lightweight -application model is that of a layered architecture. Remember that in a "classic" -layered architecture, the web layer is but one of many layers. It serves as one of the -entry points into a server-side application, and it delegates to service objects -(facades) that are defined in a service layer to satisfy business-specific (and -presentation-technology agnostic) use cases. In Spring, these service objects, any other -business-specific objects, data-access objects, and others exist in a distinct "business -context", which contains no web or presentation layer objects (presentation objects, -such as Spring MVC controllers, are typically configured in a distinct "presentation -context"). This section details how you can configure a Spring container (a -`WebApplicationContext`) that contains all of the 'business beans' in your application. - -Moving on to specifics, all you need to do is declare a -{spring-framework-api}/web/context/ContextLoaderListener.html[`ContextLoaderListener`] -in the standard Jakarta EE servlet `web.xml` file of your web application and add a -`contextConfigLocation` `` section (in the same file) that defines which -set of Spring XML configuration files to load. - -Consider the following `` configuration: - -[source,xml,indent=0,subs="verbatim,quotes"] ----- - - org.springframework.web.context.ContextLoaderListener - ----- - -Further consider the following `` configuration: - -[source,xml,indent=0,subs="verbatim,quotes"] ----- - - contextConfigLocation - /WEB-INF/applicationContext*.xml - ----- - -If you do not specify the `contextConfigLocation` context parameter, the -`ContextLoaderListener` looks for a file called `/WEB-INF/applicationContext.xml` to -load. Once the context files are loaded, Spring creates a -{spring-framework-api}/web/context/WebApplicationContext.html[`WebApplicationContext`] -object based on the bean definitions and stores it in the `ServletContext` of the web -application. - -All Java web frameworks are built on top of the Servlet API, so you can use the -following code snippet to get access to this "business context" `ApplicationContext` -created by the `ContextLoaderListener`. - -The following example shows how to get the `WebApplicationContext`: - -[source,java,indent=0,subs="verbatim,quotes"] ----- - WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(servletContext); ----- - -The -{spring-framework-api}/web/context/support/WebApplicationContextUtils.html[`WebApplicationContextUtils`] -class is for convenience, so you need not remember the name of the `ServletContext` -attribute. Its `getWebApplicationContext()` method returns `null` if an object -does not exist under the `WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE` -key. Rather than risk getting `NullPointerExceptions` in your application, it is better -to use the `getRequiredWebApplicationContext()` method. This method throws an exception -when the `ApplicationContext` is missing. - -Once you have a reference to the `WebApplicationContext`, you can retrieve beans by their -name or type. Most developers retrieve beans by name and then cast them to one of their -implemented interfaces. - -Fortunately, most of the frameworks in this section have simpler ways of looking up beans. -Not only do they make it easy to get beans from a Spring container, but they also let you -use dependency injection on their controllers. Each web framework section has more detail -on its specific integration strategies. - - -[[jsf]] -== JSF - -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, 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 -environment. Spring's JSF support is not actively evolved anymore and primarily -exists for migration purposes when modernizing older JSF-based applications. - -The key element in Spring's JSF integration is the JSF `ELResolver` mechanism. - -[[jsf-springbeanfaceselresolver]] -=== Spring Bean Resolver - -`SpringBeanFacesELResolver` is a JSF compliant `ELResolver` implementation, -integrating with the standard Unified EL as used by JSF and JSP. It delegates to -Spring's "business context" `WebApplicationContext` first and then to the -default resolver of the underlying JSF implementation. - -Configuration-wise, you can define `SpringBeanFacesELResolver` in your JSF -`faces-context.xml` file, as the following example shows: - -[source,xml,indent=0,subs="verbatim,quotes"] ----- - - - org.springframework.web.jsf.el.SpringBeanFacesELResolver - ... - - ----- - -[[jsf-facescontextutils]] -=== Using `FacesContextUtils` - -A custom `ELResolver` works well when mapping your properties to beans in -`faces-config.xml`, but, at times, you may need to explicitly grab a bean. -The {spring-framework-api}/web/jsf/FacesContextUtils.html[`FacesContextUtils`] -class makes this easy. It is similar to `WebApplicationContextUtils`, except that -it takes a `FacesContext` parameter rather than a `ServletContext` parameter. - -The following example shows how to use `FacesContextUtils`: - -[source,java,indent=0,subs="verbatim,quotes"] ----- - ApplicationContext ctx = FacesContextUtils.getWebApplicationContext(FacesContext.getCurrentInstance()); ----- - - -[[struts]] -== Apache Struts - -Invented by Craig McClanahan, https://struts.apache.org[Struts] is an open-source project -hosted by the Apache Software Foundation. Struts 1.x greatly simplified the -JSP/Servlet programming paradigm and won over many developers who were using proprietary -frameworks. It simplified the programming model; it was open source; and it had a large -community, which let the project grow and become popular among Java web developers. - -As a successor to the original Struts 1.x, check out Struts 2.x or more recent versions -as well as the Struts-provided -https://struts.apache.org/plugins/spring/[Spring Plugin] for built-in Spring integration. - - -[[tapestry]] -== Apache Tapestry - -https://tapestry.apache.org/[Tapestry] is a "Component oriented framework for creating -dynamic, robust, highly scalable web applications in Java." - -While Spring has its own xref:web/webmvc.adoc#mvc[powerful web layer], there are a number of unique -advantages to building an enterprise Java application by using a combination of Tapestry -for the web user interface and the Spring container for the lower layers. - -For more information, see Tapestry's dedicated -https://tapestry.apache.org/integrating-with-spring-framework.html[integration module for Spring]. - - -[[web-integration-resources]] -== Further Resources - -The following links go to further resources about the various web frameworks described in -this chapter. - -* The https://www.oracle.com/java/technologies/javaserverfaces.html[JSF] homepage -* The https://struts.apache.org/[Struts] homepage -* The https://tapestry.apache.org/[Tapestry] homepage