By Venkat Subramaniam

Dynamic languages provide some great capabilities for adding dynamic behavior to your Spring applications. In this presentation we will take a look at the various options for mixing dynamic languages with Spring.

You will take away tips on how to enhance your Spring applications using languages like Groovy and JRuby.

By Craig Walls

Perhaps you've tinkered with Spring MVC before. Maybe you've even built an application or two with it. But its complex hierarchy of controller classes and the hefty amount of XML required to configure it has made it easy for you to be tempted by the siren song of other frameworks.

Well, if you haven't had a look at Spring MVC lately, then it's time you take another look.

Starting with Spring 2.5, advances in annotation-driven configuration have made the next generation of Spring MVC a completely different framework, much more lightweight and significantly easier to work with.

If you think that you've lost interest in Spring MVC (or even if you're a die-hard Spring MVC fanatic), this session will no doubt give you a new perspective on how to build web applications using Spring.

By Craig Walls

Spring Security (formerly known as Acegi Security) is a very powerful and flexible security framework for Java. Based on the Spring Framework, Spring Security provides declarative method and web level security including a wealth of options for meeting your application's specific security needs.

Despite Spring Security's great power and flexibility, it has historically been overly complex and difficult to configure. But all that has changed with the release of Spring Security 2. This new incarnation of Spring Security adds simplicity to power.

In this session, we'll explore the Spring Security framework and see how easy it is to use the new configuration elements and annotations to enable security in Java based applications.

By Craig Walls

One of the most prevalent myths about Spring is that Spring requires heavy use of XML. While it is true that XML is the conventional option for configuring a Spring application context, it is not the only option. Non-XML alternatives exist, including scripting configuration with JRuby or Groovy and annotation-based configuration with Spring JavaConfig.

What's especially interesting about these non-XML alternatives is that aside from freeing developers from the "tyranny" of angle-brackets, they also open up opportunities for dynamically configured Spring contexts that take advantage of language constructs not available in XML, such as looping and conditional execution. Moreover, concerns about XML's static identifiers and lack of refactorability are non-issues when configuring Spring in a richer language such as Java.

In this session, we'll explore ways of configuring Spring without involving XML. We'll start with an examination of JRuby and Groovy configuration mechanisms and then dig into Spring JavaConfig and see how to wire an entire S

By Craig Walls

Spring has been one of the most exciting frameworks to emerge in the past few years. With Spring you can decouple your application's objects, enrich them with AOP, and apply transactional boundaries and security to them declaratively. It simplifies data access, remoting, web services, and JMS. It comes with its own web framework. And, even though Spring eliminates much of the need for EJBs, it will still integrate nicely with any EJBs you may have lying around. What's not to love?

Everyone's favorite Java framework continues to improve, with significant enhancements in Spring 2.5 and many more slated for Spring 3.0. Maybe you've already seen or read about

Spring and perhaps you've even developed applications using Spring. But have you seen the latest that Spring has to offer.

In this example-driven presentation, I'll lead a guided tour through the key features of Spring, with an emphasis on the Spring's core facilities of Dependency Injection and Aspect-Oriented Programming. Whether you're a Spring newbie or a seasoned Spring developer, there'll be something new for nearly everyone.

By Craig Walls

A common complaint about Spring is the vast amount of XML required to configure an application. In this presentation, I'll show you ways to reduce or even eliminate much of the XML required to configure Spring.

A typical Spring configuration file will contain dozens, hundreds, or possibly thousands of lines of XML. Because of all of the XML clutter, some have started looking for alternatives to Spring that don't require so much configuration, even if it means forfeiting all of the other benefits afforded by Spring.

But before you throw the baby out with the bathwater, you should know that there are several ways to simplify Spring configuration so that it isn't so XML-heavy.

In this presentation, I'll show you ways to cut back on Spring configuration while still achieving the same results. I'll discuss a few XML reducing ideas, such as custom configuration namespaces, and I'll also show you some X

By Craig Walls and Costin Leau

Spring Modules is a java.net project that provides a home for extensions to the Spring Framework, almost like a Spring plugin repository. This session will provide an overview of the extensions, highlight the coolest ones and show you how you can get started with them in your applications.

Some of the extensions covered include:

- Caching

- db4o

- Workflows modules

- JCR

- Validation

- XT

By Craig Walls

As a matter of good design and best practice, we all know we should divide our application code into logical layers or modules that can be developed independent of each other. But if modularization is a good practice to follow as we write our code, why do we package it all up into a monolithic WAR file for deployment?

Breaking an application down into several well-defined modules affords developers many advantages, including:

* Easier parallel development

* Improved testability

* Substitutability of functionality

* Isolation of updates

Both a de facto standard and a proper standard, OSGi offers lightweight modularity to Java. Spring Dynamic Modules for OSGi (Spring-DM) brings the power of Spring to OSGi, making it possible to create, deploy, and wire OSGi components together without mucking about in the OSGi API. Together, Spring-DM and OSGi enable assembly of applications from fine-grained modules (known as bundles) that can be developed, deployed, and updated independent of each other. This combinati

By Ben Alex

This session introduces Spring Security to those not already using it, or those seeking to gain a wider appreciation of what it can do for a typical enterprise application. Attendees will learn how to configure and deploy a basic Spring Security system, as well as gain knowledge on how to extend the system to meet their unique security requirements.

Most enterprise applications are multiuser systems dealing with business-critical corporate data. Such applications generally require a security approach that at least addresses user identification and their permissions.

