Content deleted Content added
Extract out section on EJB |
|||
| (45 intermediate revisions by 26 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>
Spring Framework 4.3 has been released on 10 June 2016 and
Spring 5 is announced to be built upon [[Reactive Streams]] compatible Reactor Core.<ref>{{cite web|url=http://spring.io/blog/2016/02/09/reactive-spring|title=Reactive Spring|publisher=Spring Blog|date=9 February 2016}}</ref>{{Obsolete source|reason=This source is from 2016, but Spring 5.0.x was already released and was called "a major release" in the book "Pro Spring 5" by Iuliana Cosmina, Rob Harrop, Chris Schaefer and Clarence Ho|date=June 2023}}
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 91 ⟶ 77:
Spring modules are packaged as JAR files.{{sfn | Cosmina | Harrop | Schaefer | Ho | 2017 | p=21-23}} These artifacts can be accessed via the Maven Central Repository using [[Apache Maven|Maven]]{{sfn | Cosmina | Harrop | Schaefer | Ho | 2017 | loc=§2 Accessing Spring Modules Using Maven | pp=24-25}} or [[Gradle]].{{sfn | Cosmina | Harrop | Schaefer | Ho | 2017 | loc=§2 Accessing Spring Modules Using Gradle| p=26}}
=== 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.
==== Types of Inversion of Control ====
There are several types of Inversion of Control. Dependency injection and dependency lookup are examples of Inversion of Control.{{sfn | Cosmina | Harrop | Schaefer | Ho | 2017 | loc=§3 Introducing IoC and DI in Spring | p=37}} Objects can be obtained by means of either dependency lookup or dependency injection.{{sfn | Johnson | Hoeller | 2004}}{{rp | p=127}}<ref>[http://forum.springsource.org/showthread.php?79731-What-is-the-difference-between-the-depencylookup-and-dependency-injection What is the difference between the depencylookup and dependency injection - Spring Forum]. Forum.springsource.org (2009-10-28). Retrieved on 2013-11-24.</ref>
Line 114 ⟶ 100:
====Autowiring====
The Spring framework has a feature known as autowiring, which
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
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, and
The {{code|@Inject}} annotation is an annotation that conforms to JSR 300, or Standard Annotations for injection, and is ===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 160 ⟶ 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 181 ⟶ 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 190 ⟶ 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 257 ⟶ 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 267 ⟶ 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 289 ⟶ 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 297 ⟶ 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 316 ⟶ 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 352 ⟶ 341:
Although applications using Spring WebFlux technology is usually less readable than their MVC counterparts, they are more resilient, and simpler to extend.{{sfn|Deinum|Cosmina|2021|loc=§11 Securing Spring WebFlux Applications|p=421}} Spring WebFlux reduces the need to deal with the complications associated with synchronizing thread access.{{sfn|Deinum|Cosmina|2021|loc=§11 Securing Spring WebFlux Applications|p=421}}
Spring WebFlux supports [[server-sent events]] (SSE), which is a server push technology that allows the client to get automatic
==Relationship with Jakarta Enterprise Beans (EJB)==
Line 365 ⟶ 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 383 ⟶ 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 509 ⟶ 499:
{{Wikibooks|Java Programming|Spring framework}}
* {{Official website|https://spring.io}}
* [https://websparrow.org/category/spring Spring Tutorials]
{{Java (Sun)}}
| |||