You've no doubt read Jennifer Hickey's amazing blog posts introducing Cloud Foundry workers, their application in setting up Ruby Resque background jobs, and today's post introducing the Spring support.

Key Takeaways for Spring Developers

1. You need to update your version of vmc with gem update vmc.
2. Cloud Foundry workers let you run public static void main jobs. That is, a Cloud Foundry worker is basically a process, lower level than a web application, which maps naturally to many so-called back-office jobs.
3. You need to provide the command that Cloud Foundry will run. You could provide the java incantation you'd like it to use, but it's far simpler to ship a shell script, and have Cloud Foundry run that shell script for you, instead. The command you provide should employ $JAVA_OPTS, which Cloud Foundry has already provided to ensure consistent memory usage and JVM settings.
4. There are various ways to automate the creation of a Cloud Foundry deployable application. If you're using Maven, then the org.codehaus.mojo:appassembler-maven-plugin plugin will help you create a startup script and package your .jars for easy deployment, as well as specifying an entry point class.
5. Everything else is basically the same. When you do vmc push on a Java .jar project, Cloud Foundry will ask you whether the application is a standalone application. Confirm, and it'll walk you through the setup from there.

So, let's look at a few common architectures and arrangements that are easier and more natural with Cloud Foundry workers. We'll look at these patterns in terms of the Spring framework and two surrounding projects, Spring Integration and Spring Batch, both of which thrive in, and outside of, web applications. As we'll see, both of these frameworks support decoupling and improved composability. We'll disconnect what happens from when it happens, and we'll disconnect what happens from where it happens, both in the name of freeing up capacity on the front end.

I've got a Schedule to Keep!