Spring Security (formerly known as Acegi Security) is the Spring Portfolio's security module, and is widely used in security-critical environments such as banking, finance, defence and government departments. Spring Security delivers value by freeing application developers from the time-consuming and complex work of securing their applications, with out-of-the-box capabilities including authentication, authorization, domain object access control, human user detection, chann

By Ben Alex

Come to this session for a lively discussion on implementing secure systems with Ben Alex and Erwin Vervaet.

By Ben Alex

This session will cover the exciting new capabilities of Spring Security 2 M1. We'll cover what each new feature does and how you would configure it. We'll highlight how to upgrade your existing Acegi Security 1.0.x configurations to the new and significantly simplified Spring Security 2 configuration format.

Spring Security has provided comprehensive security infrastructure for Spring-based applications since 2003. Formerly known as Acegi Security, Spring Security 2 Milestone 1 offers considerably simplified configuration, together with a wide range of other new features including Windows NTLM authentication, a user management API, persistence-backed remember-me services, hierarchical roles, Spring LdapTemplate support, considerable ACL enhancements, portlet support, and much more.

This session will cover the new capabilities specific to Spring Security 2 M1, and what we're working towards for the 2.0 final releases (M2 and RC). We'll cover what each new feature does, and how you would configur

By Michael Alford

In this session, Michael Alford and Mark Meeker will describe the major business goals that drove the development of Orbitz Worldwide's next generation online travel commerce platform, and how those goals were met with Spring and other technologies.

Last summer, Orbitz Worldwide (NYSE: OWW) - the leading online travel commerce company - released a new generation of its global technology platform with the goals of internationalization, white-label capability, and faster, streamlined development. Michael and Mark will describe the key challenges of this technology project and how those challenges were addressed, including the good, bad, and ugly of the Spring Framework and Spring Web Flow.

By Alef Arendsen

Aspect-oriented programming has been around for quite some time now. Today, AOP is used in a wide range of applications to solve a wide variety of problems. However, some of those solutions are not very well-known to the general Java development community. In this session, Alef will explore several aspects he has seen used in real-world projects.

Alef will explore innovative aspects that solve problems ranging from complex data-access scenarios, to security-related situations, to issues where concurrency plays an important role. You will be able to take away the solutions for the problems highlighted during this session immediately and use them in your own projects.

By Alef Arendsen

CRUD (create/read/update/delete) actions on domain entities are a significant part of what database-backed web applications are about. Frameworks like Ruby on Rails apply useful conventions that simplify implementing CRUD functionality. These same conventions can be applied in a Spring Web environment to deliver great productivity gains. Come to this session to see how to efficiently implement CRUD actions end-to-end in your Spring Web application.

Topics covered include:

- The HTTP contract for CRUD, including important URL and method conventions

- How to implement CRUD actions that are automatically detected and exposed at the proper URL endpoint

- How to apply declarative validation constraints to your CRUD forms

- Strategies for generating CRUD forms from domain model metadata

- Tools to support CRUD-style web application development

This session will cover implementation using Spring Framework 2.5 and Spring Web Flow 2.0.

By Alef Arendsen and Ramnivas Laddad

Aspect-oriented programming (AOP) is a proven paradigm for enforcing broad organizational policies. In this session, Ramivas and Alef will explore the definition and enforcement of software architecture policies to help keep a code base clean. They will present several reusable examples you can apply within your own organization to catch architectural violations. They will also demo the best features of the leading off-the-shelf architectural enforcement tools.

Architectural policies originate from a variety of sources: consensus among developer community about generally accepted programming idioms and best practices, your own ideas on what a good architecture looks like, requirements of the underlying framework, core architecture of the specific project, and specific design choices made by the team on a project. In short, policies represent accumulated knowledge to create better quality software. If there is no enforcement, the errors may go undetected during development and show up only in the deployed system. Often if one error is allowed to go undetected, the associate code often ends up mistaken as design pattern.

In this session, we look at

By Mattias Arthursson

Spring LDAP is a Java framework for simplifying LDAP operations. In this session, the creators of Spring LDAP will use code examples to introduce the basic features of the framework, and demonstrate how even the smallest LDAP project will benefit from using Spring LDAP.

Spring LDAP is based on the template pattern and is conceptually similar to Spring's JdbcTemplate. The LdapTemplate class encapsulates the plumbing work involved in traditional LDAP programming, and lets the programmer focus on what matters: where to find data and what to do with it. Spring LDAP also provides several utility classes that simplify common tasks. Come to this session to see the LDAPTemplate in action and explore its options for working with LDAP directories.

By Mattias Arthursson

This session will present common real-world LDAP integration problems and how these problems can solved using Spring LDAP. The advanced features of Spring LDAP will be covered in depth. Attendees will learn how Spring LDAP can be used to solve problems that were previously considered virtually unsolvable in the LDAP world.

Many enterprise systems have a need for integration with a directory data source, such as an LDAP or MS Active Directory Server. Common tasks include administration of authentication data, user, group and role management, authentication, and synchronization of data between the directory and a relational database. Many of these tasks are tricky, particularly since working with directory data sources is quite different from relational data sources and many developers lack experience with LDAP.

By Shay Banon

Compass is an open source Java Search Engine framework, allowing the integration of search functionality into any application. One of Compass main modules is a Spring integration module, heavily used among Compass user base.

In this session, we will first review the main features of Compass, focusing on Compass extensive integration with Spring. We will then see how Compass can be used to add google like search capability to Spring's petclinic sample with almost no coding involved using Jpa and Annotations.

