By Craig Walls

Windows changed everything. Back in the days of MS-DOS, you could only run one application at a time. Switching between writing a letter and balancing your checkbook involved closing a word processor and opening a spreadsheet. But now you can be running dozens of applications simultaneously, each inside its own window. And now switching from one application to another may be as simple as a shift of your eye or a click of the mouse button.

Portals do for web applications what Windows did for MS-DOS. With traditional web applications such activities as checking the weather, viewing baseball scores, and keeping up with the latest news involves visiting several distinct web applications. But with portals, all of these applications, presented as portlets, can be combined into a

single web-page for convenient and concise viewing.

In this session, I'll demonstrate how to build portlet application using Spring Portlet MVC, an adaptation of the Spring MVC framework that is geared toward writing JSR-168 compliant portlet applications.

By Craig Walls

Where Spring promotes loose-coupling between your application objects, service-oriented architecture (SOA) encourages loose-coupling between applications that interact with each other.

In this presentation, I'll show you how to build loosely-coupled architectures based on Spring-enabled services. We'll look at Spring's remoting and messaging support and you'll see how to easily turn simple POJOs into web-services, message listeners, and remote services.

In addition, you'll see how Spring can be used with MuleESB and ServiceMix to take loose-coupling between applications to a higher level.

By Craig Walls

Most well-designed web applications can be broken down into three logical layers: presentation, business, and persistence. In addition, many applications require a fourth layer to provide security.

At each of these layers, you are given several choices: Should you use Hibernate or JDO for persistence? Spring MVC, JSF, or Tapestry for presentation? Spring's promotion of loose-coupling makes it easy to mix-n-match frameworks at each layer with minimal or no impact to the other layers.

In this presentation, I'll show you how to build an application using my favorite arrangement of frameworks: Hibernate, Spring, Acegi, and Tapestry. In doing so, I'll explain why I favor this arrangement and also demonstrate how loose-coupling makes it easy to swap out one framwork for another.

By Ben Alex

This presentation will provide developers with a practical approach to security issues typically encountered when developing Spring-based enterprise applications, with a particular focus on Acegi Security.

We will cover authentication, web request authorization, method authorization on your services layer beans, and domain object access control capabilities. The presentation will briefly compare two common implementation approaches: container managed authentication (CMA) and Spring/Acegi Security. A sample web application will be used throughout the presentation to illustrate some typical security requirements of enterprise applications. We will migrate this sample application from CMA to Spring/Acegi Security during the course of the presentation.

No previous experience with Spring Security is required to benefit from this presentation, although a basic understanding of CMA and configuring S

By Ben Alex

Moving beyond the basics of using Acegi Security, in this presentation we will review some of the more sophisticated capabilities and extension points provided by Acegi Security.

We will focus on the domain object instance access control list (ACL) capabilities in particular. We will review several of the popular extension points and advanced features that are useful to in more sophisticated enterprise applications.

This presentation is not an introduction to Acegi Security. If you are new to Acegi Security, you will gain the most benefit from this presentation by firstly attending one of the other introductory Acegi Security sessions available as part of The Spring Experience (for example, "Practical Quick Start With Spring/Acegi Security").

By Alef Arendsen

In the world of service oriented architectures and complex integration challenges, web services are have become an important part of application development. Using Spring and various 3rd party tools we will have a look at elegant ways to expose a Spring-based middle-tier using web services.

This session will focus on explaining how to combine Spring and 3rd party tools such as Axis and XFire to get to a well-designed web service on top of a Spring-based middle-tier.

We won't only look at the integration bits, but also discuss best-practices and new ways to expose web services. We will talk about questions such as whether web services are just another way to do RPC, whether contract-first development really is a good fit and how to get around various OXM (Object-XML-mapping) issues.

After this session you will have a clear view of how to create web services with Spring and what things you definitely have to keep in mind.

By Alef Arendsen

Although web services are gaining importance, there still is room for RPC-style invocations of objects on remote servers. Spring features a set of easy-to-use tools that allow for transparent exposing of beans in a Spring middle-tier.

This session will focus on what techniques are available to expose beans in a Spring-based middle-tier using a variety of protocols and what scenarios you may encounter that validate the use of remoting.

