Dear Spring Community,

I am pleased to announce the release of Spring Data Redis 1.2.1! This maintenance release contains some bugfixes in RedisTemplate as well as in RedisCacheManager.

As always this version is tested against Java 6, 7 and 8, for compatibility with Redis 2.6 and 2.8 as well as Spring Framework 4.0.3. You can run this Jira Query for a complete list of changes.

We look forward to your feedback on the forum or in the issue tracker.

Cheers, your Spring Data Team!

Spring Security 3.2.3 has been released and is now available from Maven Central. This release brings a number of bug fixes including:

• A fix to Java Configuration to work with Spring Boot. See SEC-2531
• A fix to Java Configuration that when CSRF protection is disabled allows remembering the last page prior to authenticating when it is a POST to work with JSF. See SEC-2498

You can find additional details within the changelog .

Welcome to another installment of This Week in Spring! This week is going to be a crazy week, and I can't wait to see you on the other end of it next week! There are some BIG announcements coming! Keep your eyes glued to spring.io this week: So. Much. Win. Alright, with that out of the way, let's get to it!

• Spring Boot co-lead and all-around awesome guy Phil Webb has announced that Spring Boot 1.0.0.RC5 is now available. I can't stress this enough: download the bits, try 'em out and give them a smoke test against your code. The GA release is very soon, and we want to have as few surprises as possible!
• Speaking of Spring Boot, Erdem Gunay put together a very cool post detailing how he took an existing app, reworked it with Spring Boot and got it up and running in one week. Wow! I note that one point he points to a configuration file that's all in XML, but it doesn't need to be. In fact, the beans so configured would be more concisely described in java. Check out the post, either way! Great stuff, Erdem!
• Spring Security lead Rob Winch has put together a nice introduction to using Spring Test MVC with HtmlUnit, which he introduced last week.
• Spring lead Juergen Hoeller has put together a really good look at the state of Java 8 in enterprise projects - a great, pragmatic resource for people stuck on eariler JDK versions.
• Speaking of Java 8, my pal Pieter Humphrey shared a great resource on the subject of Java 8 first-class functions in Manning's Java 8 tutorial video. Check it out!
• The Syntx.co blog has a nice post on how to use Spring 4's websocket support along with a simple client-side example
• Sergi Almar's Blog has a great post on Detecting WebSocket Connects and Disconnects in Spring 4. Great for presence detection usecases in games, chat, etc.
• Sergi Almar is on fire this week! He also posted a some good info on how to Track your WebSocket messages with Spring 4 and RabbitMQ.
• SpringOne2GX 2013 Replay: Tips and Tricks for Client Side Performance by Scott Andrews is now up on YouTube!
• It's Javascript March madness around here - another Javascript session from SpringOne 2GX: AOP-ing your JavaScript by Brian Calavier is now up on YouTube!
• OK, I confess, I almost didn't include this post because of its name. I won't repeat it here, but if you can look past the name and just read the post, it's hilarious and - to be honest- a rather good narrative on choosing a dependency injection approach.
• The DevCrumb blog has a nice post introducing how to use Spring 3.2.2 and Hibernate 4.2.0 together. This works but I'd advise against using any XML configuration (or any configuration at all!) if it can be helped. Most of the code in this post goes away if you use Spring Boot. If you also use Spring Data JPA repositories (and why wouldn't you?), then all of the code except for the Person entity can be thrown away.
• There's a neat post on JournalDev by Pankaj Kumar that looks at using Spring's AOP support.

Speaker: Juergen Hoeller

Slides: https://speakerdeck.com/jhoeller/spring-framework-4-on-java-8

Spring has a track record of providing dedicated support for new Java generations in a timely fashion, and now it's right about time to go Java 8: With Spring Framework 4.0, we're providing in-depth support for all relevant OpenJDK 8 features, including lambda expressions, JSR-310 Date and Time, parameter name discovery, and java.util.concurrent enhancements. This talk will illustrate basic Spring Framework 4.0 concepts, and selected Java 8 features within Spring's programming model, exploring the impact on application architectures.

Learn more about Spring Framework at: http://projects.spring.io/spring-framework