By Antranig Basman and Aaron Zeckoski

Come to this session to learn about Reasonable Java Server Faces (RSF), a unique Java-based UI component framework that emphasies plain old semantic HTML and supports a Web Designer / Developer separation of roles.

RSF (Reasonable Server Faces) is an open source web programming framework that was written from the ground up with Spring in mind. All parts of the application are designed using standard Spring bean definitions, whilst the front end is driven by a completely pure XHTML templating layer that allows full control by designers down to the last tag.

In this session you will learn how to use RSF in conjunction with standard Spring Web technologies such as Spring MVC, Spring Validation and Spring Web Flow (including integration with the latest 2.0 milestones). The session will cover the use of both "semantic" (data-driven) AJAX as well as more markup-driven (AHAH) strategies, in plain RSF as wel

By Adrian Colyer and Rob Harrop

By Adrian Colyer

In this session, the latest advances in the Spring OSGi project will be presented, and several concrete applications of the project will be discussed and demoed. We will also discuss how OSGi as a platform influences your development and deployment.

Nowadays, OSGi seems to be everywhere. What exactly is OSGi and how can you use it? What are the benefits and where does Spring fit in? Come to this session to find out.

By Keith Donald

This session will explore the "full stack" web framework trend and answer the question: how does Spring stack up? This session will first define what a full-stack web framework is, then provide a fair technical comparison between a Spring-centric web development stack and the alternatives. Attendees will learn the feature-set of modern "full stack" web frameworks, and what Spring has that differentiates itself from the pack.

Spring is best known for bringing POJO Enterprise Java programming to the mainstream. No matter what web framework you use, chances are you use Spring to integrate your application's business logic using the proven POJO model. In addition, all credible Java web frameworks today, including the ones that classify themselves as full stack frameworks, provide Spring integration.

Since it's inception, Spring has also shipped its own web framework that builds on the core Spring Framework, and released products like Spring Web Flow, Spring Security, and Spring Web Services that solve previously under-served needs of web application developers. When a Spring-managed web tier is combined with a S

By Keith Donald

This session explores the challenges of accessing a shared data repository from a high-volume web application with many users. Attendees will learn how to ensure data integrity and data access performance while maintaining a satisfactory user experience. In addition, attendees will gain an understanding of key web application data access patterns and how to use frameworks like Spring and Hibernate to apply them.

Specific topics covered include:

- How to properly isolate an application transaction, like an edit session occurring in a browser window, that may span several requests into the application server before committing or canceling

- Object persistence guidelines and how to prevent lazy loading exceptions

- When locking is required and how to select a locking strategy

- How to use Spring, Spring Web Flow, and Hibernate to address web application data access challenges

Web patterns covered include:

- Application Transaction

- Conversational Persistence Context

- Editable Data Table

- Master Detail

- Data List Paging

- Open Session in View

- Optimistic Locking

- Pessimistic Locking

By Keith Donald

In this session, you will learn to recognize opportunities for extracting high-level, reusable UI components within your web applications, how to capitalize on them, and how to use the technique of component composition to create highly-interactive web applications.

This session will also highlight important concepts present in all modern component-oriented web frameworks, and leave you with practical examples of component engineering you can hit the ground running with.

Some of the topics covered include:

- How do extract UI panels into reusable modules that can be embedded anywhere in your web app

- How to design for linear wizards embeddable within a page

- How to have embedded components like a wizard or shopping cart view share application state, and free them from HTTP session management concerns

- How to isolate state between multiple browser windows.

- How to demarcate application transaction boundaries within your UI components to prevent dupl

By Keith Donald

Come to this BOF for a lively discussion on web application design with Keith Donald, Graeme Rocher, Jeremy Grelle, and Mark Meeker.

By Christian Dupuis and Mik Kersten

Recently, the benefits of Mylyn have been combined with the open source Spring IDE project to provide a tool for developing Spring applications. Come to this talk to see this development tool in action.

Current Enterprise Java IDEs overload us with tens of thousands of artifacts. As a result, we often spend more time searching, scrolling, and navigating than we do programming. The open source Mylyn project re-aligns the software development experience around the tasks that make up our workday. Since being packaged as part of the default Eclipse downloads, this new approach to programming has been adopted by an increasingly large number of Java developers. More recently, the benefits of Mylyn's Task-Focused Interface have been combined with the open source Spring IDE project. This new combination of technologies is starting to make the development of large Enterprise Java applications funda

By Mike Esler

This session presents a case study detailing HSBC's approach to the adoption of the Spring framework.

In 2005, HSBC made the decision to evergreen its existing home grown Java framework. This case study presents the background related to the decision, the decision making process itself, and finally the actual implementation approach. It includes an overview of which components were adopted, and which were forgone in favor of homegrown alternatives, with an in-depth analysis of the reasoning behind HSBC's decision not to use Spring MVC or Spring Flow in favor of its own Request Processing model in combination with JSF.

By Mark Fisher

In the first-part of this two-part workshop, Mark will focus on the essentials of Enterprise Integration with Spring. First, he will take a whirlwind tour of Spring's enterprise integration support libraries. Next, he will discuss the "big picture" of an event-driven architecture based on messaging with an overview of key enterprise integration patterns. Attendees will leave with a clear understanding of Spring's integration capabilities and an appreciation for the benefits of message-driven architecture, ready to put that into practice in Part II.