We will review how to expose Spring-managed beans using RMI, Hessian, Burlap and Spring's HttpInvoker. The protocols all have their advantages and drawbacks and we'll discuss them all.

By Jonas Boner

How do you scale a Spring application beyond a single node? How can you guarantee high-availability, eliminate single points of failure and make sure that you meet your customer SLAs?

Historically speaking, clustering an application is not easy: it takes a significant amount of time and usually requires you to rewrite parts of your application. It also usually perturbs your domain model and breaks object identity.

But does it have to be like that?

In this talk Jonas Bonér will walk you through how to cluster your Spring application, Transparently and Naturally, with zero changes to your application code, using the forthcoming Terracotta Spring Runtime. The Terracotta Spring Runtime allows you to take an arbitrary Spring application, written for a single JVM, and cluster it to N

nodes while preserving the exact same semantics. It also drops in a custom implementation of Spring AOP which improves its performance significantly (even when running on a single node).

The session is backed up by live demos, showing for example:

how to make Spring Bean's lifecycles and state mean the same thing on a cluster as on a single node (e.g. cluste

By Jim Clark

I look at the Java Persistence draft spec as being both good for developers and good for the vendors. For those of you who want to use ORM frameworks in your Spring DAOs, you'll probably be glad to finally see some agreement on just what APIs and what metadata will be required. And vendors, suddenly freed from endless language wars, can perhaps focus on implementation issues. Which, I guess, is also good for developers.

But for many of us who have been working with O/R issues for a few years, this spec provides us with an opportunity to think about the generic problems involved in O/R mapping. Therefore, I'd like to discuss some of the key issues involved in the implementation of a JPA PersistenceProvider. I will start out by discussing why it is possible to have a spec at all. But in my opinion, the more interesting discussion is the handling of the issues that are "hidden" behind the spec. How are Objects isolated into seperate transactions? What is the role of byte-code weaving (what JoinPoints are of interest to JPA implementations)? What is the role of caching?

With the Glassfish reference implementation now quite functional, and project Dali also moving along quickly, it has recently become possible to test out these ideas and to compare and contrast different solutions. For example, how difficult is it to implement an EJB3.0 version of the Spring PetClinic sample app? I actually know the answer to this. :).

By Dieter Dirkes

Developing and operating Spring based applications is nice. But what about managing and monitoring them? Based on a case study from DekaBank, Frankfurt, Germany we will show you what DekaBank, its partner Accenture and Wily Technology do for managing Spring based applications.

Starting with a short explanation of the product Introscope from Wily Technology we will demonstrate which key components of a Spring based framework we monitor at DekaBank and how you can improve the performance, scalability and stability of Spring based applications.

By Keith Donald

Spring is a key part of the agile development equation. But alone, Spring is not enough. To be agile, you need discipline, you need good people, and you must embrace change. From a technical perspective, you need a strong build process, automated dependency management, database schema management, IDE integration, and comprehensive testing strategies for all layers of the application.

In this session, Keith and Christian will walkthrough a ?jumpstart? application development environment, the same environment Spring uses internally to manage its projects and Interface21 uses on its clients engagements, and show how it enables developer productivity. When developers can start a new project from a common blueprint, and leverage a shared build environment which takes care of all related concerns, they are able to very quickly start working on adding business value, and generally with less chance of getting into trouble. Aside from reducing wasted effort, this also effectively makes a Spring-based stack a viable choice both for smaller as well as larger applications.

Christi

By Keith Donald

This session focuses on Spring Web Flow (SWF), a core module of Spring?s web stack, and its architecture as a powerful controller technology based on a finite-state machine.

The session highlights SWF's capabilities, namely the ability to capture web application page flows as self-contained, reusable modules that make dynamic and sophisticated page navigation decisions. It demonstrates solutions to common issues facing web application developers in areas such as application transactions, duplicate submits, security, testability, browser-navigation button use, and state management.

This session also shows how Spring Web Flow may be leveraged in a variety of web environments as a compliment to "traditional" controllers. You?ll see how to embed flows within a number of established frameworks in the web space, including Spring MVC, Portlet MVC, Struts, and JSF.

