We’re pleased to announce that, after a long period of internal incubation, we’re releasing a foundational framework for asynchronous applications on the JVM which we’re calling Reactor. It provides abstractions for Java, Groovy and other JVM languages to make building event and data-driven applications easier. It’s also really fast. On modest hardware, it's possible to process over 15,000,000 events per second with the fastest non-blocking Dispatcher. Other dispatchers are available to provide the developer with a range of choices from thread-pool style, long-running task execution to non…

There are two ways to generate output using Spring MVC:

• You can use the RESTful @ResponseBody approach and HTTP message converters, typically to return data-formats like JSON or XML. Programmatic clients, mobile apps and AJAX enabled browsers are the usual clients.
• Alternatively you may use view resolution. Although views are perfectly capable of generating JSON and XML if you wish (more on that in my next post), views are normally used to generate presentation formats like HTML for a traditional web-application.
• Actually there is a third possibility - some applications require both, and Spring MVC supports such combinations easily. We will come back to that right at the end.

In either case you'll need to deal with multiple representations (or views) of the same data returned by the controller. Working out which data format to return is called Content Negotiation.

There are three situations where we need to know what type of data-format to send in the HTTP response:

• HttpMessageConverters: Determine the right converter to use.
• Request Mappings: Map an incoming HTTP request to different methods that return different formats.
• View Resolution: Pick the right view to use.

Determining what format the user has requested relies on a ContentNegotationStrategy. There are default implementations available out of the box, but you can also implement your own if you wish.

In this post I want to discuss how to configure and use content negotiation with Spring, mostly in terms of RESTful Controllers using HTTP message converters. In a later post I will show how to setup content negotiation specifically for use with views using Spring's ContentNegotiatingViewResolver…

Welcome to An Epic Week in Spring! Lots of new sessions have been posted to SpringOne Conference, so head over to the site and check out the featured sessions! We'll have the agenda grid online before the end of May.

Featured SpringOne2GX 2013 sessions accepted!

<li><a href="http://www.springone2gx.com/conference/santa_clara/2013/09/session?id=29165">Tackling Big Data Complexity with Spring</a> (Mark Fisher and Mark Pollack)</li>
    <li><a href="http://www.springone2gx.com/conference/santa_clara/2013/09/session?id=29395">Reactor - an asynch  framework for distributed web and enterprise architectures</a> (Jon Brisbin)</li>

• Spring for Snowboarders (Dave Syer and Phil Webb)

Many other new sessions accepted as well:

• Taming client-server Communication (Scott Andrews)
• Tuning Large Scale Java Platforms (Emad Benjamin - VMware)
• AOP-ing your JavaScript (Brian Cavalier)
• Integrating Splunk into your Spring Applications (Damien Dallimore - Splunk)
• REST-ful API Evolution (Ben Hale)
• Free Yourself with CloudFoundry: A Private Cloud Experience (Mike Heath - LDS Church)
• Integrating Spring Batch and Spring Integration (Gunnar Hillert and Michael Minella)
• Your Data, Your Search, Elasticsearch (Costin Leau - ElasticSearch)
• Multi Environment Spring Applications (Josh Long and Kevin Nilson)
• JSR-352, Spring Batch and You (Michael Minella)
• Spring Scala (Arjen Poutsma)
• Open/Closed Software - Developing freemium application using Spring Framework (Baruch Sadogursky - jFrog)
• Spring Testing (Mattias Severson - Jayway)
• The Pitfalls of Building Enterprise Applications (Jeffrey Sogolov - ADP Dealer Services)
• How Not to Measure Latency (Gil Tene - Azul)
• Building Reactive Apps (James Ward - TypeSafe)

And now, back to our regularly scheduled week in Spring... as usual, we've got a lot to cover, so let's get to it!