Producing high-quality, testable code while remaining agile requires loosely-coupled, highly-cohesive components that are not tied to any particular infrastructure - in other words: separation of concerns. When building web applications, MVC frameworks provide an environment for achieving separation of web-specific concerns (such as HTTP requests) from an application's business logic. However, an enterprise Service Oriented Architecture may require many types of integration beyond the web-tier such that maintaining separation of concerns can become a significant challenge. Spring offers assistance with inversion of control, aspect-oriented programming, and a wide variety of service abstracti

By Mark Fisher

Building on Part I, Part II of this workshop will demo a series of messaging systems built on Spring. The samples will exercise event-driven scenarios involving distributed architectures with messaging and remoting. Each sample will highlight a variety of important enterprise integration patterns.

Some samples will focus on routing to multiple endpoints based on message content. Others will focus on exposing a service for asynchronous as well as synchronous requests across multiple protocols. Still others will demonstrate translation of the message content in order to satisfy the requirements of multiple consumers. All of the samples will emphasize the need to maintain separation of concerns so that business logic is reusable in multiple environments and testable in isolation.

By Mark Fisher and Juergen Hoeller

In this session, we will take a deep-dive into annotation-based dependency injection with Spring 2.5. You will learn how to combine annotation and XML formats, how to customize component scanning, and how to leverage Java 6 annotations within a Spring application. Since there is no "one size fits all" solution to application configuration, we will wrap up the discussion with general guidelines to consider when employing this approach.

Although XML is the most widely used format for Spring configuration, other options do exist including properties files, Spring's Java Configuration, and even Groovy builders. Spring 2.5 adds to this mix with support for Java's @Resource annotation and Spring's @Autowired annotation. Spring 2.5 also supports classpath scanning for Spring components. This session will provide a comprehensive overview of these new Spring 2.5 features for annotation-based configuration.

By Ted Goddard

Ajax applications can generally be developed with traditional techniques, but in order to produce revolutionary applications efficiently, some new ideas must be embraced. This session covers the characteristics of advanced Ajax applications and explainshow to develop and deploy them using Spring Web Flow and ICEfaces.

Advanced Ajax applications are characterized by:

- single-page, multi-window interfaces,

- fine-grained interaction on blur and click events,

- cinematic effects, drag and drop, and

- asynchronous page update (Ajax Push/Comet)

Attendees will learn the details of adding such features to their applications using Ajax Push from ICEfaces, powerful scope and navigation extensions from Spring Web Flow, and asynchronous I/O features from the Tomcat Servlet Container.

By Jeremy Grelle

Today, there are a wealth of technologies to take advantage of to add Ajax behaviors to your web applications. This session will assume you know the basics of Ajax, and will dive straight into evaluating the leading Ajax technologies, where they are going, and how to integrate them with Spring. Attendees will emerge with an understanding of which tools to use when, and how they work in a Spring environment.

Topics covered include:

- Remoting technologies such as DWR and JSON

- Lightweight Javascript libraries such as Prototype, Scriptaculous, and jQuery

- Full solution Javascript frameworks such as Dojo and Ext

- Useful integration helpers for simplifying use of these frameworks

- How to integrate with Spring

By Jeremy Grelle

This session illustrates how JSF and Spring fit together with Spring Faces, and how to use these technologies together to create rich web applications. Attendees will learn how Web Flow and Spring Faces help to make using JSF a more pleasant experience.

Some of the topics covered include:

- How Spring plugs into the JSF Lifecycle for navigation handling and state management

- How Spring integrates with popular JSF libraries such as Facelets and Ajax4JSF

- How Spring enhances JSF's exception handling capabilities

- How Spring usage compares to standard JSF Navigation Handling and to JBoss Seam

- Patterns and practices for getting the most out of Spring in a JSF application

- Roadmap for future integration enhancements

By Jeremy Grelle

Nearly every web application must process user input of some kind. Forms are an especially important element for supporting complex user interactions and data entry processes. In this session you will learn to use leading JavaScript frameworks with Spring and Spring Web Flow to develop rich user input forms with minimal effort.

Topics covered:

- Implementing common form behaviors such as as-you-type validation, hovers, and alert indicators

- Integrating form input controls such as auto-complete combo boxes and date choosers

- Binding form input to server-side resources

- Accounting for accessibility guidelines

- Styling forms consistently using CSS

- Leveraging server-side Spring resources to enhance user feedback.

By Rob Harrop

Large scale batch processing often requires extreme levels of performance in both file I/O and data access. In this session, Rob presents a number of practical strategies for working with massive batch data sets.

Topics covered include:

* Reading and writing flat files

* Working with massive XML data sets

* Mastering JDBC

* Exploiting database features

* Managing transactions

* Designing APIs for performance

* Common problem areas

By Rob Harrop

In this session, Rob presents a practical discussion of the creation of highly concurrent enterprise applications. Attendees will be presented with a wide range of topics for concurrency management.

Topics covered include:

* Java memory model basics

* The best of the JDK concurrency library

* Concurrency in Java 7

* Testing concurrent applications

* Common concurrency patterns

* Exploiting multiplexing

* Concurrency beyond Java

Attendees should be familiar with the basics of Java concurrency.

By Rob Harrop

Come to this BOF for a lively discussion that explores what "Extreme Scalabiity" really means with Rob Harrop, Nati Shalom, Billy Newport, Patrick Peralta, and Wayne Lund.

By Jennifer Hickey

