Spring 2.0 has marked a major advance in the Spring Framework. While still maintaining backwards compatibility, this release adds quite a few new features. What are those features and how do they add value? Come by and see.

In this session we'll provide a practical tour of what's new in Spring 2.0. Spring 1.x users who are looking to upgrade to Spring 2.0 will love this session. If you're not using Spring already, this talk will give a great overview of the things you're missing out by not using Spring 2.0.

The talk will highlight new configuration strategies, Spring AOP, bean scoping, JPA support, JMS improvements, new Spring MVC features, VM languages, and much more.

To today's JEE developer, there are two indispensable tools for creating applications; Spring and Hibernate. Together these two frameworks comprise one of the most powerful and often used stacks in the industry. While it is possible to do amazing things it's not always obvious how best to use them to maximize value. This session aims to correct that.

In this session, we'll start by addressing the basic design of an application using Spring and Hibernate. Once we've established some baseline best practices, we'll focus on how to best use Hibernate (both 2 and 3) in the persistence tier. We'll take a look at the use of Spring's HibernateTemplate and some new strategies in Spring 2.0. To finish with a look to the future, we'll explore use of JPA (Hibernate implementation) with Spring 2.0.

You're winding down a project and you get that dreaded email from your project manager, "How hard would it be to add some performance monitoring to the system?" Well, after this session, you'll be able to respond, "No problem at all!" It turns out that with a pinch of AOP and a dash of JMX, you can introduce amazing management and monitoring capabilities without changing your mainline code one bit.

In this session, we explore the technologies of AOP and JMX and how they can be used together to transparently add management and monitoring in a completely non-invasive way. We'll explore some of the various AOP packages including Spring AOP and AspectJ and how they can be used to apply management and monitoring inline to an application. Once we've added this functionality we'll how to expose it using JMX using Spring's JMX support and consume it using JConsole or Spring.

If you're tentative about introducing AOP or JMX into your application, come take a look at some of the cool things you can do with them and how easy it can be.

Security is one of the major requirements in modern day enterprise applications and yet it is also one of the weakest parts of most developers toolboxes. The problem is of course that security is HARD! It turns out that rather than reinventing the wheel for each application, developers can turn to a great security framework out there already; Acegi.

In this session we'll discuss a little known but widely used Spring sub-project called Acegi Security. Acegi is a great tool for implementing security at the URL, method, and domain object layers and can greatly simplify security requirement fulfillment for enterprise applications. The first part of the session will focus primarily on some basic security concepts and where Acegi fits into the equation. The second part of the session will focus on basic design and usage principals of Acegi. The final segment will be a live coding example where we actually take an application and add all three levels of Acegi security to it. As a bonus, I'll even tell you the story of how the Acegi name came about :)

Have you ever developed a web application with a long user action based on form input? Did you curse the Java community for their inability to address this very common application type? Well, attend this session about Spring Web Flow and you'll curse no more.

In this session we'll learn about a new(ish) Spring sub-project, Spring Web Flow. Spring Web Flow is an innovative new framework for declaratively modeling web application user interactions. We'll start with an exploration of some web development issues and then take a look at the value proposition that Web Flow brings to the table. Once everyone is comfortable with that, we'll jump straight to code. We'll start by exploring some of the features that SWF has and then we'll finish with a live coding example where the audience will help write the application.