1. Juergen Hoeller and Marius Bogoevici's talk, Java EE services for Spring applications, from SpringOne2GX 2012 is now available in HD on YouTube!
2. John Davies's talk, Spring Integration in the Wild, from SpringOne2GX 2012 is now available HD on YouTube!
3. Kim Saabye Pedersen has written a small example on using @Transactional on an interface with Spring's transaction management infrastructure. Nice job, Kim!
4. Would it be possible to take Spring Petclinic as it is now and scale it up to 1000 requests per second on a single server instance? Julien Dubois from Ippon Technologies has written a great series of five blog entries on that topic. If you missed them from the previous roundups, check out the whole series, starting here!
5. Petri Kainulainen has written a great post introducing how to sort data using Spring Data SOLR.
6. By the by, I know I've mentioned this before, but it really is handy. Have you checked out Alvaro Videla's RabbitMQ simulator?
7. Spring Data ninja Oliver Gierke has written a great response to the question, How do I use Spring Data MongoDB in a multi-tenant fashion? Be sure to check it out. Generally, his advice is applicable to many such scenarios.
8. Serkan ÖZAL has put together an awesome, bytecode-based RowMapper that can be used with Spring's JDBC infrastructure (like JdbcTemplate) and that can handle relationships like an ORM might. Because it's bytecode-based, it's very fast and not given to the same reflection-based performance limitations of Spring's own BeanPropertyRowMapper. I haven't tried this out yet, but it looks very promising!
9. Our friend Roger Hughes is back with a tutorial (of two posts, thus far). The first, RESTful Ajax with Spring MVC, establishes an application (without REST and Ajax) and the second then introduces serializing data objects using Jackson, a JSON serializer.
10. Bharat Sharma also wrote a nice post on serializing to JSON with Spring MVC this week!
11. Blogger Kal wrote up a nice post on how Spring MVC simplifies file-uploads with Spring MVC and commons-fileupload.

Welcome to another installment of This Week in Spring! We've got a lot to cover this week, as usual, so let's get to it. Did you miss last week's Pivotal public launch? Catch the replay and learn about GE's investment in the new entity! Pivotal's mission is about bringing consumer-grade software to the enterprise -- where open source technology like Spring, Groovy, Grails, RabbitMQ, Redis, and Cloud Foundry, are already widely adopted. Check out the new Pivotal website, under the Community link (top right) for some other open source initiatives that might surprise you!

1. Oliver Gierke has announced Spring HATEOAS 0.5, which contains lots of new features!
   
2. Spring Security lead Rob Winch has announced that Spring Security 3.1.4 is now available. This is a maintenance release with a number of bug fixes including OSGi support for Spring 3.2.
3. Spring Data ninja Oliver Gierke also (boy that guy gets around!) tweeted a look at the Spring Data roadmap: introducing Spring Data "Babbage."
4. Spring Data Arora SR1 released this week (named for Sanjeev Arora). As an aside, you have probably noticed that the names of the various Spring Data release trains are adapted from various influential names in computer science. The new release is named for Charles Babbage.
5. Adam Shook and Dr. Mark Pollack's webinar, Hadoop, Pivotal HD and Spring for Apache Hadoop, is now available online.
6. Gil Tene, of Azul Systems, gave an amazing talk at SpringOne2GX 2012 called Understanding Java Garbage Collection and what you can do about it, which is now online.
7. New SpringOne2GX replays now available in HD on YouTube: Building for Performance with Spring Integration & Spring Batch, Case Study: Provisioning a Multi-Site In-Memory Database
8. James Watters shared a video he'd discovered on setting up Cloud Foundry and BOSH. It's pretty epic and worth a watch if you want to get a handle on BOSH.
9. What people write blog posts about sometimes surprises me. The Javarevisted blog has a nice post introducing Spring's (fairly internal, albeit stable) org.springframework.util.StringUtils class, with examples on how to convert collections to delimited strings. I think this is perhaps too much information on the subject, but I love the enthusiasm!
10. RabbitMQ developer-advocate Alvaro Videla has put together a post on how to unit-test RabbitMQ from PHPUnit. This approach is pretty cool, though I wonder how well it would play in Java and jUnit with concurrent test suite execution. Either way, this is a nice way to unit test my favorite message queue!
11. Do you need a Spring Integration adapter? Have you checked out the Spring Integration extensions repository? This repository simply collects adapters that move faster than the Spring Integration core, or that are still being polished. It's a great place to find solutions to various problems. Heck, even the pull requests are chock full of useful stuff - I see an MQTT adapter in there by the amazing Gary Russell!
12. Check out this amazing post on @gopivotal blog called 800,000 Messages/Minute: How Nokia’s HERE Uses #RabbitMQ to Make Real-time Traffic Maps over on the @gopivotal blog. It introduces the Nokia HERE architecture that builds on Spring AMQP and RabbitMQ.