You'll learn the benefits of using a declarative, test-driven approach to building page flows to orchestrate controlled navigations that drive business processes. You'll leave with an understanding on when and how to leverage Spring Web Flow in a productive, best-practice manner.

By Keith Donald and Rod Johnson

Dependency Injection seems like a simple concept. In this session, Rod and Keith will explain:

• The important corner cases where simple DI falls down, and how Spring provides elegant, powerful solutions, based on extensive experience • “Factory beans” and when to use them • The different strategies for turning legacy code into Spring-managed services • The relationship between annotations and dependency injection • The combination of DI and AOP, and why it’s so important • Extending the Spring IoC container without changing Spring itself • The many value adds that a powerful DI container can provide

In this session, Rod and Keith will explain:

• The important corner cases where simple DI falls down, and how Spring provides elegant, powerful solutions, based on extensive experience

• “Factory beans” and when to use them

• The different strategies for turning legacy code into Spring-managed services

• The relationship between annotations and dependency injection

• The combination of DI and AOP, and why it’s so important

• Extending the Spring IoC container without changing Spring itself

• The many value adds that a powerful DI container can provide

By Keith Donald

The past year has brought a resurgence of Java? technology on the desktop. With the Java 2 Platform, Standard Edition (JSE?) 1.5, The Java Foundation Classes (JFC/Swing) API delivers a mature toolkit for desktop application developers to build on. With a strong base in place, focus is now turning toward ways to improve developer productivity. Developers seek effective desktop application architectures atop JFC/Swing that allow them to focus on creating business applications that look professional and stay maintainable. This session introduces the Spring Rich Client Project (Spring Rich) as an answer to that need.

In particular, this session highlights Spring Rich's capabilities as a state-of-the-art desktop application framework, including its integration with core Spring for application configuration, layering, and dependency management. It also covers the design strategies behind Spring Rich's solutions to common desktop application problems, in areas such as "as you type" control data binding and validation, centralized GUI commands (actions), form construction and layout, and important application window, view, editor, dialog, and wizard abstractions.

The session showcases the value of using a lightweight container within a JSE environment, contrasting it with traditional programming models. It

By Keith Donald

Spring Web Flow (SWF) is an exciting new technology for the development of self-contained application controller modules. From Builder, to State, to Strategy, to Memento, the SWF code base is full of pragmatic applications of well known GOF design patterns that solve problems for web application developers in innovative ways.

This is an advanced session that focuses on the application of those patterns and the problems they solve. Attendees will gain in-depth insight into the SWF architecture and will take away knowledge of how they can apply OO patterns effectively in their own projects.

By Justin Gehtland

Come and build an actual Enterprise Service Bus from the ground up using Spring, Mule and just a touch of Ruby.

This code-heavy talk will focus on what it means to build an ESB, and how to do it with open source technologies: Spring, Mule (from Codehaus) and Rails. We'll see the messaging layers, the integration of Spring and Mule, and a little cross-platform goodness just for good measure. Learn why the mysterious ESB isn't so mysterious after all.

By Justin Gehtland

The Spring team, as in all things they do, have learned the valuable lessons of the past when introducing a Spring solution. Spring MVC is everything Struts should be, and more besides.