Designing your enterprise application for management can be a daunting task. Developers need runtime visibility into their application once it is deployed, but often times are faced not only with the challenge of how to provide this visibility but also with the challenge of determining how much visibility to provide. In this session, you will learn practical techniques that can be used to address these issues. You will also see how Spring can play a role both in building manageability into your enterprise applications and in managing those applications once they are deployed.

The amount of information that can be exposed about your application can be overwhelming. How do you determine what information would be most valuable to have for troubleshooting issues and identifying performance bottlenecks in production? And how do you determine the best way to aggregate and represent that data? Once you determine what data you want to expose, how do you collect that data in a minimally invasive way? How can you use that data to identify and correct potential issues before they escalate?

In this session, you will learn practical techniques that can be used to address these questions. You will also see how Spring can play a role both in building manageability into your

By Jennifer Hickey

By Hal Hildebrand

The application server market is rapidly moving from monolithic to targeted solutions where end users have more control over how their systems are provisioned and configured. Spring and OSGi are important technologies for creating these targeted solutions. Oracle is building on both Spring and OSGi to lay the foundation for their next generation application server. This session will provide a behind the scenes look at the challenges and results of this work.

Come to this session to see how Oracle is using Spring and OSGi to build out their next generation middleware suite.

By Juergen Hoeller

This session provides a practical tour through what's new in Spring. If you are using Spring 2.0 and seek the most bang for your buck when upgrading to Spring 2.5, this session is for you. If you are not yet using Spring this is the place to be to get a good overview of the latest developments.

This talk will highlight the simplified and extensible configuration support, new Java 6 support, updates to Spring AOP, new bean scoping options, improved JDBC and JPA support, asynchronous JMS, updates to Spring MVC, scripting language support and more!

By Juergen Hoeller

The Spring Framework is well known as a "Java EE" application framework. However, what does this really mean in terms of Java EE platform features and platform integration? This session discusses Spring 2.5's Java EE support in detail, focusing on advanced integration with specific servers, covering J2EE 1.4 as well as Java EE 5 editions of common server products.

This session discusses Spring 2.5's Java EE support in detail, covering Servlet and JSP container, Web Services support, resource and transaction management, messaging, work manager integration, etc. The focus will be on advanced integration with specific servers, covering J2EE 1.4 as well as Java EE 5 editions of common server products such as Tomcat, WebLogic, WebSphere and GlassFish.

By Juergen Hoeller

A key piece of every Java EE server is the XA transaction coordinator, responsible for handling all transactional needs in a server environment. However, many applications do not need distributed XA transactions in the first place; native database transactions are often a more efficient and more powerful option. This talk illustrates Spring's support for native database and messaging transactions in various scenarios, including the use of multiple native resources within the same transaction.

Topics:

* Spring's transaction abstraction (brief)

* XA transaction options (JTA in Java EE and standalone)

* Native transaction options (JDBC, JMS, etc)

* O/R Mapping integration (JPA with and without JTA)

* Database access and messaging within the same transaction (with and

without XA)

* Transactional message listener containers (with and without XA)

By Juergen Hoeller

Come to this BOF for a lively discussion of patterns for Enterprise Application Integration (EAI) with Mark Fisher, Juergen Hoeller, and Mark Pollack.

By Rod Johnson

By Rod Johnson

Spring, as the leading Java application framework, brought dependency injection and POJO programming to the mainstream. In this session Rod will look at new advances in the field of dependency injection, and explore how Spring's recent work compares to others in this field.

Today, you are most likely using Spring for Dependency Injection. In the early days, you might also have heard of Avalon, Pico, and Hivemind, three other DI containers. You may remember Type I, Type II, and Type III dependency injection. Now, several other DI containers and alternative component models are cropping up. What do these containers offer that is really useful? What's not so useful? How do they compare to Spring, and what is Spring doing in this field today? This session will explore the state of the art in dependency injection.

By Mik Kersten

Mylyn's task-focused UI is changing the way that developers work. Current IDEs overload us with the tens of thousands of artifacts that make up an enterprise application, and as a result we spend more time searching, scrolling, and navigating than we do programming. Eclipse Mylyn is the solution to this problem. The talk will start with live demos to show you what Mylin can do and will conclude with a showcase of popular development tools that integrate with this cutting-edge technology.

Mylyn focuses the Eclipse IDE to show only the information relevant to the task-at-hand. This makes working with large systems much easier and multitasking almost effortless. In addition, Mylyn's integrated task management facilities displace the cumbersome browser and email based mechanism of task/bug/issue tracking.

This talk will start with an overview of Mylyn's task management features including offline editing, background synchronizations and change notifications, and demonstrate how these work for repositories such as Bugzilla, JIRA, and Trac. Demonstrations of the tool will show you how to get the most out of Mylyn's task context management when working with Java applications. Mylyn

By Mark Kralj-Taylor

This session will explore how and why Spring is being used at a large financial institution. How is Java used at the firm? Why is Spring a good fit?

Mark will show how Spring is helping to execute on a strategy of providing the firm's Java developers with a best-of-breed blend of open-source and in-house libraries. We will look at examples of how Spring is used in a variety of applications. Mark will talk about how engaging with Spring committers is helping address the firm's particular needs around robust, high-throughput transaction processing over multiple resources without an XA transaction manager.

By Ramnivas Laddad

This talk introduces AspectJ to developers experienced with Spring and explains core AspectJ constructs. Attendees will learn the essentials of AspectJ and how to use it to create even simpler Spring-based applications.

Combine Spring with AspectJ and you wield enormous power to simplify your enterprise applications. This talk will introduce AspectJ to developers experienced with Spring and explain core AspectJ constructs. The talk will also show several examples that you can readily use in your enterprise applications.