One common question I get is: How do I do job scheduling on Cloud Foundry? Cloud Foundry supports Spring applications, and Spring of course has always supported enterprise grade scheduling abstractions like Quartz and Spring 3.0's @Scheduled annotation. @Scheduled is really nice because it is super easy to add into an existing application. In the simplest case, you add @EnableScheduling to your Java configuration or <task:annotation-driven/> to your XML, and then use the @Scheduled annotation in your code. This is a very natural thing to do in an enterprise application - perhaps you have an analytics or reporting process that needs to run? Some long running batch process? I've put together an example that demonstrates using @Scheduled to run a Spring Batch Job. The Spring Batch job itself is a worker thread that works with a web service whose poor SLA make it unfit for realtime use. It's safer, and cleaner, to handle the work in Spring Batch, where its recovery and retry capabilities pick up the slack of any network outages, network latency, etc. I'll refer you to the code example for most of the details, we'll just look at the the entry point and then look at deploying the application to Cloud Foundry.

					    
// set to every 10s for testing.
@Scheduled(fixedRate = 10 * 1000)
public void runNightlyStockPriceRecorder() throws Throwable {
	JobParameters params = new JobParametersBuilder()
		.addDate("date", new Date())
		.toJobParameters();
	JobExecution jobExecution = jobLauncher.run(job, params);
	BatchStatus batchStatus = jobExecution.getStatus();
	while (batchStatus.isRunning()) {
		logger.info("Still running...");
		Thread.sleep(1000);
	}
	logger.info(String.format("Exit status: %s", jobExecution.getExitStatus().getExitCode()));
	JobInstance jobInstance = jobExecution.getJobInstance…

Last updated on November 5th, 2012 (Spring MVC 3.2 RC1)

In my last post I introduced the new Servlet 3 based, async support in Spring MVC 3.2 and talked about long-running requests. A second very important motivation for async processing is the need for browsers to receive real-time updates. Examples include chatting in a browser, stock quotes, status updates, live sports results, and others. To be sure not all examples are equally delay-sensitive but all of them share a similar need.

In standard HTTP request-response semantics a browser initiates a request and the server sends a response, which means the server can't send new information until it has a request from the browser. Several approaches have evolved including traditional polling, long polling, and HTTP streaming and most recently we have the WebSocket protocol.

Traditional Polling

The browser keeps sending requests to check for new information and the server responds immediately each time. This fits scenarios where polling can be done at reasonably sparse intervals. For example a mail client can check for new messages every 10 minutes. It's simple and it works. However, the approach becomes inefficient when new information must be shown as soon as possible in which case polling must be very frequent.

Long Polling

The browser keeps sending requests but the server doesn't respond until it has new information to send. From a client perspective this is identical to traditional polling. From a server perspective this is very similar to a long-running request and can be scaled using the technique discussed in Part 1.

How long can the response remain open? Browsers are set to time out after 5 minutes and network intermediaries such as proxies can time out even sooner. So even if no new information arrives, a long polling request should complete regularly to allow the browser to send a new request. This IETF document recommends using a timeout value between 30 and 120 seconds but the actual value to use will likely depend on how much control you have over network intermediaries that separate the browser from server.

Long polling can dramatically reduce the number of requests required to receive information updates with low latency, especially where new information becomes available at irregular intervals. However, the more frequent the updates are the closer it gets to traditional polling.

HTTP Streaming

The browser sends a request to the server and the server responds when it has information to send. However, unlike long polling, the server keeps the response open and continues to send more updates as they arrive. The approach removes the need for polling but is also a more significant departure from typical HTTP request-response semantics. For example the client and server need to agree how to interpret the response stream so that the client will know where one update ends and another begins. Furthermore, network intermediaries can cache the response stream which thwarts the intent of the approach. This is why long polling is more commonly used today.

WebSocket Protocol

The browser sends an HTTP request to the server to switch to the WebSocket protocol and the server responds by confirming the upgrade. Thereafter browser and server can send data frames in both directions over a TCP socket.

The WebSocket protocol was designed to replace the need for polling and is specifically suited for scenarios where messages need to be exchanged between browser and server at a high frequency. The initial handshake over HTTP ensures WebSocket requests can go through firewalls. However, there are also significant challenges since a majority of deployed browsers do not support WebSockets and there are further issues with getting through network intermediaries.

WebSockets revolves around the two way exchange of text or binary messages. It leads to a significantly different approach from a RESTful, HTTP-based architecture. In fact there is a need for some another protocol on top of WebSockets, e.g. XMPP, AMQP, STOMP, or other and which one(s) will become predominant remains to be seen.

The WebSocket protocol is already standardized by the IETF while the WebSocket API is in the final stages of being standardized by W3C. A number of Java implementations have become available including servlet containers like Jetty and Tomcat. The Servlet 3.1 spec will likely support the initial WebSocket upgrade request while a separate JSR-356 will define a Java-based WebSocket API.

Coming back to Spring MVC 3.2, the Servlet 3 async feature can be used for long-running requests and also for HTTP streaming, techniques Filip Hanik referred to as "the server version of client AJAX calls". As for WebSockets, there is no support yet in Spring 3.2 but it will most likely be included in Spring 3.3. You can watch SPR-9356 for progress updates.

The next post turns to sample code and explains in more detail the new Spring MVC 3.2 feature.

Dear Spring-NOSQL Community,

The new Release Candidate 1 of Spring Data - Neo4j comes with a number of long requested improvements and additions.

First of all, SDN has been updated to Neo4j 1.7.GA which includes operational improvements and new grammar to the Cypher graph query language. To complement the added language features, this release of SDN integrates a new version of the cypher-dsl with an improved API.

By popular request, support for not only unique node entities but also for relationships is now available. This works using either the remote REST-Server or an embedded Neo4j database…

I'd like to announce the availability of Spring Data MongoDB 1.1.0 M1. This is the first milestone of the 1.1.0 branch and comes with a hand full of new features:

• Support for GridFS (DATAMONGO-6)
• Support for JSR-303 validation (DATAMONGO-36 - community contribution)
• Support for new repository keywords: StartsWith, EndsWith, Contains, After, Before (DATAMONGO-418, 427)
• CDI integration for repositories (DATAMONGO-356)

Downloads | JavaDocs | Reference Documentation | Changelog

The release is available from our Maven repository. To learn more about the project, visit the Spring Data MongoDB Page. Looking forward to your feedback on the forum or in the issue tracker.

Last updated on November 5th, 2012 (Spring MVC 3.2 RC1)

Overview

Spring MVC 3.2 introduces Servlet 3 based asynchronous request processing. This is the first of several blog posts covering this new capability and providing context in which to understand how and why you would use it.

The main purpose of early releases is to seek feedback. We've received plenty of it both here and in JIRA since this was first posted after the 3.2 M1 release. Thanks to everyone who gave it a try and commented! There have been numerous changes and there is still time for more feedback!

At a Glance

From a programming model perspective the new capabilities appear deceptively simple. A controller method can now return a java.util.concurrent.Callable to complete processing asynchronously. Spring MVC will then invoke the Callable in a separate thread with the help of a TaskExecutor. Here is a code snippet before:

// Before
@RequestMapping(method=RequestMethod.POST)
public String processUpload(final MultipartFile file) {
    // ...
    return "someView";
}

// After
@RequestMapping(method=RequestMethod.POST)
public Callable<String> processUpload(final MultipartFile file) {

  return new Callable<String>() {
    public Object call() throws Exception {
      // ...
      return "someView";
    }
  };
}

A controller method can also return a DeferredResult (new type in Spring MVC 3.2) to complete processing in a thread not known to Spring MVC. For example reacting to a JMS or an AMQP message, a Redis notification, and so on. Here is another code snippet:

@RequestMapping("/quotes")
@ResponseBody
public DeferredResult<String> quotes() {
  DeferredResult<String> deferredResult…

Dear Spring Community,

I am happy to announce the first milestone release 3.0.0.M1 of the SpringSource Tool Suite (STS).

Highlights from this milestone include:

• the distribution now ships on top of the Eclipse Juno M6 (4.2M6) packages.
• updated to tc Server 2.6.5
• some improvements around Spring-related content-assists and code templates
• Groovy 2.0 support
• Grails 2.0.3 support
• Java7 support for AspectJ/AJDT

Since the Eclipse Juno release in June will be based on the new Eclipse 4.2 platform (instead of the 3.x development stream), we decided to ship this milestone build of STS based on the latest Juno milestone builds instead of the latest Indigo SR2 release. We expect a lot of fixes in the Eclipse platform until the final Eclipse version ships in June, so some glitches that you might experience using this M1 build of STS will be fixed…

Welcome to another installment of This Week in Spring! I'm writing the back of the room during Adrian Colyer's amazing keynote at SpringOne On The Road - London event.

1. Did you guys miss Oleg Zhurakousky's webinar, Practical Tips and Tricks with Spring Integration? Have no fear, the video is available online.

   Also, be sure to check out part 2, this Wednesday, May 3rd for both Europe and North America!

   	</LI>
   	<LI> <a href = "http://blog.springsource.org/author/rclarkson/">Roy Clarkson</A> has announced the <a href = "http://www.springsource.org/spring-mobile/news/1.0.0.rc2-released">latest release of Spring Mobile</A>.  
   		 The release has several enhancements including more refined resolution, and improved site switching behavior. 
   		
   		</LI> 
   		<LI>  <a href = "http://blog.springsource.org/author/jbrisbin/">Jonathan Brisbin</A> just announced <a href="http://blog.springsource.org/author…

The idea for this video was triggered by Oleg Zhurakousky's desire to share some of the more interesting integration solutions that came out of the actual customer engagements as well as the questions that are most frequently asked on the Spring Integration forums. Oleg showcases the Spring Integration framework and how it can help you to build, manage and maintain powerful enterprise-grade integration solutions. In this edition of "Practical Tips-and-Tricks" Oleg covers some of the more advanced topics of enterprise integration such as message-flow-segmentation, custom retry logic, error handling, timeouts and more. This video is based on a refined version of Oleg's very successful talk delivered at SpringOne 2GX 2011.

To review basics of messaging and Spring Integration watch this Message Driven Architecture video by Mark Fisher.

Be sure to thumbs up the presentation if you find it useful and subscribe to the SpringSourceDev channel to see other recordings and screencasts.

Dear Spring Community,

We are pleased to announce that the second release candidate of the Spring Mobile project is now available!

Spring Mobile provides extensions to Spring MVC that aid in the development of cross-platform mobile web applications.

Here is an overview of the new features and functionality:

• Tablets are no longer recognized as mobile devices
• Added support for resolving tablet devices in LiteDeviceResolver.
• Added a new DeviceType enumeration consisting of NORMAL, MOBILE, and TABLET values.
• The Device interface now includes isNormal(), and isTablet() methods in addition to the existing isMobile() method.
• WebOS devices are now recognized as a mobile device in LiteDeviceResolver
• Improved the SiteSwitcherHandlerInterceptor by adding an URL path alternative to "dotMobi" and "mDot" for site switching. The switcher is now capable of switching between "normal" and "mobile" URL paths within the same domain. For example an about page for a normal site may be "http://www.domain.com/about", and the mobile site may be "http://www.domain.com/m/about"
• You can now configure a list of "normal" User-Agent keywords in the LiteDeviceResolver. It may happen that a device is falsely identified as mobile. This list of keywords takes precedence over the mobile and tablet keywords, effectively overriding the default behavior.

See the changelog and reference manual for more information.

To retrieve the software, download the release distribution, or add the maven artifacts to your project. Sample apps are available at github.com/SpringSource/spring-mobile-samples

We want to thank Scott Rossillo for his contributions to this release, and we look forward to working with him and the rest of the Spring community on future releases. If you are building a mobile web app, we encourage you try out 1.0.0.RC2 and collaborate with us on the next iteration of the project.