The Spring framework is one of the fastest growing open source frameworks. New job postings are gaining rapidly, and many customers are adopting Spring instead of heavier alternatives. In this session, we’ll introduce Spring. You’ll see how Spring can give you much of the power of EJB, without the complexity or pain.

Spring uses concepts like dependency injection and aspect oriented programming to ease standard enterprise development. Spring developers write plain, ordinary Java objects (POJOs), instead of sophisticated components. In this session, you’ll see a basic Spring application. You’ll also see some details about some of the enterprise integration strategies, including:

• Spring AOP • Transactions • Persistence • Model/view/controller

When the session is over, you won’t be an expert, but you should have a much clearer understanding of what Spring does, what it doesn’t do, and why it’s growing so rapidly.

Dependency Injection (DI) is the cornerstone of Spring. The core concept is quite simple, but (surprise!) actual practice can become complex. To take full advantage of Spring DI, you need to understand not only the basics on configuration, but also the container lifecycle model and the various hooks provided by the framework.

Topics will include

• The difference between DI and Continuous Integration
• Setter Injection
• Constructor Injection
• Factory Injection
• Bean lifecycle
• Method Injection
• Using the ApplicationContext
• Custom PropertyEditors

Web applications have traditionally been a sort of Faustian bargain, yielding the high-quality user experience that desktop applications can deliver in exchange for incredibly easy deployment and lower support costs.

One of the arguments against creating rich HTML/JavaScript has been how difficult they can be to write and maintain. You will see how to adapt modern Java web frameworks such as JavaServer Faces and Tapestry to ease both the creation and maintenance of these types of applications.

With Ajax we can get a lot of the best of both worlds. Now our web applications can be powerful, usable, an easily deployed!

Web applications have traditionally been a sort of Faustian bargain, yielding the high-quality user experience that desktop applications can deliver in exchange for incredibly easy deployment and lower support costs (i.e., no client software to install, upgrade, and test on every conceivable desktop configuration).

It turns out that these qualities need not be mutually exclusive. As several recent high-profile web applications such as Google's GMail have shown, modern browsers (e.g., Internet Explorer 6, Mozilla/Firefox, and Safari) are capable of rendering web applications with highly dynamic and compelling user interfaces -- fetching data from a server without page refreshes, animating and manipulating page contents on-the-fly, and all without resorting to third-party plug-ins like Flash. The line between a ""web"" application and a ""desktop"" application is blurring.

Let's blur it some more. Another major limitation of web applications is the lack of ability to function in a disconnected (i.e., off-line) mode. It turns out that this too is quite possible with the right architecture -- a web application can continue to function in a modern browser even in the absence of an Internet connection. And when the connection is re-established, data collected while in off-line mode can be uploaded to a server.

Developers seeking practical, real-world advice for creating next-generation, rich web applications won't come away from this presentation disappointed.

Learn to use Spring AOP, aspect injection. and AspectJ integration

Spring provides powerful support for Aspect-Oriented Programming (AOP), via

• Spring Advisors
• Dependency Injection for Aspects
• Integration with AspectJ

In this session you will learn to use Spring AOP in real-world settings. We'll start with the basics of programmatic pointcuts, advice, and joint points. Then, we'll integrate these into the application Spring-style, using Dependency Injection.

With the basics out of the way, we'll move to meatier questions, including:

• How (and when) should I step up to AspectJ?
• How are Aspects implemented, and what are the performance implications?
• What are the alternatives to Aspects?

Attendees will get more out of this presentation if they have a basic knowledge of Spring and Dependency Injection.

Hibernate is easy to get started with, but can sometimes be hard to make efficient or secure. In fact, the default settings for Hibernate createapplications that will run slowly, cause unwanted round trips to the database, and may be more restrictive and/or permissive from a security standpointthan you would otherwise want.

This session will show advanced techniques for tuning performance, including: • advanced collection mapping strategies • lazy loading • cascading update management • lifecycle management • Hibernate's interceptor layer In addition, we'll examine the security considerations when using Hibernate. Often, single-credential data access isn't enough for sensitive data. We'll walk through using per-user credentials for data access, logging security information about and through Hibernate, and accessing data sources through secure application servers.

Java has always provided a model for concurrency and threads. With Java 1.5, this model received a major facelift. Learn how to use the new concurrency utilities to build responsive, scalable, and correct concurrent applications.

Java's support for threads is broad and deep. From the early days of the platform, programmers have used threads, synchronized blocks, and monitors to build safe multi-threaded applications. Java 1.5's new concurrency utilities greatly reduce the need to use these primitives directly. Now, Java provides a set of lock classes and task scheduling tools that provide much more leverage in writing real applications. We'll explore java.util.concurrent, and also see how the Java Memory Model has been corrected in 1.5.

Most of the advantages of java.util.concurrent can also be had in previous version of Java. We'll discuss Doug Lea's concurrency utilities and the backport of java.util.concurrent to 1.4. Both of these are appropriate for production use.

Finally, we'll look at common mistakes in multi-threaded programming. The most common mistake is using threads when you don't need them. We'll look at alternatives to threads, and how to choose between them.

The Java platform is built from the ground up with security in mind. This talk will introduce the security features of the J2SE, building quickly from the basic classes to realistic examples.

You will learn the core APIs:

SecurityManager, AccessController, Permissions and Policy

JAAS Subjects, Principals, and LoginModules

You will then see how to invoke these APIs in real application scenarios. You will learn how to:

Partition your applications to safely invoke downloaded code

Read and write Java policy files

Extend the architecture with custom permissions

Provide secure services through PrivilegedActions

Use JAAS to authenticate and authorize users