The Spring Blog

News and Events

Spring REST Docs 1.1.0.RC1

Following 1.1.0.M1, it’s my pleasure to announce that Spring REST Docs 1.1.0.RC1 has been released and is available from

What’s new?

HTTPie request snippet

A new HTTPie request snippet has been introduced. Similar to the existing curl request snippet, the new snippet contains the HTTPie command for a request. My thanks to Raman Gupta who contributed this new feature.

Reusable snippets

Snippets can now be created once with some common configuration and then reused. This reduces repetition when documenting common parts on an API, such as self links.


Spring Session 1.2.0 RC3 Released

On behalf of the community, I’m pleased to announce the release of Spring Session 1.2.0.RC3. The release can be found in the Spring Milestone Repository (

This release contains some fixes for the previous release.

Some highlights of the issues in this release include:

  • JDBC Support persists session attributes on a separate table. This was in response to the community feedback (thanks!)
  • Redis Session optimization
  • Preparations for improved Spring Boot auto configuration
  • Updated to Spring Data Hopper

Webinar: Data Microservices with Spring Cloud Data Flow

Speakers: Mark Fisher & Mark Pollack, Pivotal
The future of scalable data processing is microservices! Building on the ease of development and deployment provided by Spring Boot and the cloud native capabilities of Spring Cloud, the Spring Cloud Stream and Spring Cloud Task projects provide a simple and powerful framework for microservice stream and batch processing.
At a higher level of abstraction, Spring Cloud Data Flow is an integrated orchestration layer that provides a highly productive experience for deploying and managing sophisticated data pipelines consisting of standalone microservices. Streams and tasks are defined using a DSL abstraction and can be managed via shell and a web UI. Furthermore, a pluggable runtime SPI allows Spring Cloud Data Flow to coordinate these applications across a variety of distributed runtime platforms such as Cloud Foundry, Apache Mesos and Apache YARN.
During this webinar you’ll see an overview of Spring Cloud Data Flow, with live demos of streaming and batch apps, on different platforms ranging from local cluster to a remote Cloud to show the simplicity of the developer experience.


Webinar: Introducing Spring Cloud Task

Speaker: Michael Minella, Pivotal

One of the major promises of the cloud is that of flexibility. Today, most applications deployed to the cloud are long running processes that use the flexibility of cloud scaling. But computing is full of short lived tasks that start up, do their work, and then terminate. These tasks are excellent cloud use cases since resources can quickly be provisioned - and reclaimed.

In this webinar, we’ll explore a new project in the Spring Cloud portfolio, Spring Cloud Task, a new framework for developing and orchestrating short-lived microservices. We’ll explore various use cases, build your first task, and discuss how to orchestrate tasks using various techniques. Finally, we’ll peek into the roadmap for the Spring Cloud Task project.


This Week in Spring - April 26th, 2016

Welcome to another installment of This Week in Spring! This week I’m in Budapest, Hungary, for the amazing Craft Conf. This show is a very special show indeed. Special, for me, first in that I’ll be joined by industry titans like Adrian Cochroft, Jez Humble, Sam Newman, and Kyle Kingsbury, and in that I’ll join two of my friends from Pivotal - Andrew Clay Shafer and Bridget Kromhout (also titans)! I’m so excited to be among these, and many more, that I can hardly contain it and I recommend you consider making the trip if it’s convenient, one day, yourself.


Spring Integration 4.3 M2 is Available

I am pleased to announce that Spring Integration 4.3.0.M2 is now available from the Spring milestone repository. This release closes about 50 JIRAs and includes almost a 100 commits.

Thanks to everyone who has contributed. Especially to the Spring Cloud Stream team, whose comprehensive Spring Integration usage influences the project direction.

Some key feature since the First Milestone:

  • The Spring Integration runtime object model, together with Component Metrics, now can be exposed as a graph, which may be used to visualize the current state of the integration application. When running in a web container, the @EnableIntegrationGraphController annotation, together with an IntegrationGraphServer bean, creates a service to retrieve the model and state over the REST protocol, e.g. in JSON notation:

      "nodes": [
      "nodeId": 1,
      "name": "nullChannel",
      "componentType": "channel",
      "nodeId": 2,
      "name": "errorChannel",
      "componentType": "publish-subscribe-channel",
      "nodeId": 3,
      "name": "_org.springframework.integration.errorLogger",
      "componentType": "logging-channel-adapter",
      "output": null,
      "input": "errorChannel"
      "links": [
      "from": 2,
      "to": 3
    Continuing the tradition of Spring Integration, message channels are represented as first class citizens (nodes) in this model, and are not simply links between nodes. Also, when statistics are enabled (@EnableIntegrationManagement or <int:management />), each node in the object graph contains those statistics (message counts, response times etc).

  • Persistent MessageStores now support a Lazy-Load algorithm (enabled by default) for MessageGroup retrieval. When dealing with large, persisted, groups with operations such as aggregation, this produces significant performance benefits.

  • The Service Activator now supports an async option. If the service returns a ListenableFuture<?> and async is true, the calling thread is released immediately, and the reply message is sent on the thread (from within your service) that completes the future. Based on this foundation we also provide an AsyncAmqpOutboundGateway and async mode for the JmsOutboundGateway where the downstream flow runs on the reply listener container thread.

  • The XMPP Adapters now support Extensions (XEP). So, for example, you can more easily interact with Google Cloud Messaging (GCM):


Spring Statemachine 1.1.0.RC1 Released

We’re pleased to announce a first release candidate of Spring Statemachine 1.1.0.RC1. The release can be found in the Spring Milestone repository

What we got into this first release candidate:
- Fixed 20 tickets.
- Usual bug fixes.
- New junction, exit/entry pseudostates.
- New uml modeling support based on Eclipse Papyrus

Full changes as usual is available from changelog.

UML Modeling

One of the most requested features has been to be able to use modeling frameworks to design a statechart instead of using plain good old JavaConfig. Work for this started a while back and first step for this was to use Eclipse Papyrus and its generated uml model.


Spring Batch 3.0.7.RELEASE is now available

We are pleased to announce that Spring Batch 3.0.7.RELEASE is now available via Maven Central, Github and the Pivotal download repository. This is the 7th maintenance release for the 3.0.x branch of Spring Batch and addresses a number of minor bug fixes and enhancements. Most important of them, it addresses compatibility issues with the latest Spring Data release as well as adding updates to support the latest Hibernate releases. Many thanks to all of those who submitted the many pull requests that went into this release.


Spring Security 4.1.0.RC2 Released

On behalf of the community, I’m pleased to announce the release of Spring Security 4.1.0.RC2. This release resolved over 60 tickets.

What’s New in 4.1

You can find a good summary of What’s New in Spring Security 4.1 in the reference documentation.


Without the community we couldn’t be the successful project we are today. I’d like to thank everyone that created issues & provided feedback. A special thanks to the following people who provided pull requests for this release:


Understanding Reactive types

Following previous Reactive Spring and Reactor Core 2.5 blog posts, I would like to explain why Reactive types are useful and how they compare to other asynchronous types, based on what we have learned while working on the Spring Framework 5 upcoming Reactive support.

Why using Reactive types?

Reactive types are not intended to allow you to process your requests or data faster, in fact they will introduce a small overhead compared to regular blocking processing. Their strength lies in their capacity to serve more request concurrently, and to handle operations with latency, such as requesting data from a remote server, more efficiently. They allow you to provide a better quality of service and a predictable capacity planning by dealing natively with time and latency without consuming more resources. Unlike traditional processing that blocks the current thread while waiting a result, a Reactive API that waits costs nothing, requests only the amount of data it is able to process and bring new capabilities since it deals with stream of data, not only with individual elements one by one.