Content deleted Content added
m Reverted edits by 136.232.13.166 (talk): unexplained content removal (HG) (3.4.12) Tags: Huggle Rollback Disambiguation links added |
|||
| (23 intermediate revisions by 16 users not shown) | |||
Line 1:
{{About|the Spring Framework|the Spring Boot|Spring Boot||}}
{{Short description|Application framework for Java platform}}
{{Infobox software
Line 17 ⟶ 18:
| license = [[Apache License]] 2.0
}}
The '''Spring Framework''' is an [[application framework]] and [[inversion of control]] [[Servlet container|container]] for the [[Java platform]].{{sfn | Deinum |
==Version history==
Line 24 ⟶ 25:
! Version
! Date
|-
| 0.9 || 2003
|▼
|-
| 1.0 || March 24, 2004
|-
| 2.0 || 2006
|▼
|-
| 3.0 || 2009
|-
| 4.0 || 2013
|-
| 5.0 || 2017
|-
▲|-
▲| November 16, 2022
| 6.1 || November 16, 2023
▲|-
| 6.2 || November 14, 2024
|-
|}
The first version was written by [[Rod Johnson (programmer)|Rod Johnson]], who released the framework with the publication of his book ''Expert One-on-One J2EE Design and Development'' in October 2002. The framework was first released under the [[Apache License|Apache 2.0 license]] in June 2003. The first production release, 1.0, was released in March 2004.<ref>{{cite web |url=https://spring.io/blog/2004/03/24/spring-framework-1-0-final-released | date=24 March 2014 | title=Spring Framework 1.0 Final Released | website=Official Spring Framework blog |access-date=1 March 2021}}</ref> The Spring 1.2.6 framework won a [[Jolt Awards|Jolt productivity award]] and a [[JAX Innovation Award]] in 2006.<ref>[http://www.ddj.com/architect/187900423?pgno=10 Jolt winners 2006]</ref><ref>{{Cite web |url=http://jax-award.de/jax_award06/gewinner_de.php |title=JAX Innovation Award Gewinner 2006 |access-date=2009-08-12 |archive-url=https://web.archive.org/web/20090817202514/http://jax-award.de/jax_award06/gewinner_de.php |archive-date=2009-08-17 |url-status=dead }}</ref> Spring 2.0 was released in October 2006, Spring 2.5 in November 2007, Spring 3.0 in December 2009, Spring 3.1 in December 2011, and Spring 3.2.5 in November 2013.<ref>{{cite web |url=https://spring.io/blog/2013/11/07/spring-framework-3-2-5-released |date=7 Nov 2013 | title=Spring Framework 3.2.5 Released | website=Official Spring website | access-date=16 October 2016}}</ref> Spring Framework 4.0 was released in December 2013.<ref>{{cite web|url=https://spring.io/blog/2013/12/12/announcing-spring-framework-4-0-ga-release/|title=Announcing Spring Framework 4.0 GA Release|publisher=Spring blog|date=12 December 2013}}</ref> Notable improvements in Spring 4.0 included support for Java SE (Standard Edition) 8, [[Groovy (programming language)|Groovy]] 2,{{sfn | Walls | 2016 | loc=§5 | pp=92-106}}{{sfn | Cosmina | Harrop | Schaefer | Ho | 2017 | loc=§4 Spring Configuration in Detail and Spring Boot | pp=125-126 }} some aspects of Java EE 7, and [[WebSocket]].{{sfn | Cosmina | Harrop | Schaefer | Ho | 2017 | loc = §1 Introducing Spring | pp=1-18}}
Spring Framework 4.2.0 was released on 31 July 2015 and was immediately upgraded to version 4.2.1, which was released on 01 Sept 2015.<ref>{{cite web|url=http://spring.io/blog/2015/07/31/spring-framework-4-2-goes-ga|title=Spring Framework 4.2 goes GA|publisher=Spring Blog|date=31 July 2015}}</ref> It is ''"compatible with Java 6, 7 and 8, with a focus on core refinements and modern web capabilities"''.<ref name="spring-4.2">{{cite web|url=http://spring.io/blog/2015/07/31/spring-framework-4-2-goes-ga|title=Spring Framework 4.2 goes GA|publisher=Spring Blog}}</ref>
Line 72 ⟶ 58:
==Modules==
The Spring Framework includes several modules that provide a range of services:
* Spring Core Container: this is the base module of Spring{{sfn | Walls | 2019 | p=48}} and provides spring containers (<code>BeanFactory</code> and <code>ApplicationContext</code>).<ref>[http://docs.spring.io/spring-framework/docs/current/spring-framework-reference/html/beans.html#beans-introduction Spring Framework documentation for the Core Container]</ref>{{sfn | Johnson | Höller | Arendsen | Risberg | 2005 | loc=Chapter §2 - The Bean Factory and ApplicationContext}}{{sfn | Deinum |
* [[Aspect-oriented programming]]: enables implementing [[cross-cutting concern]]s.{{sfn|Johnson|Höller|Arendsen|Risberg|2005|loc=Chapter §4 - Spring and AOP}}{{sfn | Deinum |
* [[Authentication]] and [[authorization]]: configurable security processes that support a range of standards, protocols, tools and practices via the [[Spring Security]] sub-project (formerly Acegi Security System for Spring).{{sfn|Johnson|Höller|Arendsen|Risberg|2005|loc=Acegi Security System for Spring}}{{sfn | Deinum |
* [[Convention over configuration]]: a rapid application development solution for Spring-based enterprise applications is offered in the [[Spring Roo]] module.
* [[Data access]]: working with [[RDBMS|relational database management systems]] on the Java platform using [[Java Database Connectivity]] (JDBC){{sfn|Walls|2019|pp=56-59}} and [[object-relational mapping]] tools and with [[NoSQL]]{{sfn | Deinum |
* [[Inversion of control]] container: configuration of application components and lifecycle management of Java objects, done mainly via [[dependency injection]].{{sfn|Johnson|Höller|Arendsen|Risberg|2005|loc=Chapter §2 - The Bean Factory and ApplicationContext}}
* Messaging: declarative registration of message listener objects for transparent message-consumption from [[message queue]]s via [[Java Message Service]] (JMS), improvement of message sending over standard JMS APIs.{{sfn | Deinum |
* [[Model–view–controller]]: an [[HTTP]]- and [[Java Servlet API|servlet]]-based framework providing hooks for extension and customization for web applications and [[REST]]ful (representational state transfer) Web services.{{sfn | Johnson | Höller | Arendsen | Risberg | 2005 | loc=Chapter §12 - Web MVC Framework}}{{sfn | Deinum |
* Remote access framework: declarative [[remote procedure call]] (RPC)-style{{sfn | Deinum |
Marshalling|pp=641-658}}{{sfn | Johnson | Höller | Arendsen | Risberg | 2005 | loc=Chapter §8 - Lightweight Remoting}}
* [[Transaction processing|Transaction management]]: unifies several transaction management APIs and coordinates transactions for Java objects.{{sfn | Johnson | Höller | Arendsen | Risberg | 2005 | loc=Chapter §9 - Supporting Services}}{{sfn | Deinum |
* Remote management: declarative exposure and management of Java objects for local or remote configuration via [[Java Management Extensions]] (JMX).{{sfn | Johnson | Höller | Arendsen | Risberg | 2005 | loc=Chapter §9 - Supporting Services}}{{sfn | Deinum |
* [[Software testing|Testing]]: support classes for writing [[Unit testing|unit test]]s{{sfn | Deinum |
* WebFlux support: support for using reactive runtimes or web servers such as UnderTow and [[Netty (software)|Netty]].{{sfn | Deinum | Cosmina | 2021 | loc=§2 Spring Framework Fundamentals - The Spring Framework | pp=22-25}}{{sfn | Musib | 2022 | loc=§8.3 Introducing Spring WebFlux | p=358}}
* Web Socket support: Support for communicating using the WebSocket protocol. The artifact for this module is <code>spring-websocket</code>.
Line 92 ⟶ 78:
=== Inversion of control container ===
The [[inversion of control]] (IoC) container is the core container in the Spring Framework.{{sfn | Deinum |
In many cases, one need not use the container when using other parts of the Spring Framework, although using it will likely make an application easier to configure and customize. The Spring container provides a consistent mechanism to configure applications{{sfn | Johnson | Hoeller | 2004}}{{rp | p=122}} and integrates with almost all Java environments, from small-scale applications to large enterprise applications.
Line 99 ⟶ 85:
====Creating and managing beans====
Objects created by the container are called managed objects or [[JavaBeans|beans]].{{sfn | Deinum |
The {{code|@Configuration}} is a Spring-specific annotation that marks a class as the configuration class. The configuration class provides the beans to the Spring {{code|ApplicationContext}}.{{sfn|Walls|2019|loc=§1.1 Getting started with Spring - What is Spring|pp=4-6}} Each of the methods in the Spring configuration class is configured with the {{code|@Bean}} annotation. The {{code|ApplicationContext}} interface will then return the objects configured with the {{code|@Bean}} annotation as beans. The advantage of
==== Types of Inversion of Control ====
Line 114 ⟶ 100:
====Autowiring====
The Spring framework has a feature known as autowiring, which uses the
There are several annotations that can be used for autowiring POJOs, including the Spring-specific annotation {{code|@Autowire}} (as well as several other Spring-specific annotations that help resolve autowire ambiguity such as the {{code|@Qualifier}} or {{code|@Primary}} annotations),{{sfn | Deinum |
The {{code|@Qualifier}} annotation can be used on a class that defines a bean to inform Spring to prioritize the bean creation when autowiring it by '''name'''.{{sfn | Cosmina | Harrop | Schaefer | Ho | 2017 | loc=§3 Introducing IoC and DI in Spring - Autowiring Your Beans | pp=112-120 }}
The {{code|@Primary}} annotation can be used on a class that defines a bean to inform Spring to prioritize the bean creation when autowiring it by '''type'''.{{sfn | Cosmina | Harrop | Schaefer | Ho | 2017 | loc=§3 Introducing IoC and DI in Spring - Autowiring Your Beans | pp=112-120 }}
The {{code|@Resource}} annotation is an annotation that conforms to [[JSR 250]], or Common Annotations for the Java Platform
The {{code|@Inject}} annotation is an annotation that conforms to JSR 300, or Standard Annotations for injection ===Aspect-oriented programming framework===
{{main article | Aspect-oriented programming}}
The Spring Framework has its own [[Aspect-oriented programming]] (AOP) framework that modularizes cross-cutting concerns in [[Aspect (computer science)|aspects]].{{sfn | Deinum |
The Spring AOP framework is [[Proxy pattern|proxy pattern-based]].{{sfn | Deinum |
Compared to the [[AspectJ]] framework, Spring AOP is less powerful, but also less complicated.{{Citation needed|date=June 2023}} Spring 1.2 includes support to configure AspectJ aspects in the container. Spring 2.0 added more integration with AspectJ; for example, the [[pointcut]] language is reused and can be mixed with Spring AOP-based aspects.{{Citation needed|date=June 2023}} Further, Spring 2.0 added a Spring Aspects library that uses AspectJ to offer common Spring features such as declarative transaction management{{sfn | Deinum |
Spring AOP has been designed to work with cross-cutting concerns inside the Spring Framework.{{sfn | Johnson | Hoeller | 2004}}{{rp | p=473}} Any object which is created and configured by the container can be enriched using Spring AOP.
The Spring Framework uses Spring AOP internally for transaction management, security, remote access, and [[Java Management Extensions|JMX]].<ref>{{
Since version 2.0 of the framework, Spring provides two approaches to the AOP configuration:
Line 161 ⟶ 149:
===Data access framework===
Spring's data access framework addresses common difficulties developers face when working with databases in applications. Support is provided for all popular data access frameworks in Java: JDBC, [[IBATIS|iBatis]]/[[MyBatis]],{{sfn | Deinum |
For all of these supported frameworks, Spring provides these features
* Resource management – automatically acquiring and releasing database resources
* Exception handling – translating data access related exception to a Spring data access hierarchy{{sfn | Deinum |
* Transaction participation – transparent participation in ongoing transactions{{sfn | Johnson | Hoeller | 2004}}{{rp|pp=290–291}}
* Resource unwrapping – retrieving database objects from connection pool wrappers
* Abstraction for [[binary large object]] (BLOB) and [[character large object]] (CLOB) handling
All these features become available when using [[Template method pattern|template classes]] provided by Spring for each supported framework.{{sfn|Deinum
Together with Spring's transaction management, its data access framework offers a flexible abstraction for working with data access frameworks. The Spring Framework doesn't offer a common data access API; instead, the full power of the supported APIs is kept intact.{{Citation needed|date=June 2023}} The Spring Framework is the only framework available in Java that offers managed data access environments outside of an application server or container.<ref>
Line 182 ⟶ 170:
While using Spring for transaction management with Hibernate, the following beans may have to be configured:
* A <code>[[Datasource]]</code> like <code>com.mchange.v2.c3p0.ComboPooledDataSource</code> or <code>org.apache.commons.dbcp.BasicDataSource</code>{{sfn | Deinum |
* A <code>SessionFactory</code> like <code>org.springframework.orm.hibernate3.LocalSessionFactoryBean</code> with a <code>DataSource</code> attribute{{sfn | Deinum |
* A <code>HibernateProperties</code>{{sfn | Johnson | Hoeller | 2004}}{{rp|p=173}} like <code>org.springframework.beans.factory.config.PropertiesFactoryBean</code>
* A <code>TransactionManager</code> like <code>org.springframework.orm.hibernate3.HibernateTransactionManager</code> with a <code>SessionFactory</code> attribute{{sfn | Deinum |
Other points of configuration include:
* An AOP configuration of cutting points.
Line 191 ⟶ 179:
===Transaction management===
Spring's transaction management framework brings an abstraction mechanism to the Java platform.{{sfn | Deinum |
* working with local and [[distributed transaction|global transaction]]s{{sfn | Johnson | Hoeller | 2004}}{{rp | p=258}} (local transaction does not require an [[application server]])
* working with [[nested transaction]]s{{sfn | Deinum |
* working with [[savepoint]]s{{sfn | Deinum |
* working in almost all environments of the Java platform
In comparison, [[Java Transaction API]] (JTA) only supports nested transactions and global transactions, and requires an application server (and in some cases, deployment of applications in an application server).
The Spring Framework ships a <code>PlatformTransactionManager</code>{{sfn | Deinum |
* Transactions managed on a JDBC Connection{{sfn | Deinum |
* Transactions managed on Object-relational mapping Units of Work{{sfn | Deinum |
* Transactions managed via the JTA
* Transactions managed on other resources, like [[object database]]s
Next to this abstraction mechanism the framework provides two ways of adding transaction management to applications:
* Procedurally, by using Spring's <code>TransactionTemplate</code>{{sfn |Deinum |
* Declaratively, by using [[metadata]] like XML or Java annotations (<code>@Transactional</code>,{{sfn | Deinum |
Together with Spring's data access framework – which integrates the transaction management framework – it is possible to set up a transactional system through configuration without having to rely on JTA or [[EJB]]. The transactional framework also integrates with messaging{{sfn | Deinum |
===Model–view–controller framework===
[[File:Spring5JuergenHoeller2.jpg|thumb|Spring MVC/Web Reactive presentation given by Jürgen Höller]]
The Spring Framework features its own [[model–view–controller]] (MVC) [[web application framework]],{{sfn | Deinum |
Like Struts, Spring MVC is a request-based framework.{{sfn | Johnson | Hoeller | 2004}}{{rp | p=375}} The framework defines [[strategy pattern|strategy]] interfaces{{sfn | Johnson | Hoeller | 2004}}{{rp | p=144}} for all of the responsibilities that must be handled by a modern request-based framework. The goal of each interface is to be simple and clear so that it's easy for Spring MVC users to write their own implementations, if they so choose. MVC paves the way for cleaner front end code. All interfaces are tightly coupled to the [[Java Servlet|Servlet API]]. This tight coupling to the Servlet API is seen by some as a failure on the part of the Spring developers to offer a high level of abstraction for Web-based applications {{Citation needed|date=February 2007}}. However, this coupling ensures that the features of the Servlet API remain available to developers while offering a high abstraction framework to ease working with it.
The <code>DispatcherServlet</code> class is the [[front controller]]<ref>Patterns of Enterprise Application Architecture: [http://www.martinfowler.com/eaaCatalog/frontController.html Front Controller]</ref> of the framework and is responsible for delegating control to the various interfaces during the execution phases of an [[Hypertext Transfer Protocol|HTTP request]].{{sfn | Deinum |
The most important interfaces defined by Spring MVC, and their responsibilities, are listed below:{{sfn | Deinum | Cosmina | 2021 | loc=§4 Spring MVC Architecture - The Request Processing Summary | pp=82-83}}
* <code>Controller</code>: comes between <code>Model</code> and <code>View</code> to manage incoming requests and redirect to proper response.{{sfn | Deinum |
* <code>HandlerAdapter</code>: responsible for execution of objects that handle incoming requests.{{sfn | Deinum |
* <code>HandlerInterceptor</code>: responsible for intercepting incoming requests.{{sfn | Deinum |
* <code>HandlerMapping</code>: responsible for selecting objects that handle incoming requests (handlers) based on any attribute or condition internal or external to those requests{{sfn | Deinum |
* <code>LocaleResolver</code>: responsible for resolving and optionally saving of the [[locale (computer software)|locale]] of an individual user.{{sfn | Deinum |
* <code>MultipartResolver</code>: facilitate working with file uploads by wrapping incoming requests.{{sfn | Deinum | Cosmina | 2021 | loc=§4 Spring MVC Architecture - Prepare a request | pp=75-76}}
* <code>View</code>: responsible for returning a response to the client. The <code>View</code> should not contain any business logic and should only present the data encapsulated by the <code>Model</code>.{{sfn | Deinum |
* <code>ViewResolver</code>: responsible for selecting a <code>View</code> based on a logical name for the <code>View</code>{{sfn | Deinum |
* <code>Model</code>: responsible for encapsulating business data.{{sfn | Deinum |
Each strategy interface above has an important responsibility in the overall framework. The abstractions offered by these interfaces are powerful, so to allow for a set of variations in their implementations.{{sfn | Johnson | Hoeller | 2004}}{{rp | p=144}} Spring MVC ships with implementations of all these interfaces and offers a feature set on top of the Servlet API. However, developers and vendors are free to write other implementations. Spring MVC uses the Java {{Javadoc:SE|package=java.util|java/util|Map}} interface as a data-oriented abstraction for the <code>Model</code> where keys are expected to be {{Javadoc:SE|java/lang|String}} values.{{Citation needed|date=June 2023}}
The ease of testing the implementations of these interfaces is one important advantage of the high level of abstraction offered by Spring MVC.{{sfn | Deinum |
====A workflow of Spring MVC====
When a user clicks a link or submits a form in their web-browser, the request goes to the Spring <code>DispatcherServlet</code>. <code>DispatcherServlet</code> is a [[Front controller|front-controller]] in Spring MVC.{{sfn | Deinum |
springframework.web.servlet.mvc.Controller</code> or <code>org.
springframework.stereotype.Controller</code> annotated classes.{{sfn|Deinum|Cosmina|2021|loc=§4 Spring MVC Architecture - DispatcherServlet Request Processing Workflow|pp=73-74}} It consults one or more handler mappings.{{sfn | Deinum |
====Configuration of DispatcherServlet====
Line 258 ⟶ 246:
* By using <code>javax.servlet.ServletContainerInitializer</code>{{sfn|Deinum|Cosmina|2021|loc=§4 Spring MVC Architecture - Bootstrapping DispatcherServlet|pp=84-90}}
* By implementing the <code> org.springframework.web.WebApplicationInitializer</code> interface.{{sfn|Deinum|Cosmina|2021|loc=§4 Spring MVC Architecture - Bootstrapping DispatcherServlet|pp=84-90}}
* By using the built-in autoconfiguration for Spring Boot, which uses the <code>[[Spring Boot#Bootstrapping DispatcherServlet|SpringBootServletInitializer]]</code> class.lm{{sfn|Deinum|Cosmina|2021|loc=§4 Spring MVC Architecture - Bootstrapping DispatcherServlet|pp=84-90}}
===Remote access framework===
Spring's Remote Access framework is an abstraction for working with various RPC ([[remote procedure call]])-based technologies available on the Java platform both for client connectivity and marshalling objects on servers.{{sfn | Deinum |
The framework provides fault-recovery (automatic reconnection after connection failure) and some optimizations for client-side use of EJB remote [[Stateless Session Bean|stateless session beans]].
Line 268 ⟶ 256:
* HTTP-based protocols
** [[Hessian (Web service protocol)|Hessian]]: binary serialization protocol,{{sfn | Deinum |
** Burlap: An [[Xml based language|XML-based]] binary protocol that is open-sourced and also maintained by the company [[Caucho Technology|Caucho]].{{sfn|Deinum
** [[Java remote method invocation|RMI]] (1): method invocations using RMI infrastructure yet specific to Spring{{sfn | Deinum |
** RMI (2): method invocations using RMI interfaces complying with regular RMI usage{{sfn | Deinum |
** [[RMI-IIOP]] ([[Common Object Request Broker Architecture|CORBA]]): method invocations using RMI-IIOP/CORBA
* [[Enterprise JavaBean]] client integration{{sfn | Deinum |
** Local EJB stateless session bean connectivity: connecting to local stateless session beans
** Remote EJB stateless session bean connectivity: connecting to remote stateless session beans
* SOAP
** Integration with the [[Apache Axis]] Web services framework{{sfn | Deinum |
[[Apache CXF]] provides integration with the Spring Framework for RPC-style exporting of objects on the server side.{{sfn | Deinum |
Both client and server setup for all RPC-style protocols and products supported by the Spring Remote access framework (except for the Apache Axis support) is configured in the Spring Core container.
Line 290 ⟶ 278:
====Spring Boot====
{{main article|Spring Boot}}
[[Spring Boot]] Extension is Spring's [[Convention over configuration|convention-over-configuration]] solution for creating [[
Key Features:
Line 298 ⟶ 286:
* Provide opinionated 'starter' [[Project Object Model]]s (POMs) to simplify your [[Maven (software)|Maven]]/[[Gradle]] configuration{{sfn|Walls|2016|loc=§Preface|p=x}}
* Automatically configure Spring whenever possible{{sfn|Walls|2016|loc=§1.1.2|pp=4-5}}
* Provide production-ready{{sfn|Walls|2016|loc=§foreword|p=vii}} features such as [[software metrics|metrics]],{{sfn|Walls|2016|loc=§7|pp=124-139}} health checks
* Absolutely no code generation{{sfn|Walls|2016|loc=§1.1.3|p=7}} and no requirement{{sfn|Walls|2016|loc=§Preface|p=x}} for XML configuration.<ref>{{cite web | url=https://aristeksystems.com/blog/what-you-need-know-about-spring-boot/| title=About Spring Boot | accessdate=2020-03-18}}</ref>
* Smooth Integration and supports all Enterprise Integration Patterns.
Line 317 ⟶ 305:
* [[Logging (computing)|logging]]/[[Tracing (software)|tracing]]
* transaction management
* job processing statistics{{sfn | Deinum |
* job restart
It provides more advanced technical services and features that enables extremely high-volume{{sfn | Deinum |
Spring Batch executes a series of jobs; a job consists of many steps and each step consists of a "READ-PROCESS-WRITE" task or single operation task (tasklet). A "single" operation task is also known as a tasklet.{{sfn | Deinum |
The "READ-PROCESS-WRITE" process consists of these steps: "read" data from a resource ([[comma-separated values]] (CSV), XML, or database), "process" it, then "write" it to other resources (CSV, XML, or database). For example, a step may read data from a CSV file,{{sfn | Deinum |
The steps can be chained together to run as a job.{{sfn | Deinum |
===Integration framework===
{{main article|Spring Integration}}
[[Spring Integration]] is a framework for [[Enterprise application integration]] that provides reusable functions essential to messaging or [[event-driven architecture]]s.
* routers – routes a message to a message channel based on conditions{{sfn | Deinum |
* transformers – converts/transforms/changes the message payload and creates a new message with transformed payload{{sfn | Deinum |
* adapters – integrates with other technologies and systems (HTTP, [[AMQP]] (Advanced Message Queuing Protocol),{{sfn | Deinum |
* filters – filters a message based on criteria. If the criteria are not met, the message is dropped.{{sfn|Deinum
* service activators – invoke an operation on a service object. Spring supports the use of the annotation <code>@ServiceActivator</code> to declare the component that requires this functionality.{{sfn|Deinum
* management and auditing
* gateways - exposes an interface to the client for the requested services. A messaging middleware is responsible for provisioning this interface. This interface decouples the messaging middleware from the client by hiding the underlying JMS or Spring Integration APIs. Gateways are related to the [[Facade pattern]]. Spring's Integration class, <code>SimpleMessagingGateway</code>, provides essential support for gateways. <code>SimpleMessagingGateway</code> enables the Spring application to specify the channel that sends requests, and the channel that expects to receive responses. The primary focus of <code>SimpleMessagingGateway</code> is to deal with payloads, which spares the client from the intricate details of the transmitted and received messages. <code>SimpleMessagingGateway</code> is used along with channels to enable integration with file systems, JMS, e-mail, or any other systems that require payloads and channels.{{sfn|Deinum
* splitter - Separates a large payload into smaller payloads to support different processing flows. The splitter is achieved in Spring using the splitter component. The splitter component usually forwards the messages to classes with more specialized functionality. Spring supports the <code>@Splitter</code> annotation to declare the component that requires this functionality.{{sfn|Deinum
* aggregator - Used for combining many messages into a single result. Loosely speaking, the aggregator is the reverse of the splitter. The aggregator publishes a single message for all components downstream. Spring supports the <code>@Aggregator</code> annotation to declare the component that requires this functionality.
Spring Integration supports pipe-and-filter based architectures.
===Spring WebSocket===
An essential rule for dealing with data streams effectively is to never block.{{sfn|Deinum|Cosmina|2021|loc=§11 The WebSocket Protocol|pp=422-425}} The WebSocket is a viable solution to this problem.{{sfn|Deinum|Cosmina|2021|loc=§11 The WebSocket Protocol|pp=422-425}} The WebSocket Protocol is a low-level [[transport protocol]] that allows [[Full duplex|full-duplex]] communication channels over a [[TCP connection]]. The WebSocket acts as an alternative to HTTP to enable two-way communication between the client and the server. The WebSocket is especially useful for applications that require frequent and fast exchanges of small data chunks, at a high speed and volume.{{sfn|Deinum|Cosmina|2021|loc=§11 The WebSocket Protocol|pp=422-425}}
Spring supports the WebSocket protocol by providing the WebSocket API for the reactive application. The <code>@EnableWebSocket</code> annotation gives Websocket request processing functionality when places in a Spring configuration class. A mandatory interface is the <code>WebSocketConfigurer</code> which grants access to the <code>WebSocketConfigurer</code>. Then, the Websocket URL is mapped to the relevant handlers by implementing the registerWebSocketHandlers(WebSocketHandlerRegistry) method
===Spring WebFlux===
Line 366 ⟶ 354:
==Spring4Shell vulnerability==
{{See also | Log4Shell}}
A [[remote code execution]] vulnerability affecting certain versions of Spring Framework was published in April 2022 under {{CVE|2022-22965}}. It was given the name ''Spring4Shell'' in reference to the recent [[Log4Shell]] vulnerability, both having similar proofs-of-concept in which attackers could
==See also==
Line 384 ⟶ 372:
* {{cite book | last=Cosmina | first=Iuliana | last2=Harrop | first2=Rob | last3=Schaefer | first3=Chris | last4=Ho | first4=Clarence | title=Pro Spring 5 | publisher=Apress | publication-place=Berkeley, CA | year=2017 | isbn=978-1-4842-2807-4 | doi=10.1007/978-1-4842-2808-1}}
* {{cite book | last=Deinum | first=Marten | last2=Cosmina | first2=Iuliana | title=Pro Spring MVC with WebFlux | publisher=Apress | publication-place=Berkeley, CA | year=2021 | isbn=978-1-4842-5665-7 | doi=10.1007/978-1-4842-5666-4}}
* {{cite book | last=Deinum | first=Marten | last2=Long | first2=Josh | last3=Mak | first3=Gary | last4=Rubio | first4=Daniel | title=Spring Recipes | publisher=Apress | publication-place=Berkeley, CA | year=2014 | isbn=978-1-4302-5908-4 | doi=10.1007/978-1-4302-5909-1}}
*{{cite book | first1 = Rod
| last1 = Johnson
Line 510 ⟶ 499:
{{Wikibooks|Java Programming|Spring framework}}
* {{Official website|https://spring.io}}
* [https://websparrow.org/category/spring Spring Tutorials]
{{Java (Sun)}}
| |||