By Ramnivas Laddad

By Ramnivas Laddad

Come to this BOF for a lively discussion of AOP in the Enterprise with Ramnivas Laddad, Adrian Colyer, and Jennifer Hickey.

By Ramnivas Laddad

This session explores using custom annotations to add cross-cutting behavior to your applications. We will examine several concrete use cases for defining your own custom annotations, then show how to consume those annotations at runtime to apply new functionality.

Specifying metadata using annotations has gained huge popularity since its introduction in Java 5. However, the story on consuming annotations is not as clear. Reading and processing annotation is still a complex process often requiring you to understand byte-code manipulation tools and their low-level API. As a result, most developers shy away from using custom annotations, limiting their usages of annotations only those prescribed by frameworks. The result is missed opportunities for programming simplification.

In this session, we explore how AOP can make it a simple task to consume annotation in a powerful manner. We also examines best practices in designing custom annotations. The exa

By John Lewis

The Java Portlet 2.0 specification (JSR 286) introduces major new features for Portlet development. This session will detail the changes present in this new specification and will explore planned enhancements to Spring Portlet MVC to allow developers to take full advantage of them.

Enhancements covered include: a new eventing phase that allows portlets to communicate with each other, the ability to serve up resources directly out of the portlet, and full filtering support of portlet requests, along with a number of other minor changes and improvements. This session will explore the changes and enhancements that are being made to Spring Portlet MVC to empower developers to take full advantage of these new capabilities.

By John Lewis

This session will survey the landscape for developing JSR 168 Portlets with Spring. Attendees will learn the options available for Portlet development today, with a strong focus on Spring MVC.

We'll begin by discussing the unique differences and challenges when developing Portlets instead of traditional Servlet webapps. Then we will review a number of web development frameworks with support for the JSR 168 Portlet 1.0 specification. We'll focus primarily on Spring MVC, but we will also talk about Spring Web Flow, Apache Portals Bridges, and several others.

By John Lewis

In this session, attendees will learn how to secure JSR-168 Portlets using the latest version of Acegi Security, called Spring Security 2.0

The 2.0 release of Spring Security includes new support for JSR-168 Portlet development. In this session we'll cover how the Acegi security model translates into the Portlet world, show how to configure the authentication provider for JSR-168 Portlets, and discuss the special interceptors for processing Portlet requests and for storing the security context in the Portlet session. Finally we'll show how Portlets and Servlets in the same webapp can share security context, which allows for secure AJAX calls and dynamic images from within Portlets.

By Wayne Lund

This advanced presentation will focus on best practices around creating high performance batch architectures with the Spring Batch container.

Effective batch architecture is an integration challenge. High performance involves not only having a highly performance batch container but also involves understanding the environmental tuning choices in the integration with databases, queues, and the operation platform.

Topics covered in this session include:

Performance Guidelines - understanding the role of the infrastructure components like databases and queues in the performance of batch, building a batch schedule capacity model, leveraging the DBA & Queue administrators as SMEs, etc.

Performance Monitoring - understanding the role of monitoring and runtime statistic for revealing weak spots in the batch architecture.

Performan

By Jim Moore

In this session you'll gain a holistic view of testing web applications and how Spring and other open tools support the testing process. Attendees will learn what they should testing on both the client and server and the best tools available for the job.

Topics covered include:

- Unit testing domain and application logic

- Unit testing controllers

- Unit testing Javascript

- Acceptance testing in the web browser

By Jim Moore

While Ajax is bringing web browsers closer to the rich user experience of traditional applications, the desktop has not been standing still. This will show some of the ways that the desktop is continuing to move the user experience forward and how Spring makes working with services equally accessible for whatever view technology is best.

Topics covered include:

- Desktop application framework update

- Innovative libraries and utilities

- Integrating Spring Remoting and Web Services

- Testing Desktop Applications

By Billy Newport

This session illustrates how to build redundant grids using ObjectGrid that make sure processing can continue when serious infrastructure failures occur.

The session will show examples of how to set up topologies for datagrid and HTTP Session replication that can continue processing even after serious infrastructure failures have occurred and how they revert to pre failure conditions once the faults have been corrected.

By Billy Newport

This session first provides an introduction to ObjectGrid, then examines how to build J2SE-based Extreme Transactional Processing (XTP) applications with ObjectGrid and Spring. Attendees will see ObjectGrid and Spring applied in the context of a realistic financial markets scenario.

This session explores a sample XTP application for order matching for an investment bank. An order matching application accepts orders and attempts to match compatible buy and sell orders against each other. The best bid/offer for a given tradeable instrument is then advertised to the market.

The sample application will demonstrate to attendees how to design and host XTP applications within an ObjectGrid environment. The application makes use of Spring to wire itself together as well as provide services to the application. It was originally designed for WebSphere XD 5.1, and was used as a proof of concept for an international exchange. It has since been ported to use ObjectGrid and now runs

By Patrick Peralta

In this session we will examine the architecture of a typical Spring application and some of the scalability challenges that may arise, in particular the issue of state and data management.

We will discuss various types of state and strategies for handling state via a Coherence Data Grid that will allow Spring applications to linearly scale.

Additionally we will explore topics such as caching patterns, the Data Grid paradigm (and how it is different from 'normal' caching) and ways in which a Coherence Data Grid can leverage infrastructure provided by Spring.

By Mark Pollack