Today we are officially kicking off a new initiative called Spring XD whose theme is "tackling Big Data complexity"¹.

The Spring Data team has been incredibly busy over the past few years, not only providing support for NoSQL datastores but also simplifying the development experience with Hadoop. With the creation of the Spring for Apache Hadoop project, we made it easier to get started developing Hadoop applications by providing a rich configuration model and a consistent programming model across Hadoop ecosystem projects such as Hive and Pig. As Spring users would expect, one can:

1. Configure and run MapReduce jobs as container managed objects.
2. Use template helper classes for HDFS, HBase, Pig and Hive to remove boilerplate code from your applications.

Spring…

Welcome back to another installment of This Week in Spring! Here in San Francisco, we're experiencing the first fits of life and beautiful weather typical of spring time. Fitting, too, as things are busy-as-can-be in the Pivotal open source communities - including Cloud Foundry and SpringSource - as we march towards the Pivotal Initiative launch on April 24th. See you then!

Without further ado, let's get into this week's roundup:

1. Have you guys seen the amazing Java configuration support in Spring Batch 2.2.0.RC1? The code I've just linked you to demonstrates a complete working Spring Batch job that reads in a .csv file and then writes the records to a data source, all of which are configured in the class, entirely in Java. This demonstrates the @EnableBatchProcessing annotation in 2.2.0. Check it out!
2. New SpringOne2GX replays now available in HD on YouTube: Implementing Domain Driven Design with Spring and vFabric, Batch Processing and Integration on Cloud Foundry and a bonus session, Understanding Java Garbage Collection and what you can do about it.
3. The FuzzyDB open source project tweeted that they'd released a new version of FuzzyDB with Spring Data bindings aligned with the Spring Data Arora release train. Congratulations, guys!
4. Have you had a chance to play with Thymeleaf, the HTML5 and Spring MVC-friendly templating engine? If you'd like to learn even more, you'll probably like this presentation called Thymeleaf, Will it Blend?
5. David Welch put together a quick demo of Spring Data Mongo and made the work available. He tweets that he went from working demo in 8 minutes with 4 classes and a pom.xml. Nice work man!
6. Check out Ramnivas Laddad's awesome talk CloudFoundry Architecture talk at SpringOne2GX up live on the SpringSource YouTube channel SpringSourceDev.
7. Spring HATEOAS lead Oliver Gierke tweeted a link to this post, "How I Explained REST to my wife", which would seem at first to be just one person's attempt at explaining a fairly deep technology concept to a person who didn't have the same technical background, but quickly turns into a (I think really insightful) look at the applicability of REST. Check out Spring HATEOAS if you want to take your REST-fu to the next level.
8. I'm personally enamored of the new Java configuration APIs, both those recently released and those currently available in preview releases. I showed a very simple example of the Spring Batch API above. I also took a moment last week to write about the powerful Spring Social Java configuration API soon to be available in the 1.1.0.M2 release.
9. You can have Spring perform a sort of pre-condition check by using the @Required annotation to insist at runtime that a property be satisfied with a non-null value, or Spring will abort the construction of the object. This helps avoid any silent NullPointerExceptions. This JavaBeat post does a nice job explaining how to use @Required.
10. The how to do in java blog has a nice posting on how to create a custom UserDetailsService in Spring Security 3.
11. The JavaCodeGeeks blog has a nice post on how to create RESTful services with Spring MVC.
12. Brian's Java Blog has a nice post on using Spring AOP with both annotation and XML-centric configuration options.

Dear Spring Community,

I am happy to announce the first milestone release 3.3.0.M1 of the Spring Tool Suite (STS) and the Groovy/Grails Tool Suite (GGTS).

Highlights from this milestone build include:

• Spring IDE: improved support for JavaConfig-driven Spring projects
• Groovy-Eclipse: now supports customizable editor templates
• Groovy-Eclipse: navigation and hovers in binary (compiled) groovy files
• Grails-IDE: preliminary support for current builds of Grails 2.3

Both tool suites ship on top of the latest Eclipse Juno SR2 release. For optimal performance and stability we still recommend the distribution that is based on Eclipse 3.8.2.

The second milestone 3.3.0.M2 build is scheduled for early June 2013, followed by the 3.3.0 release in early July 2013 - shortly after the Eclipse Kepler release.

To download the distributions, please go visit:

• Spring Tool Suite: http://www.springsource.org/sts
• Groovy/Grails Tool Suite: http://grails.org/products/ggts

Enjoy!

Welcome to another installment of This Week in Spring! It's been an exciting week for Spring at Pivotal, which you can hear more about at the re-scheduled Pivotal launch event on April 24th.

1. In case you are reading too fast, Pivotal has re-scheduled the launch event to April 24th. Register here!
2. Arjen Poutsma has announced Spring Web Services 2.1.3.RELEASE. The new release mainly consists of bug fixes, for the full details check out the changelog.
3. Don't miss the upcoming Webinar with Donald Miner and Mark Pollack discussing Pivotal HD and Spring Hadoop, a good introductory webinar for those that are Pivotal HD-curious.
4. New SpringOne2GX replays now available in HD on YouTube: Cloud Foundry Architecture, Effective Design Patterns in NewSQL
5. There was a great post on Reddit the other day that explains the difference between REST and SOAP in terms of Martin Lawrence. This has nothing to do with Spring, but was droll enough that it's worth sharing.

     Spring, of course, has an amazing REST stack and I highly encourage people to check out how to build consolidated, streamlined REST services with Spring! Moving on... :) 
   

6. James Rossiter has a good post on how to use a Spring InitBinder to Resolve Type Mismatch and bind Exceptions in POST from Spring MVC to Controller Actions.
7. @olivergierke brings up a great point on Twitter: how much code does it take to add the JTA 1.2 JSR javax.transaction.Transactional annotation to Spring? Almost nothing! Most of the code here is just unit tests. Otherwise, this is just a dead simple mapping of the JTA annotation to Spring's already supported engine, which also currently supports the native Spring @Transactional and @javax.ejb.TransactionAttribute annotation.
8. Are you looking into Gradle and want to get started with Spring, quickly? Giancarlo Frison has put together a nice post with a bootstrap Gradle build that can be used with Spring applications.
9. Eugen Paraschiv has put together a nice post on how to use RestTemplate to do HTTP BASIC authentication.
10. Spring has long supported a utility class, called the org.springframework.util.StopWatch, which can be used to measure the execution of method invocations. The Javarevisited blog has a

      <a href="http://www.stumbleupon.com/su/1rKtfP/javarevisited.blogspot.com.au/2012/04/how-to-measure-elapsed-execution-time.html">nice post on how to use the <CODE>StopWatch</code> class</a>.
    </LI>
    

11. This post is fairly old, but I just stumbled upon it and thought it was a well thought out presentation introducing Aspect Oriented Programming (AOP) in Spring.

Welcome to another installment of This Week in Spring! As usual, we've got a lot to cover, so let's get to it!

1. SpringSource CTO Adrian Colyer outlines the direction and momentum of SpringSource and the Spring projects under the Pivotal Initiative, a new company spun out of EMC comprised of - among other things - SpringSource, Cloud Foundry, and GreenPlum. This is definitely worth a read if you want to understand Spring's - ahem - Pivotal role in this new initiative!

   </LI>  
   <LI> Spring Batch lead Michael Minella has <A href="http://www.springsource.org/node/9666"> announced that Spring Batch 2.2.0.RC1 is now available</a>.
   	The new release includes preliminary support for Spring Data, Java configuration support, non-identifying job parameters 
   	and numerous fixes and polishes. This release is amazing, and definitely worth a look. I, personally, <EM>love</EM> the Java configuration API that's
   	been surfaced. You don't need to write another…