and at

http://spring.io/guides

!{iframe width="420" height="315" src="//www.youtube.com/embed/90MBOV6mOPM" frameborder="0" allowfullscreen}{/iframe}

In my second post I described how to use Spring MVC Test with HtmlUnit. In this post we will leverage additional abstractions within WebDriver to make things even easier.

Why WebDriver?

We can already use HtmlUnit and MockMvc, so why would we want to use WebDriver? WebDriver provides a very elegant API and allows us to easily organize our code. To better understand, let's explore an example.

NOTE Despite being a part of Selenium, WebDriver does not require a Selenium Server to run your tests.

Suppose we need to ensure that a message is created properly. The tests involve finding the html…

Speaker: Mattias Arthursson, Spring LDAP lead

Slides: https://speakerdeck.com/marthursson/spring-ldap-2-dot-0

The recently released 2.0 version has given the Spring LDAP project a significant facelift. With new features like Spring Data Repository and QueryDSL support, a fluent LDAP query builder, and XML namespace configuration, LDAP administration applications can now be built more efficiently than ever. This webinar will provide an overview of the goals and scope of Spring LDAP and demonstrate all the improvements in version 2.0, giving you plenty of hands-on tips along the way on how to make maximum use of the library.

Learn More about Spring LDAP at: http://projects.spring.io/spring-ldap

!{iframe width="420" height="315" src="//www.youtube.com/embed/hdUQaGePWRo" frameborder="0" allowfullscreen}{/iframe}

In my previous post I introduced Spring Test MVC HtmlUnit and explained the motivation behind the project. In this post I will describe how to use Spring MVC Test with HtmlUnit.

Updating Dependencies

Before you use the project, you must ensure to update your dependencies. Instructions for both Maven and Gradle can be found on the site documentation.

Using HtmlUnit

Now that we have the correct dependencies, we can use HtmlUnit in our unit tests. Our example assumes you already have JUnit as a dependency. If you have not added it, please update your classpath accordingly. The complete code sample for using HtmlUnit and Spring MVC Test can be found in MockMvcHtmlUnitCreateMessageTest…

Recorded at SpringOne2GX 2013 in Santa Clara, CA

Speaker: Jeremy Grelle

As the complexity of web and mobile apps increases, so does the importance of ensuring that your client-side resources load and execute in an optimal and efficient manner. Differences in resource loading techniques can have a dramatic impact on how fast an application feels to your users, and can be the catalyst for whether they have a joyful or frustrating experience. This talk will discuss performance techniques aimed at keeping your users on the joyful end of this user experience spectrum. We'll take a look at:

• Pragmatic tools for measuring client-side performance
• Techniques for optimizing resources and their resulting impact
• Approaches to maximizing dev-time happiness and production performance
• Easy incorporation of these techniques into your everyday tool-chain

!{iframe width="560" height="315" src="//www.youtube.com/embed/wrdNdp1Dyrc" frameborder="0" allowfullscreen}{/iframe}

Recorded at SpringOne2GX 2013 in Santa Clara, CA.

Speaker: Brian Cavalier

Loose coupling. Your web front-end has that, right? Your JavaScript is using pubsub, event emitters, and message buses! Guess again, you can do better. Aspect Oriented Programming (AOP) is a technique for augmenting the behavior of objects, methods, and functions non-invasively. AOP adds new behaviors and modifies existing behaviors "from the outside". Using AOP, it's possible to create connections between components without either having any knowledge of the other and without any extra library dependencies in your code. While you may be familiar with AOP in Spring, you may not yet have applied it in JavaScript. In this talk, we'll do just that. We'll introduce simple techniques for applying AOP in pure JavaScript using no additional libraries, and then look at meld.js (https://github.com/cujojs/meld), the AOP library that powers Cujo.js (http://cujojs.com). We'll work from simple examples of making connections between components to more sophisticated examples that integrate pubsub, message buses, etc. in a truly loosely coupled way.

!{iframe width="560" height="315" src="//www.youtube.com/embed/MoZgJY2IF4A" frameborder="0" allowfullscreen}{/iframe}