This session will give an update on recent developments in Spring.NET covering messaging, interop, WinForms, .NET 3.0, and AJAX integration. An overview of features not found in Spring Java, such as the Spring Expression language and its integration into the container, will also be presented.

Come to this session to see what Spring on the .NET platform has to offer.

By Arjen Poutsma

2007 was the year of Spring Web Services 1.0. In this session, attendees will learn what this solid product has to offer from its creator. Come to this session to see how how to apply the latest Spring WS release to develop and consume interoperable, document-driven web services.

Spring Web Services is a comprehensive web services stack for developing and consuming SOAP Web services. We will start this session by giving an introduction into Spring-WS, and show how a typical Web service is built. Next, we will show how the client-side WebServiceTemplate can be used to consume this Web service.

We will also discuss some of the new features in the upcoming version of Spring Web Services: version 1.5. We will show how to use the JMS and email transports, how to use the new XML namespaces to easy the configuration, and more.

By Arjen Poutsma

REST, the REpresentational State Transfer, is the architectural style underlying the HTTP protocol. In the last couple of years, REST has emerged as a compelling and simpler alternative to SOAP/WSDL-based distributed architectures. In this session, Arjen will explain what REST is, how it can be used to build Web Services, and where it makes sense to use.

We will start by giving an overview of REST: where did it come from, how does it work, and how can it be used to build a distributed architecture? Using illustrative examples, we will try to find an answer to these questions.

Next, we look at some of the current frameworks and tools which can be used to build web services. We will look at Spring-MVC and JSR-311 (also known as JAX-RS) on the server-side, and also investigate client-side options, such as the plain HttpURLConnection, and the more mature Commons HttpClient.

In this session, you will learn how build RESTful Web services, and how Spring can help you with this.

By Arjen Poutsma

One of the most interesting features of languages such as Smalltalk, ObjectiveC, and Ruby is duck typing. This session will show you how you can apply duck typing to Web Services to make them more flexible and less strict.

The basic idea behind duck typing is that if an object walks like a duck and talks like a duck, then the language is happy to treat it as if it a duck. In other words: the object's type is determined by what it can do not by its class.

Web services exchange information, often in a common, interlingual format such as XML. What happens when we apply the principles behind duck typing to Web services?

This talk presents WS-DuckTyping: not a new W3C standard; but rather a way to deal with XML as if it were a duck. We will give a number of practical tips to implement this Anatidaeic development style, including working with XPath to extract information from incoming Web service request, whether

By Chris Richardson

In this presentation, you will learn how to improve your applications by implementing business logic using a rich domain model. Chris will refactor a procedural design into an object-oriented design and illustrate the benefits of using the object-oriented approach. You will learn how to identify procedural code smells and eliminate them by refactoring your code - something you can start doing the Monday morning after the conference.

Java is an object-oriented language and object-oriented design is considered by many to be a good way to tackle complexity. However, surprisingly many complex enterprise Java applications are written in a procedural style. The business tier consists of fat services and anemic domain models and consequently can be difficult to understand, maintain and test.

In this presentation, you will learn about how to improve your applications by implementing business logic using rich POJO domain model. We will compare and contrast a procedural design with an object-oriented design and describe the benefits of using an object-oriented approach.You will learn how to identify procedural code smells and e

By Chris Richardson

A domain model encapsulates data and behavior together into expressive domain objects. Testing is not only important for verifying domain behavior, but also measuring the suitability of the design. In this session, Chris will show you testing techniques that build confidence in your code and help you improve your design.

A rich domain model is an excellent way to organize complex business logic. It can make the code easier to understand and maintain. Using a domain model can even make testing easier. Sadly, many developers do little or no automated testing and so do not fully benefit from using a domain model. The quality of their code gradually declines, development becomes increasingly more difficult and they often have to throw the code away and start over. In this presentation you will learn some simple yet effective ways to test a domain model. We describe how to overcome some of the common obstacles to writing tests. You will learn testing techniques that you can easily apply to your existing domain

By Thomas Risberg

Working with databases always results in issues that can be helped by using available tools. In this session, Thomas will look at some useful tools and see how they can be configured to run within a Spring environment.

Topics covered include:

Connecting and interacting with your database

- Squirrel

- IDEA/Eclipse plugins

Testing your database app

- DBUnit

- Spring's Transactional Test Support

Monitoring DB activity

- Elvyx

- p6spy

Generating ORM metadata and DDL

- Hibernate Tools

- Oracle TopLink Essentials

Generating Java classes from database tables

- Hibernate Tools

By Graeme Rocher

In this talk the Grails project lead, Graeme Rocher, introduces a new way to develop web applications with the Spring framework. The Grails web application framework, based on the Groovy language with powerful Spring underpinnings, is lowering the barrier of entry to Java EE development with Spring.

Through clever use of DSLs and convention-over-configuration Grails dramatically reduces the complexity of web development while still allowing the flexibility of the underlying frameworks such as Spring MVC, Web Flow and Hibernate. This session will guide you through the basics of Grails, and preview its power features such as GORM, GSP and Web Flow.

By Graeme Rocher

Domain specific languages (DSL) are becoming increasingly prominent with the rise of dynamic languages like Groovy and Ruby. In this talk Graeme Rocher, Grails Project Lead, introduces two interesting use cases from the Grails framework: A Spring Configuration DSL and a Spring Web Flow DSL using Groovy.

In the first demonstration the session will show how using Groovy to script your application context can enable dynamic, runtime configuration that allows you application to adapt to its environment and the presence of different libraries.

