Session Schedule

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 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 and Mark Fisher
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 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 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 Aaron Zeckoski and Antranig Basman
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 well as in Spring Web Flow 1.x and 2.x.

We will stress the separation of roles that RSF offers between developers and designers, the latter free to customise the application design by editing pure XHTML templates decoupled from developer work cycles. We will also showcase RSF's work with the accessibility community, most particularly the Fluid Project, to build a reliable library of UI components that work in every environment for users with different needs.

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 ways to implement architectural enforcement policies along with many reusable examples. Attendees will learn to define policies, and ensure architectural violations are detected immediately upon their introduction into a code base leading to a solid implementation that is faithful to its design.

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 and how to validate XML with a schema, and more. Finally, we will show some recent improvements into Spring Web Services which facilitate WS-DuckTyping.

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, channel switching and so on. As such, Spring Security significantly reduces the cost and risk of securing enterprise applications, while also providing a robust, production-proven solution that is extremely flexible to current and future requirements.

This session is aimed at introducing Spring Security to those not already using it, or those wishing to gain a wider appreciation of what it can do in typical enterprise applications. We'll demonstrate adding Spring Security to an existing web application. This will show you how easy it is to configure and deploy Spring Security.

Attendees already familiar with Spring/Acegi Security are invited to consider attending the "What's New In Spring Security 2" session, which will provide specific in-depth coverage of the new Spring Security 2 features.

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 configure it with Spring Security. We'll also cover in detail how to upgrade your existing Acegi Security configurations to the new and significantly simplified Spring Security 2 configuration namespace.

This session is aimed at existing Spring/Acegi Security users. Those not already using Spring/Acegi Security are invited to consider attending the "Introduction to Spring Security" session for a broader introduction to the Spring Security feature set and introductory implementation approaches. Those interested in the new prtlet support in Spring Security are encouraged to attend John Lewis' session, "Securing Portlets with Spring Security".

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 with just J2SE and Spring, although it can be easily hosted within WebSphere if required. The session will examine the overall design of the application and show how ObjectGrid integrates with Spring.

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 eliminate them by refactoring your code - something you can start doing the Monday morning after the conference.

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 model.

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 fundamentally easier.

This talk will start with an overview of Spring IDE and the support for Spring 2.5, AOP, Web Flow and JavaConfig. We will then give several demonstrations that showcase how Spring IDE is working together with Mylyn to make your enterprise application development easier. The demonstrations will range from integrated issue tracking to the streamlined workflow that results when all your code and beans are automatically focused on the task-at-hand. We will also review the growing ecosystem around these two technologies, and present the roadmap for Spring application development tools with the first public demonstration of the SpringSource Tool Suite.

By Costin Leau and Craig Walls
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
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 Spring application together using annotations instead of XML.

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 XML-free options such as using Java 5 annotations and scripting languages to configure Spring.

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 combination of Spring and OSGi offers developers a refreshing lightweight component framework that is dramatically changing the enterprise Java landscape.

In this example-driven session, I'll show you the basics of building Spring-DM components, starting with a simple "Hello World" example and then ramping up quickly to a full-blown web application. You'll learn how to publish and consume services, how to extend bundles with OSGi fragments, and how to write integration tests against your component bundles.

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. month-end calculations, notices or correspondence), periodic application of complex business rules processed repetitively across very large data sets (e.g. insurance benefit determination or rate adjustments), or the integration of information that is received from internal and external systems that typically requires formatting, validation and processing in a transactional manner into the system of record. Batch processing is used to process billions of transactions every day for enterprises.

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 Spring Core features such as custom scopes, namespaces and templates have been used in Spring Batch to address some of these requirements. We will also show how the use of a domain-driven approach to the design of Spring Batch has brought benefits to the product generally.

The initial release of Spring Batch provides an Infrastructure layer in the form of low level tools. There is also a simple Container application, using the infrastructure in its implementation. The container provides robust features for traceability and management of the batch lifecycle. A key goal is that the management of the batch process (locating a job and its input, starting, scheduling,restarting, and finally processing to created results) should be as easy as possible for developers.

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.

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 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 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