Spring Framework 4.0.5 & 3.2.9 released - next stop: 4.1
Dear Spring community,
It's my pleasure to announce that Spring Framework 4.0.5 and 3.2.9 have been released. Both of those are designed as a final feature release in the respective line - we will only consider further releases from the 4.0.x and 3.2.x branches in case of serious bugs now.
http://projects.spring.io/spring-framework/
Spring Framework 3.2.9 comes with a repackaged ASM 5.0.2 and is therefore capable of basic Java 8 bytecode processing. However, specific Java 8 feature support - JSR-310 date-time, repeatable annotations, etc - is exclusive to the Spring Framework 4.x line.
Spring Data Release Train Dijkstra Goes GA
Hot on the heels of the Spring 3.2.9 and 4.0.5 releases, I am pleased to announce the availability of the GA release of the Spring Data release train named Dijkstra.
We're happy to welcome 5 new modules to the release train: Elasticsearch, Cassandra, Couchbase, Gemfire and Redis. Two of them even celebrate their first GA version ever. So I'd like to send special congratulations and thanks to the project leads Mohsin Husen for Spring Data Elasticsearch and David Webb as well as Matthew Adams for Spring Data Cassandra.
Here's the full list of participating modules:
- Spring Data Commons 1.8 GA - Artifacts - JavaDocs - Documentation - Changelog
- Spring Data JPA 1.6 GA - Artifacts - JavaDocs - Documentation - Changelog
- Spring Data MongoDB 1.5 GA - Artifacts - JavaDocs - Documentation - Changelog
- Spring Data Neo4j 3.1 GA - Artifacts - JavaDocs - Documentation - Changelog
- Spring Data Solr 1.2 GA - Artifacts - JavaDocs - Documentation - Changelog
- Spring Data Couchbase 1.1 GA - Artifacts - JavaDocs - Documentation - Changelog
- Spring Data Cassandra 1.0 GA - Artifacts - JavaDocs - Documentation - Changelog
- Spring Data Elasticsearch 1.0 GA - Artifacts - JavaDocs - Documentation - …
SpringOne2GX 2013 Replay: Migrating from WLS, WAS, JBoss to Pivotal tc Server
Recorded at SpringOne2GX 2013 in Santa Clara, CA
Speaker: Zhiyong Li
SAS® Institute has a large portfolio of Java EE applications. SAS had previously provided support to deploy and run all of these applications in WebLogic, WebSphere and JBoss. Beginning with SAS 9.4, which was released in July 2013, SAS updated its infrastructure and middle tier platform to deliver and run on Pivotal tc Server. In this talk, we will discuss the motivation, technology selection, architecture, system administration, automated installation and configuration, etc., that SAS used to improve value for its customers. Specifically, we will discuss the following areas in detail:
- Technology selection: To make tc Server viable, we include the messaging, caching and the transaction management system.
- Architecture: To leverage tc Server scalability and reliability in SAS products, we support clustering by using the Pivotal Web Server and the mod_proxy. Application migration: We provide guidance to our Java developers and configuration developers on how to migrate their applications to the tc Server environment.
- Security: We support SSL, single sign-on and other enterprise security protocols such as Integrated Windows Authentication, CA Site Minder, IBM Web Seal, SAML, etc.
- System administration: We provide a single entry point to manage all SAS application stacks including all web applications by leveraging the Hyperic product.
- Automated installation / configuration: We provide the automated process to install and configure Hyperic and all Pivotal Application Fabric products (tc Server, vFWS and GemFire) and SAS web applications.
- Delivery and support: SAS delivers embedded tc Server as the SAS Web Application Server for use with all our offerings with a midtier on all our supported host platforms. This enables SAS to provide complete supported application architecture with more complete visibility and control of the critical software.
- Cloud deployment: This approach also provides advantages for our customers leveraging virtualization and cloud deployment strategies.
!{iframe width="560" height="315" src="//www.youtube.com/embed/qfV4Bl80dJo" frameborder="0" allowfullscreen}{/iframe}
SpringOne2GX 2013 Replay: Virtualizing and Tuning Large Scale Java Platforms
Recorded at SpringOne2GX 2013 in Stana Clara, CA
Speakers: Emad Benjamin and Guillermo Tantachuco
The session will cover various GC tuning techniques, in particular focus on tuning large scale JVM deployments. Come to this session to learn about GC tuning recipe that can give you the best configuration for latency sensitive applications. While predominantly most enterprise class Java workloads can fit into a scaled-out set of JVM instances of less than 4GB JVM heap, there are workloads in the in memory database space that require fairly large JVMs. In this session we take a deep dive into the issues and the optimal tuning configurations for tuning large JVMs in the range of 4GB to 128GB. In this session the GC tuning recipe shared is a refinement from 15 years of GC engagements and an adaptation in recent years for tuning some of the largest JVMs in the industry using plain HotSpot and CMS GC policy. You should be able to walk away with the ability to commence a decent GC tuning exercise on your own. The session does summarize the techniques and the necessary JVM options needed to accomplish this task. Naturally when tuning large scale JVM platforms, the underlying hardware tuning cannot be ignored, hence the session will take detour from the traditional GC tuning talks out there and dive into how you optimally size a platform for enhanced memory consumption. Lastly, the session will also cover vfabric reference architecture where a comprehensive performance study was done. Learn more about
!{iframe width="560" height="315" src="//www.youtube.com/embed/htxkAMiAD58" frameborder="0" allowfullscreen}{/iframe}
Demo: Zero to Stream processing in 7 minutes with Spring XD
Speaker: Pieter Humphrey
Creating a stream of live twitter data for an analytics dashboard using Spring XD, a JavaScript D3 component / Spring XD's REST API.
Source code:https://github.com/spring-projects/spring-xd-samples/tree/master/analytics-dashboard
Learn more about Spring XD: http://projects.spring.io/spring-xd
Learn more about Spring for Apache Hadoop: http://projects.spring.io/spring-hadoop
!{iframe width="420" height="315" src="//www.youtube.com/embed/nOfzrQ6CdKI" frameborder="0" allowfullscreen}{/iframe}
Webinar Replay: Spring Integration 4.0 - The New Frontier
Speaker: Gary Russell
The Spring Integration team has been hard at work on the latest release of the popular integration framework. Before version 4.0, it was impractical to define a complete Spring Integration flow without using XML. With this major release, the existing basic annotation support has received an overhaul and those who prefer to use java @Configuration classes can now define their applications without needing to use any XML (of course, XML is still supported as well). In this session we will cover these major changes to the framework, explaining how and when to use them. It will be mainly demonstration and code walk through, and we will build a useful Spring Boot / Integration application from scratch.
Learn more about Spring Integration at http://projects.spring.io/spring-integration
Learn more about Spring Boot at http://projects.spring.io/spring-boot
Learn more about Spring Framework at http://projects.spring.io/spring-framework
!{iframe width="420" height="315" src="//www.youtube.com/embed/g3DgdSqEgzI" frameborder="0" allowfullscreen}{/iframe}
Spring Boot 1.1.0.M1 available now
The first milestone release for Spring Boot 1.1.0 is available now in the Spring milestone repository.
Highlights include:
- Additional templating support.
- Improved metrics and health endpoints.
- Additional data integrations (including improved MongoDB support and support for GemFire).
- A host of minor improvements and additions.
- Updated dependencies for many third-party libraries.
See the release notes for a complete list of new and noteworthy features.
We'd appreciate any feedback from existing Spring Boot 1.0 users. If you are upgrading, be sure to follow the instructions from the release notes…
This Week in Spring - May 13th, 2014
Welcome back to another installment of This Week in Spring! This week I'm in Krakow, Poland for Geecon, the Polish developer conference where, of course, I'll be speaking to developers about Spring. (and, maybe, Spring). If you're around, find me, I'll be wearing the giant Spring leaf t-shirt! :)
Other than that, there's a lot to get through so let's get to it!
- In preparation for the upcoming Spring IO Platform, Spring Data release train Dijkstra has been released! This is a tremendous release train that includes: JPA, MongoDB, Neo4J, Apache Solr, Couchbase, Cassandra, Elasticsearch, Gemfire, Redis and Data REST! Congrats to the Spring Data Team!
- Spring Boot 1.1.0 M1 is now available and introduces MongoDB and Gemfire support, as well as improved actuator metrics and health endpoints.
- Final maintenance releases for the Spring Framework 3.2.x and 4.0.x versions are now available!
- Spring Integration ninja (rockstar!) Artem Bilan put together a nice post introducing all the amazing Java configuration support in the nascent Spring Integration Java configuration DSL, which builds upon the basic
@EnableIntegration
support available in the just-released Spring Integration 4.0. You should read that post. Seriously. I want to steal some of Artem's thunder by excerpting this one amazing code-snippet:java @Bean IntegrationFlow helloWorldFlow() { return IntegrationFlows.from("helloWorldInput") .filter("World"::equals) .transform("Hello "::concat) .handle(System.out::println) .get(); }
Yep! That's a Spring Integration flow that handles input messages,filter
s them,transform
s them, and then gives them to the escape-hatch method,handle
, which lets the developer insert any behavior into the mix. Remember, you can change anything about this - including where it gets the messages from and where it writes the messages to. Indeed, the output of one flow could be the input to another. Congratulations, Spring Integration team! Also, make sure to check out the launch webinar replay! - I know I mentioned this last week, but it's so worth a re-read! Groovy 2.3.0 is here! (Hah! Gotcha! This week's link was to a different post by the same author on the subject of the Groovy 2.3.0 release! But aren't you glad you read it, anyway?) Go, Groovy, go!
- My pal Pieter Humphrey has done a nice introductory screencast on Spring XD - showing how to get up and running doing stream processing, and wiring it to an analytics dashboard in less than 7 minutes. XD uses a deceptively simple DSL (domain specific language) and no Java code - it's never been easier to work with Hadoop.
- Spring Security lead Rob Winch has been moving heaven and earth to make unit-testing secure applications easier than ever. In this first installment of a new series, Rob looks at new annotations designed to stand in place of a live-fire Spring Security apparatus to mock a
Principal
, aUserDetailsService
, and more. Check it out and stay tuned for more! - Speaking of Rob Winch, he gave an epic introduction to Spring Security at SpringOne2GX 2013 last year. This is a perfect place to jump onboard if you're new to Spring Security.
- New Relic's Ashley Puls was kind enough to do a webinar with your humble author on Web Application Diagnostics using New Relic. Thanks, Ashley! I'll be very honest, this webinar was super informative for me. I knew just a little about New Relic, and in working through the development of the webinar I learned about a zillion and five use cases that are well served by New Relic. Really cool stuff!
- Also published this week - a SpringOne2GX 2013 Replay by Emad Benjamin and Guillermo Tantucho: Virtualizing and Tuning Large Scale Java Platforms. This goes over JVM memory tuning and all the tricks and tips for getting Java to run well on a virtualized environment.
- SpringOne2GX 2013 replay - a great talk from SAS Software: Migrating from WebLogic, WebSphere, JBoss to Pivotal tcServer. This might go well with a recent post on why App Servers are dead by Eberhard Wolff.
- Do you love Spring's new home on the web, spring.io, as much as I do? Want to learn more? Check out this talk by project lead and Spring ninja Chris Beams on the makeup of the site, its development, and deployment.
- Last week, Spring Data Neo4j lead and graph-ninja Michael Hunger and I gave a talk on Spring Boot and Neo4j. This talk was fun for me because it gave me a lot of excuses to play with Neo4j. In point of fact, Michael and I are doing a webinar on about the same subject on the 20th of May (that's 7 days away!), so come see what we've come up with. In the meantime, you may want to check out this recent post on creating a time-tree with Cypher, the language that Michael works on that's used to drive interactions with Neo4j. That post was, of course, a response to another post that Michael put together on importing forests into Neo4j, also worth a read!
- I quite liked this post introducing how to setup a Spring Batch job using Spring Boot. The author found a comfortable configuration-middle ground in the Groovy
BeanBuilder
support, and describes it nicely in this post - Moritz Schulze has put together a very nice post, following others in the series, on how to integration test REST services
- Are you using Spring Boot and want to use Spock? Netflix engineer Tomas Lin has put together an example on his GitHug page. Check it out!
- Jakub Kubrynski has put together a nice post on how to use Spring Boot's
org.springframework.boot.actuate.system.ApplicationPidListener
(which Jakub contributed - thanks Jakub!) - to work with the application's process identifier (PID
). Nice! - Meltdown 1.0.0 has been released! Meltdown is a Clojure interface to the Reactor project. So... functional programming and stream processing inside a lisp-like language? A dream! Check it out!
Spring Batch 3.0.0.RC1 is now available
Today we are pleased to announce the release candidate for Spring Batch 3.0. This release of Spring Batch provides the support for JSR-352 we are committed to providing as well as a number of new features for our existing Spring Batch community.
Features in Release Candidate 1
The major features for this release include:
- JSR-352 support
- Promotion of Spring Batch Integration into Spring Batch
- Complete overhaul of dependencies
- Support for SQLite
- Job scope
- Switch from Maven to Gradle for building Spring Batch
JSR-352 Support
JSR-352 is the batch JSR and was released as 1.0 late last year. As Spring Batch served as the inspiration for much of the programming model of this JSR, Spring is committed to supporting it. With the 3.0 release, Spring Batch is compliant with JSR-352 passing all TCK tests. It provides the most production-tested implementation of the JSR.
Creating batch jobs that comply with the standards of this JSR should feel very familiar to users of Spring Batch. The XML configuration and interfaces are very similar to the existing Spring Batch. Below is an example JSR-352 batch job
```xmlSpring Batch's implementation of JSR-352 was developed to allow the most flexibility for existing Spring Batch users. We allow developers to use existing ItemReader, ItemProcessor, ItemWriters, etc in conjunction with the configuration facilities that JSR-352 provides. This provides developers a complete library of production-tested components for building robust batch jobs.
To read more about Spring Batch's implementation of JSR-352, visit our reference documentation here: http://docs.spring.io/spring-batch/trunk/reference/html/jsr-352.html
Promote Spring Batch Integration to Spring Batch
The line between when to use Spring Batch or Spring Integration is often a blurry one. There are many use cases where one works better than the other. However, there are also many use cases where they can be used together to build robust and scalable data processing systems. Spring Batch Integration provides a collection of components to use Spring Batch and Spring Integration together. Use cases that Spring Batch Integration provide for include:
- Asynchronous item processing
- Remote chunking
- Launching batch jobs via messages
- Remote partitioning
These capabilities take batch processing beyond what JSR-352 provides and allows users to develop batch applications that scale beyond a single JVM. You can read more about Spring Batch Integration and it's components in the reference documentation here: http://docs.spring.io/spring-batch/trunk/reference/html/springBatchIntegration.html.
Complete overhaul of dependencies
We took this opportunity to review all third party dependencies for Spring Batch and bring them up to date. As part of this exercise, we also brought them in alignment with the other projects in the Spring portfolio to allow for the easiest experience in adding Spring Batch to an existing application (or adding other projects to a Spring Batch project).
Support for SQLite
While HSQLDB is useful for many testing scenarios, a file based system like SQLite can also be very useful. With the 3.0 release we have added the job repository DDL for SQLite to address these use cases.
Job scope
Spring Batch's step scope allows developers to delay the creation of objects until a particular step is executed. This functionality has also exposed the ability to provide late binding of properties in batch artifacts. With this 3.0 release, Spring Batch introduces a Job scope. This scope works in the same way as the step scope (delays the creation of objects via proxies), however it delays the creation until the job executes instead of the step. This can be helpful when defining multiple jobs in a context or when heavy weight initialization processes occur in step level components. You can read more about the job scope in the reference manual here: http://docs.spring.io/spring-batch/trunk/reference/html/configureStep.html#job-scope.
Move from Maven to Gradle
Finally, this release is the first for Spring Batch to move from Maven to Gradle for an internal build system. This change will have zero effect on developers consuming the jars. They will still be available via Maven Central for maven users.
Conclusion
3.0.0.RC1 represents the completion of the next major milestone for Spring Batch. It brings the standards that JSR-352 provides to our community as well as providing an exhaustive collection of additional features for the advanced user. We look forward to your feedback in the forums, social media, and in person at SpringOne2GX!