Finally, Graeme will present a Spring Web Flow DSL that allows simplified construction of flow definitions that go beyond the constraints of the default XML syntax

By John Rymer

By Nati Shalom

Designers of distributed systems are forced to deal with many complex issues such as high availability, scalability, performance and latency. We often address these issues with brute force development work, thereby creating a cumbersome and slow development process. Despite the challenge, the need to apply agile development and testing practices in such environments is obvious and we see numerous solutions and methodologies aimed to fulfill it. One of the more successful ones is the Spring Framework that its layered architecture enables modularity and agility of development.

In this session Nati Shalom, GigaSpaces CTO, will share his experience of applying agile methodologies in the development of a high-end, low latency, distributed infrastructure, by leveraging platforms such as the Spring Framework. Shalom will share his experience of how the creation of a Testing Grid framework improved the time it takes to provision and test complex cluster environments, as well as run multiple clustering topologies simultaneously to reduce the time it takes to do full regression in an automated way. Shalom will demonstrate the applicability of these methodologies throughout the entire value chain; from product development through successful project deployment, and all the

By Nati Shalom

In this session, Nati will present three simple steps to scale out your Spring applications. He will demonstrate how you can take an existing application employing a traditional tier-based architecture and evolve it to a service-based architecture that delivers higher levels of scalability while keeping your core programming model intact.

Across industries, from financial services to the Internet, transaction and data volumes are growing exponentially and need to be processed in real time. While the Spring Framework offers developers a simpler and more flexible way to build their applications, the scalability and performance of such systems is still limited by the underlying architecture, regardless of the programming model.

How do you move your existing stateful, tier-based application to linearly scalable services?

In this session, we will present a three-step solution to this challenge. We will show how you can keep your existing programming model intact, while focusing on abstracting and replacing the underlying implem

By Rossen Stoyanchev

How do you know your web application will perform under load when its deployed into production? Concrete benchmarks that measure where time is spent and how memory and other resources are utilized can go a long way to identifying bottlenecks. In this session attendees will learn use tools to measure web application performance to pave the way for performance optimization.

Topics covered include:

- Benchmarking relative time-spent from your view-layer down to the data-access layer

- Measuring performance and memory utilization of your Spring Web Flows

- Collecting higher-level metrics on customer usage patterns for assessing overall web application performance

By Rossen Stoyanchev

This session will teach you the essentials of using Hibernate with the latest version of Spring to develop database-backed applications.

Hibernate is a solid framework bridging the gap between relational databases and object-oriented middle tiers. Spring is a solid infrastructure framework removing the need for plumbing code like getting a data source or starting

and ending a transaction. In this session you will learn what each of these tools can offer and how you can use them together to build data access applications with a strong and consistent architectural layering.

By Rossen Stoyanchev

What framework should you go with to develop web services in Java? How do the major frameworks compare in terms of features and development style? This session will provide a fair evaluation of the three major open-source web services frameworks Apache Axis, XFire CXF, and Spring Web Services. A number of factors will be considered to help attendees select the best overall framework for their requirements.

Topics covered:

- Apache Axis 1 and 2

- XFire and CXF (XFire 2.0)

- Spring Web Services 1.1

By Dave Syer and Lucas Ward

This presentation will introduce the exciting new Spring Batch project by example. Attendees will explore interesting cases of early adoption from clients of Accenture and Interface21 to learn the problems Spring Batch solves and the value it provides.

Attendees will see examples of typical batch processing patterns, and gain insight into the details of the enterprise eco-systems that Spring Batch has become a part of. Concrete examples include optimization of high-volume processing applications, flat-file processing, batch reporting and management applications, offline report production.

Many applications within the enterprise domain require bulk processing to perform business operations in mission critical environments. These business operations include automated, complex processing of large volumes of information that is most efficiently processed without user interaction. These operations typically include time based events (e.g. m

By Dave Syer and Lucas Ward

This presentation will give participants a chance to see the details of Spring Batch internals from the perspective of its creators. This will be of interest to anyone using Spring Batch and wanting to know more about how it works, and equally to those who are framework developers and want to see a few tricks.

The way the difficult framework issues have been addressed will be examined, along with the design of the Spring Batch domain model(s). We will look at topics such as:

Separation of business logic separate from framework / execution environment

Stateful retry, a previously processed item and deciding what to do based on whether it has previously failed

Resource management, for example, how to guarantee to close a file handle without the application developer needing to know explicitly that there even was a file handle.

Automatically managing the lifecycle of stateful objects tied to the scope of a step execution

Separation of job configuration from execution environment

We will show how

By Erwin Vervaet

Spring Web Flow is a powerful UI flow engine with many unique features to take advantage of in your own applications. In this session, you will learn about some of the lesser known features of Spring Web Flow and when to use them. Even if you have been working with Web Flow for some time, you'll come out of this session having learned something new.

Some of the topics covered include:

- How to use named action to implement the chain of responsibility pattern

- How to leverage the power of FlowExecutionListeners

- How evaluate actions and flow variables form a powerful combo giving you an elegant, object oriented programming paradigm for the web.

By Erwin Vervaet

This session will explain the common and complex requirement of tracking changes to information managed by a rich domain model. You will be introduced to actual-temporal, record-temporal and bi-temporal change tracking and the issues involved. Furthermore, you will also learn about several different approaches and patterns related to this problem. Finally, Erwin will show you a practical implementation of bi-temporal data leveraging Hibernate.

Come to this session to learn temporal issues in rich domain models and how to tackle them in practice.