This talk will introduce you to the Spring web application framework. You'll find out about the Controller hierarchy, and how the different kinds of Controllers allow for a more manageable logic tier. We'll look at validation and exception handling, configuration, URL mapping and CommandControllers (Spring's answer to ActionForms). Finally, we'll look at Spring's integration with another powerful web framework, Tapestry.

By Justin Gehtland

In this session, you will learn what Ajax is and how it is revolutionizing the way that web applications are developed.

In a similar way, the Spring Frameworks is greatly simplifying the code that we write Java web applications with.

By Rob Harrop

Aspect-oriented programming (AOP) is a technology that can help you keep your business objects pure and simple. In this session, Rob Harrop and Adrian Colyer will explain the concepts behind AOP and show how you can start benefiting immediately by using the AOP-based services built into Spring.

This session presents an in-depth discussion of the Spring AOP proxy architecture and shows how to get the best performance from you Spring AOP applications. Spring 1.3 integrates even more closely with AspectJ, and this session will also cover when to use Spring-based AOP services, when to use AspectJ aspects, and how you can move seamlessly between the two.

By Rob Harrop

Developing enterprise applications is a difficult job but keeping those applications running in peak condition after deployment can prove even harder. Developers put a lot of effort into building fast, scalable applications but often place less importance on the ease in which these applications can be managed once deployed.

In this session, developers will learn to exploit lightweight techniques with traditional Java management technologies, using both Spring and JMX to build-in manageability to their applications in a transparent manner. This session presents an in-depth look at the JMX features that exist in Spring including exposing Spring beans to JMX, JMX notifications, JSR-160 connectors and JMX proxies.

As you will see, creating JMX MBeans is only half of the puzzle – accessing these MBeans is equally if not more important. In this session, attendees will learn how to access local and remote MBeans using the JConsole tool in Spring JMX and they will learn how to take advantage of close integration betwe

By Rob Harrop

Many of the concepts in Spring are not specific to the Java world and have a wider applicability across the enterprise development space. Features such as Dependency Injection, AOP and consistent data access abstractions have their place on all enterprise development platforms.

For this reason, the Spring .NET project was established and has steadily been working to provide a solid platform on which to build .NET applications. In this session, Rob and Aleks will demonstrate many of the core features of Spring that have been ported to the .NET platform as well as many of the .NET-specific features that have been given the Spring treatment. Some of the topics covered in this session include Dependency Injection, AOP, data access, ASP.NET integration and Windows Service integration.

By Rob Harrop

Many developers are unaware of many of the more useful features available in Spring MVC and as such are not taking advantage of the full power at their fingertips.

In this session, Rob Harrop will talk about advanced Spring MVC features and techniques and you will learn how to:

Support multiple view technologies in the same application

Manage form processing workflows using Spring form controllers

Add interception logic to your Controllers using HandlerInterceptors

Test your Controllers outside of the container

Support multiple-languages

Handle file uploads

Provide targeted exception handling

Rob will present a detailed discussion of Spring MVC internals and discuss how you can extend the framework with your own request handling workflow components.

By Rob Harrop

Job scheduling is a common requirement of many enterprise applications, so it will come as no surprise to find out that Spring provides comprehensive scheduling support using both JDK Timers and the open source Quartz scheduling engine. In this session, Rob will present an overview of Spring’s scheduling support and how you can utilise it within your enterprise applications.

Rob will also present a detailed discussion of how to use the Quartz scheduling support in an enterprise application setting. Attendees will learn how to:

Configure Quartz and JDK Timers in a Spring application

Control scheduling using cron expressions

Schedule new jobs at runtime

Control job scheduling persistence

Inject objects and configuration into jobs at runtime

Access Spring framework components from within jobs

By Rob Harrop

Aspect-oriented programming (AOP) is a technology that can help you keep your business objects pure and simple. In this session, Rob Harrop and Adrian Colyer will explain the concepts behind AOP and show how you can start benefiting immediately by using the AOP-based services built into Spring.

This session presents an in-depth discussion of the Spring AOP proxy architecture and shows how to get the best performance from you Spring AOP applications. Spring 1.3 integrates even more closely with AspectJ, and this session will also cover when to use Spring-based AOP services, when to use AspectJ aspects, and how you can move seamlessly between the two.

By Juergen Hoeller

A core piece of Spring's middle tier support is the transaction abstraction. Spring is unique in that it clearly separates transaction demarcation (declarative proxies, source-level metadata, programmatic calls) from backend transaction management (JDBC, JTA, etc).

This session will start with Spring's various ways of demarcating transactions. Juergen will then continue to discuss backend transaction management choices, highlighting the strengths of JDBC-based transactions as well as illustrating the power of JTA integration.

As an example for Spring driving a high-end transaction coordinator, this session will finish by showing Spring in action on WebLogic Server 9.0. You’ll see live how Spring transactions are manageable with WebLogic’s transaction monitor and how Spring taps into other special features of the WebLogic platform.

By Juergen Hoeller

Spring not only provides core container features, it also comes with an extensive library that covers a wide range of topics. Many of those little features are less than obvious and thus not as widely used as the core container.

This session will pick a number of those "hidden treasures" from Spring's core library and highlight their benefits. No matter how much exposure you already had to Spring - it's pretty unlikely that you will leave this session without having learned anything new.

By Juergen Hoeller

Spring includes sophisticated support for JMS and JCA for integrating with enterprise backend systems. The newest addition to the family is support for asynchronous message listening based on plain POJOs, introduced in Spring 1.3.

This session will explore various usage styles for both JMS and JCA, illustrating the basic principles of using them in a Spring environment. Both setup in a high-end J2EE server as well as setup with standalone providers/connectors will be illustrated.

By Juergen Hoeller

Spring provides dedicated support for many popular O/R Mapping solutions, out-of-the-box with the core distribution, namely: JDO, Hibernate, Oracle TopLink, Apache OJB, iBATIS SQL Maps, and - as the most recent addition - JSR220 persistence, also known as EJB3 persistence.

This session will explore the entire range of supported O/R Mapping solutions, elaborating their various differentiators in approach and API. We will illustrate how to integrate each of them into a Spring environment.

The main focus will be on key strenghts and discriminators of the respective O/R Mapping approaches rather than on details of a particular tool. Furthermore, we will highlight the consistency of Spring's support across diverse O/R Mapping tools.

By Juergen Hoeller

Birds of a Feather Session focused on Persistence

This BOF will focus on Persistence & Spring. Bring your questions and comments to this session.

By Juergen Hoeller

Spring not only provides core container features, it also comes with an extensive library that covers a wide range of topics. Many of those little features are less than obvious and thus not as widely used as the core container.

This session will pick a number of those "hidden treasures" from Spring's core library and highlight their benefits. No matter how much exposure you already had to Spring - it's pretty unlikely that you will leave this session without having learned anything new.

By Rod Johnson

Rod Johnson will discuss the core concepts of Spring and how they are combined to facilitate writing real-world applications based on POJOs. You will see how:

• IoC and Dependency Injection provide sophisticated wiring for application POJOs • AOP allows declarative services to be applied to POJOs • How and why Spring offers a portable service abstraction in many areas, including transaction management and data access

You will see how these three sides of the Spring triangle work together to provide a comprehensive framework, and look at other concepts consistently seen throughout Spring, such as:

• Templates and callbacks • The Spring approach to exception handling

You’ll see how to help Spring help you once you understand these fundamental concepts.

Even if you’re an experienced Spring user, you will benefit from Rod’s views on some of the key design decisions central to Spring. If you’re new to Spring, this will be a great way to understand what it’s all about and why it works the way it does.

By Rod Johnson

In this session, Thomas and Rod will illustrate JdbcTemplate and other key parts of Spring’s JDBC abstraction library. The focus will be on how these features can be used to greatly simplify working with the JDBC API, even when you need to perform advanced operations.

This session will feature live coding using the org.springframework.test integration testing framework and an Oracle database. Thomas and Rod will cover:

• Deciding what to do in the database, and what in Java

• Deciding when to use O/R mapping, and when to use a relational approach

• Issuing dynamic SQL

• Working with database-specific exceptions, such as exceptions thrown from PL/SQL triggers and stored procedures

• Portable BLOB handling

• Batching to meet extreme performance requirements

Note: Although the examples will use Oracle, the concepts discussed in this session are relevant to all advanced JDBC usage.

By Rod Johnson

Join Rob, Rob and Adrian for a Spring Experience session on the Middle Tier.

This Spring Experience Session will be a focused Birds of a Feather.

By Rod Johnson

Everyone knows that Dependency Injection facilitates unit testing. However, Spring is far more than a simple Dependency Injection container, and it provides a holistic solution for making your code easier to test. The emphasis is on testing outside an application server or container, thus greatly improving productivity.

In this session, Rod will discuss:

• How to unit test Spring applications

• Mock objects and when to use them

• Issues around testing the persistence layer

• Integration testing and the support that Spring provides for it

• Testing web applications

The presentation will include a demo showing how an application can be tested as it is developed, without developers needing to wait for container startup and deployment.

By Rod Johnson

Developers often miss the fact that Spring is highly extensible, without the need to change any code in Spring itself. This means that Spring makes an excellent base for custom frameworks implementing project or organization-specific functionality.

In this session, Rod will discuss:

• How to use BeanPostProcessors to customize the behaviour of the Spring IoC container

• How to register custom property editors to teach the IoC container about your own types

• How to use Spring AOP to customize the behaviour of your POJOs

• How to use auto proxy creators to cause custom aspects to be applied automatically throughout your codebase

• How to use the extensible configuration mechanism introduced in Spring 1.3

Examples will include custom annotation processing and application-specific lifecycle callbacks,

By Rod Johnson

Everyone knows that Dependency Injection facilitates unit testing. However, Spring is far more than a simple Dependency Injection container, and it provides a holistic solution for making your code easier to test. The emphasis is on testing outside an application server or container, thus greatly improving productivity.

In this session, Rod will discuss:

• How to unit test Spring applications

• Mock objects and when to use them

• Issues around testing the persistence layer

• Integration testing and the support that Spring provides for it

• Testing web applications

The presentation will include a demo showing how an application can be tested as it is developed, without developers needing to wait for container startup and deployment.

By Jeremy Kraybill

Two members of eBay's CARad.com team walk through their experiences in gradually evolving a well-established, high-volume eBay application built on Macromedia ColdFusion 5, Visual Basic and SQL stored procedures to a Spring/Hibernate/Tapestry/Axis architecture, while maintaining very high uptime, increasing site stability and introducing new functionality and products.

Topics covered will include real-world experiences in implementing

Spring DAO support, Spring context inheritance, evolving build and automated testing procedures, application uptime monitoring, and creating a re-usable, scalable domain layer.

By Jim Moore

This case study from Symantec Software will explore Titan, a technical support case tracking tool. Since this project's start in 1997, it has gone through four major revisions. In this last one, the Titan middle tier first made use of the Spring framework in March 2004, just before the version 1.0 release. Since then, the usage of Spring has increased dramatically, being heavily used in all aspects of Titan, and has rapidly been adopted by other project groups as well.

The focus of this case study will include the reasons why we decided to use Spring, which features of Spring we're using, and our experiences using Spring. Among the many benefits we have gained as a result of using Spring are

• Loose coupling between tiers - including physical tiers and tiers within the applications themselves

• Abstraction of remoting technology - we support HTTP remoting, EJB,SOAP, and JMS

• Testability - over 75% test code coverage in the server tier

• Container independence - the server runs on JBoss and Tomcat with little modification

• A Rich Client framework - making it much easier to add functionality and keep things consistent across a large & complex applica

By Matthew Porter

From it's early pre-release, WebWork 2 has included Inversion of Control. This implementation, based upon interfaces, served the WebWork community well due to its simplicity; however, it lacked a number of features. Beginning in version 2.2, the WW IoC container has been deprecated and replaced with the more powerful Spring IoC.

This session will detail how to use the WW 2.2 built-in integration with Spring, as well as when not to use it in favor of other integration methods. In addition, it will cover the migration from the WW IoC to Spring, including how to deal with the lack of Session scoped component.

By Matt Raible

Learn how to expose Spring beans as web services - and how to talk to them using Laszlo.

The Spring Framework's Remoting module makes it easy to expose web services from your middle-tier objects. Laszlo is a Flash-based open-source project that allows you to develop rich internet applications. This session will show you how to publish your Spring beans as web services, and how to consume them using Laszlo. This session also compares Laszlo to Ajax and describes the pros and cons of these next-generation web application frameworks.

By Matt Raible

One of the hardest parts about J2EE development is getting started. There is an immense amount of open source tools for web app development. Making a decision on which technologies to use can be tough - actually beginning to use them can be even more difficult.

Once you've decided to use Struts and Hibernate, how do you go about implementing them? If you look on the Hibernate site or the Struts site, you'll probably have a hard time finding any information on integrating the two. What if you want to throw Spring into the mix?

For developers, one of the best ways to learn is by viewing sample apps and tutorials that explain how to extend those applications. In order to learn (and remember) how to integrate open source technologies such as Hibernate, Spring, Struts, and Ant/XDoclet, Raible created AppFuse.

The beauty of AppFuse is you can actually get started with Hibernate, Spring, and Struts without even knowing much about them. Using test-driv

By Colin Sampaleanu

This session provides examples of best-practice usage of JSF as part of a Spring-based application. You'll learn how to tap into Spring-managed services from a JSF presentation layer. You'll see how to use Spring Web Flow seamlessly as a powerful JSF Navigation Handler.

The Java Server Faces (JSF) standard simplifies development of a web application user interface by defining a web UI component model which is tied to a well defined request processing lifecycle. Compared to existing, less capable but "de-facto" standards such as Struts, JSF is still experiencing change and evolving as a JCP specification. This session provides examples of best-practice usage of JSF as part of a Spring-based application and shows how Spring leverages JSF's various extension points to address current gaps in the specification.

By Colin Sampaleanu

This Spring Experience Session will center around the web tier.

This Birds of a Feather (BOF) session will focus on best-practice usage of Spring as it applies to the web tier. Nothing in this general area will be considered off-limits. Bring your questions and comments to this session, and take advantage of 3 Spring web UI experts who will be available and ready to talk about any topic in this general area.

By Colin Sampaleanu

Enterprise JavaBeans is the original server-side component model for Java. While the writing is on the wall for the heavy, invasive EJB 2.1 standard, EJB 3.0, providing a programming model that is on the surface similar to Spring plus an O/R mapping library, is coming.

After an overview of the state of EJB, past, present, and future, including some of the problems which led to the creation of Spring itself, the first part of this session focuses on EJB 3.0. Both EJB 3.0 and Spring provide an Inversion of Control container (including dependency injection), and declarative transactional wrapping of application code. Attendees will learn how each framework tackles the same basic concerns, as well as the advantages and disadvantages of each approach.

EJB 3.0 also includes an O/R mapping API, officially known as the Java Persistence API. This persistence framework is usable both inside and outside of an EJB container. This section of the presentation will also

By Bram Smeets

Buzzwords like AJAX (Asynchronous JavaScript And XML) and HttpXmlRequest are buzzing around Java blogs for months now. The DWR (Direct Web Remoting) project aims to provide easy AJAX for Java.

This session will provide an introduction on using DWR as part of a web application. It will provide insight into the ease of using DWR to add dynamic behavior to your web application, without the hassle of knowing the ins-and-outs of HttpXmlRequest.

The focus of this session will be on DWR in conjunction with Spring. A hands-on example will be used of adding dynamic behavior to a sample Spring MVC application. Furthermore, best practices and dos and don’ts are discussed.

By Thomas Van de Velde

As part of a strategy to put Open Source at the heart of mission-critical, high volume applications, the French Tax Authority has successfully taken a big step to modernize France’s tax services. Working with the French Tax Authority, Accenture has helped provide the more than 34 million tax payers a set of second generation applications that offer access to web-based tax declarations and fiscal account consultation.

This case study will highlight how Accenture moved the previous EJB-based architecture towards a light-weight architecture based upon Spring and Hibernate. We will look at several of the key motivations for using Spring and how it has helped increase developer productivity with J2EE.

By Chris Wall

BEA WebLogic Server 9.0 is the leading implementation of Sun Microsystems' J2EE 1.4 and provides superior enterprise support - enhanced management, ease-of-use, high availability, scalability, reliability, and performance. WebLogic Server is not tied to any particular programming model; thus, it is a natural fit with the new breed of non-J2EE programming models, including the Spring Framework.

This session will demonstrate how Spring-based applications may take advantage of WebLogic Server's core competencies as well as the finer points of Spring and WebLogic Server integration. Topics to be discussed are best practices for utilizing Spring on WebLogic Server, clustering Spring applications, administration console support for Spring applications, Web Service enablement, distributed transactions, and Java Management Extensions support. The session will also demonstrate integrating Spring with persistence implementations such Kodo and Hibernate via the Medical Records sample application. The session will discuss future collaboration between BEA and Interface21 to deliver tighter