By Mark Richards

More people are starting to turn to iBATIS as a viable persistence alternative to Hibernate and JPA. In this session you will learn why iBATIS is becoming so popular, how iBATIS differs from Hibernate and JPA (JSR-220), and how to use iBATIS as the persistence framework for Spring-based applications. Through interactive coding examples I will demonstrate how to configure and use iBATIS within Spring-based applications.

In this session I will also discuss the various caching strategies available within iBATIS and the techniques, design strategies, and best practices for using iBATIS in small and large-scale spring-based applications.

Agenda

- The State of Java Persistence

- iBATIS Architecture, Structure, and Components

- Configuring iBATIS with Spring

- iBATIS In Action (Interactive Coding)

- iBATIS Caching Strategies

- Pragmatic Usage and Best Practices

- Summary and Discussion

By Brian Sletten

You've seen how to build web applications with Spring. What if you also need to support data access and services to non-browser clients? You know how to do this with SOAP, but what about this REST stuff people are getting interested in? This talk will focus on exposing Spring code through RESTful interfaces.

This talk will focus on exposing Spring code through RESTful interfaces using technologies like Restlets and NetKernel for simplified consumption from any language/tool that supports HTTP. After a brief introduction to the ideas behind the REST architectural style, we will talk about what goes into building RESTful Spring APIs, how to control access to them through ACEGI, and how to publish, find and bind to them without using SOAP, WSDL and UDDI.

By Brian Sletten

Now that you have built your Spring applications with all kinds of fancy beans, aspects, etc. you have to deploy it. Once it is deployed, you have to manage that deployment. How do you support different installation scenarios? How do you upgrade the whole system? How about just part of the system? Installing Jar files and Spring configurations by hand is so last century. Come see how you can use Maven to deploy, upgrade and rollback Spring configurations long before JSR 277 is available.

Copying and installing Jar files and Spring configurations by hand is so last century. Maven, the project management tool that grew up out of Apache efforts can do more than manage your builds and report on unit tests.

Come see how you can use an embedded Maven engine and local repository to deploy, upgrade and rollback Spring configurations long before JSR 277 is available.

By Venkat Subramaniam

Test Driving Development (TDD) is a valuable technique. However, unit testing is hard when your code has dependencies. This often becomes a quick excuse to give up on TDD. This example driven Zero Powerpoint (ZePo) presentation will help you Spring into unit testing.

Test Driving Development (TDD) is a valuable technique that has several benefits. This example driven Zero Powerpoint (ZePo) presentation will help you spring into unit testing. We will look at techniques to realize good unit testing, and focus on the effective use of mock objects and frameworks to test your Spring application.

By Ben Alex

Join Ben for a lively discussion on ACEGI Security.

ACEGI Security

By Ben Alex

In this presentation Ben distills domain object security in Acegi. You will learn the ACL architecture, common plug-in points, and how to structure your application to use hierarchical ACL services. You will see some of the key scalability and persistence issues involved when using ACLs.

Acegi Security provides four major security capabilities:

1. authentication

2. web request authorization

3. method-level authorization and

4. domain object access control

Between these, users have enjoyed a broad foundation upon which to integrate security into their Spring-based enterprise applications.

Since Acegi 1.0 configuring basic authentication (1) and authorization (2, 3) is pretty simple--you've probably "been there, done that".

Domain object access control lists (ACL), on the other hand, are often considered one of the most powerful yet confusing areas of Acegi Security. ACLs allow you to restrict access to individual domain object instances, similar to permissions to files on

By Ben Alex

In this presentation we will study a web application developed by a major Australian corporation. We say the application uses a "real object oriented", or ROO, architecture. That means we swapped out those anemic domain objects, fat services, and repetitive DAOs for rich domain objects that utilize transparent persistence and encapsulate business rules. If you are grappling with how to do this DDD stuff, this presentation will show you what worked and provide inspiration for your own projects.

Direct from Australia, this presentation will feature an authentic Australia ROO. While quarantine restrictions have prevented the export of a live kangaroo, as a consolation we will have photos and code 'a plenty.

In this presentation we'll study an internal web application developed by a major Australian corporation. The application uses a "real object oriented", or ROO, architecture. That means we swapped out those anemic domain objects, fat services, and those repetitive DAOs for rich domain objects that utilize transparent persistence and encapsulate business rules.

We will be looking at code, architecture and key considerations in this presentation (rather than reviewing processes

By Mattias Arthursson

Spring LDAP completely eliminates the need to worry about creating and closing DirContext and looping through NamingEnumeration. It also provides a more comprehensive unchecked exception hierarchy, built on Spring's DataAccessException. As a bonus, it also contains classes for dynamically building LDAP filters and distinguished names.

In this session, the creators of Spring LDAP will discuss these

features and also do some live coding in order to demonstrate how to

quickly build a fully working person manager application.

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

tbd

tbd

By Ron Bodkin

In this session you will learn how the Glassbox open source troubleshooting and monitoring agent supports low overhead management and troubleshooting without needing to "bake in" instrumentation up front. Glassbox provides an automated installer and discovers common application components, such as Spring MVC controllers. It then reports on application performance and failures with an easy to use AJAX interface that gives concise summaries of common problems such as database failures, and slow operations caused by thread contention and excessive distributed calls. Glassbox also supports customization and detailed analysis for deeper investigation.

Under the covers, Glassbox uses JMX and aspect-oriented programming to discover applications, track performance, and automatically diagnose common problems in Java applications. You will see how Glassbox can be extended easily with XML, AspectJ, and Spring AOP, providing a solid foundation for customized application monitoring. Glassbox is deployed using AspectJ load-time weaving and is built and configured using Spring so it is an interesting example of using Spring. We look at some best practices for working with AspectJ load-time weaving to achieve the best performance and avoid issues. See also http://www.glassbox.com/ for more information.

By Jonas Boner

How do you scale a Spring application beyond a single node? How can you guarantee high-availability, eliminate single points of failure and make sure that you meet your customer SLAs? Come to this session to see the Terracotta solution to these problems.

In this rapid fire session Jonas will take you through the process of clustering a Spring application using the 'Teracotta for Spring' runtime. You'll see how to cluster the same application both transparently and naturally, with zero changes to your application code.

Some of the capabilities illustrated include:

* Preserving lifecycle and scope semantics across the cluster - within the same logical ApplicationContext (singleton and session scoped beans).

* Exporting clustered beans using Spring JMX support, which guarantees a single point of management and coherent view of all the JMX data in the cluster.

* Sharing Spring WebFlow executions across the cluster.

* Using Spring's local

By Ed Burns

In this 90 minute session, Ed Burns will clear up the fog that sometimes surrounds people's understanding of this Web Application Development Framework. Ed is well suited to the task, having helped shape the design of JSF from its inception up to the present day. Upon leaving this session, the participant will know what JSF is good for, why it is good for these things, and how to be productive using it.

Everyone already knows what a web-application is and when it's

appropriate to use them. Therefore, the session skips the small stuff

and starts out by building a strong foundation by exploring the four

pillars of JSF: the View, Model interaction, the Lifecycle, and the

Navigation Model.

With these concepts firmly understood, we cover some JSF design

principals and patterns used all over JSF. Patterns discussed include

decorator, singleton, strategy, template method, and observer. For each

pattern, its use in JSF will be covered in detail, with emphasis on how

the pattern is used to enable developer customizations.

The participant then learns about Type Conversion, Validation, Events,

an

By Jason Carreria

JSR-303 is a new specification for JavaBean validation. It will be used by upcoming revisions of specifications such as JSF and the Java Persistence API (JPA), as well as popular open source projects such as Struts 2, Spring, and Hibernate. Come and find out the current state of this important new specification from the Jason Carreira, the JSR-303 Specification Lead.

JSR 303 defines runtime meta-data for bean validations, as well as an annotation an XML-based formats for defining that meta-data.

Come and find out the current state of this important new specification from the Jason Carreira, the JSR-303 spec lead. We'll look at the ideas behind JSR-303 and the current work in progress on the API and reference implementation.

By Jim Clark

This session focuses on showing how to get the most value out your Oracle DB in a high-volume Spring-based application using Toplink JPA. Designing for performance and concurrency will be discussed. If you are using Spring and Oracle together this talk is for you.

This session focuses on showing how to get the most value out your Oracle DB in a high-volume Spring-based application using Toplink JPA. Designing for performance and concurrency will be discussed.

By Adrian Colyer

This session provides a practical tour through what's new in Spring 2. If you are using Spring 1.x and seek the most bang for your buck when upgrading to Spring 2, 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 XML configuration support, updates to Spring AOP, new bean scoping options, JPA support, asynchronous JMS, updates to Spring MVC, scripting language support and more!

By Adrian Colyer

Do you seek to to improve the modularity of your enterprise applications? Do you wish you could deploy multiple concurrent versions of services and applications? Do you require operational control over the lifecycle of key application components? Interested in building on a proven component technology? If so, Spring on OSGi could be just the thing for you.

In this session Adrian will first introduce OSGi and then focus on the new Spring support for building Spring applications that take advantage of the OSGi platform.

By Adrian Colyer

By Adrian Colyer and Rob Harrop

Come to this session to learn the tools, tips, and tricks Rob and Adrian use day-to-day to stay productive, and to have some fun in the process, too.

No one could deny the chemistry between Rob and Adrian at last year's Spring Experience during their "Pragmatic AOP with Spring and AspectJ" talk--a favorite at the show. The two literally completed each other sentences.

This year they're back, this time to talk about tooling. And since Adrian is a hard-core Eclipse guy, while Rob the epitome of an IDEA snob, things could get interesting...

Come to this session to learn the tools, tips, and tricks Rob and Adrian use day-to-day to stay productive, and to have some fun in the process, too.

By Keith Donald

This session covers the set of object-oriented patterns and best practices that makeup the foundational building blocks of Domain-Driven Design. Keith will quickly define each building block, then present a number of focused examples that show motivation and usage considerations. Attendees will leave equipped with a rich vocabulary for describing the structure of a software system, as well as an understanding of when to use these building blocks and how to use them effectively.

The core building blocks include discussed:

- Applications

- Layers

- Modules

- Services

- Entities

- Value objects

- Associations

- Repositories

- Factories

- Aggregates

Keith will quickly define each, then present a number of focused examples that show motivation and usage considerations. Attendees will leave equipped with a rich vocabulary for describing the structure of a software system, as well as an understanding of when to use these building blocks and how to use them effectively.

By Keith Donald

In this interactive session Keith and the audience will work together to craft the domain layer of a non-trivial business application using Domain-Driven Design (DDD) techniques. Attendees will learn techniques for distilling a domain layer from interactions with end users and domain experts. They will experience how a design translates to an implementation prototype powered by Spring.

This session is divided into three parts:

The first part simulates the dynamics between system designers and end users to distill the core of a complex domain. You will extract an initial model that serves as the ubiquitous language for the project.

The second part focuses on binding the model to an implementation prototype powered by Spring using the DDD building blocks outlined in the previous session.

The third part emphasies the discovery process that results as the initial model's utility is put to the test in implementation. You'll see how models evolve and transform on deeper insight.

Attendees will learn techniques for distilling a domain layer from interactions with end user

By Keith Donald and Erwin Vervaet

Join Erwin and Keith for a lively discussion on Spring's UI technologies including Spring Web Flow and Spring Rich Client.

Spring Web Flow and Spring Rich Client.

By Keith Donald and Erwin Vervaet

In this "storytellers" Keith and Erwin speak from the heart about the 18th month journey leading Spring Web Flow from infancy to a stable, production-ready product. You'll gain insight into what the most difficult challenges were, and what sparked the most exciting design breakthroughs. You'll leave with lessons Keith and Erwin learned along the way.

You'll gain insight into how the project evolved, including:

- Where the most difficult challenges were

- What sparked the most exciting breakthroughs

- What caused the most passionate disputes

- Where transformations on deeper insight have lead to sustainable advantage

You'll leave with overall lessons Keith and Erwin learned along the way.

By Christian Dupuis and Colin Sampaleanu

Spring 2.0, Java EE 5.0, EJB 3.0, how do they relate? This session compares and analyzes Spring 2.0 in the world of Java EE 5.0.

One of the main goals of the Java EE 5 specification was to simplify the EJB programming model to overcome the complexity of previous versions. Among simplifications in the component model, new features such as Dependency Injection (DI) and annotation based interception have been added to the specification.

The session will give a brief introduction to the new features of EJB 3.0, comparing them to features available in Spring (including Spring AOP) and AspectJ. It will show that Spring adds value even in a Java EE 5.0 environment, and generally offers more comprehensive Inversion of Control and Dependency injection capabilities, while offering true AOP functionality, not just simple interc

By Eric Evans

For many software teams, complexity lies in the intricacy of the problem domain itself. Domain models provide a way to manage that complexity. In this session Eric Evans, the author of Domain-Driven Design, will set the tone for this track by sharing what DDD is all about.

In this session Eric Evans, the author of Domain-Driven Design, will set the tone for this track by sharing what DDD is all about.

By Eric Evans, Rob Harrop, Juergen Hoeller, and Thomas Risberg

Join Juergen and Rob for a lively discussion on Core Spring.

Core Spring Framework BOF

By Mark Fisher

One of the most exciting new features of Spring 2.0 is its support for Message-Driven POJOs (MDPs). In this talk we will build a Message-Driven POJO sample application from the ground up.

With Spring 2.0 MDPs, it is now possible to receive JMS messages asynchronously and delegate the handling of those messages to simple objects. If your POJO has a return value, it will automatically be sent to a reply destination. Spring's messaging containers support configurable pooling of concurrent consumers and offer full integration with Spring's transaction management.

After a quick overview of Spring's JMS support, we will build a Message-Driven POJO sample application from the ground up. This will include sending a Message as a request and receiving a reply across separate JVMs. You will learn how to configure the Message-Driven POJO without writing a single line of messaging code.

By Mark Fisher and John Lewis

In this session, Mark and John will give a tour of the Spring Portlet MVC framework. They will provide an in-depth review of a sample application developed using the Spring Portlet MVC framework. If you are using Spring in a Portlet environment, this session is for you.

Spring's Portlet MVC framework brings the proven benefits of the servlet-based Spring MVC framework to JSR-168 Portlet development. In fact, many of Spring MVC's classes and interfaces have parallel versions within the portlet framework. Therefore, architects and developers who are already familiar with Spring MVC's architecture and idioms will find themselves immediately at home, while new Spring users will find it refreshingly intuitive.

In this session, Mark and John will point out the similarities and differences between servlet and portlet applications at a high level. Then, they will give a quick tour of the Spring Portlet MVC framework highlighting how these similarities and differen

By Mark Fisher and Ross Mason

This session will offer a glimpse of a few technologies (scheduling, messaging, and remoting) within the context of an ESB. The content will be heavily example-based with a good deal of code. We will present a sample application built with Spring and Mule - a popular open source ESB engine.

An Enterprise Service Bus (ESB) brings flow-related concepts such as transformation and routing to a Service-Oriented Architecture. An ESB can also provide an abstraction for endpoints. This promotes flexibility in the transport layer and enables pluggability of POJO services.

The emphasis in this session will be on Spring's enabling role within such an environment for implementing POJO-based solutions that achieve flexibility in the face of change.

By Ben Hale

When Rod Johnson wrote J2EE Design and Development he called J2EE "the best platform for enterprise development today", claiming the problem in those days wasn't J2EE itself but that it was "often used badly". In this session attendees will leave with an understanding of the big picture--the fundamentals that make Java and JEE application development work in practice. You will learn the foundations of the Spring Framework project and the principles of the developers and community behind it.

At the heart of Rod's book were techniques that showed us how to make J2EE work in practice. And delivered with that book were 30,000 lines of code that put those techniques into action. Add Juergen, Thomas, Alef, Colin, Keith, and Rob (in that order), and one hell of a passionate user community and, well, the rest they say "is history".

In this session attendees will leave with an understanding of the big picture--the fundamentals that make Java and JEE application development work in practice.

By Ben Hale

You may have heard it before, "Spring configuration is XML hell"! This session analyzes what's behind this statement to see if it holds water. In this "MythBuster" you'll learn practical techniques for managing (and in many cases reducing) the volume of configuration information for your Spring-based application.

You'll leave with guidelines on:

- What to externalize the configuration of and what not to

- When to select a particular configuration medium: XML? Annotations? Java? Custom DSL?

- How to effectively organize configuration information as your project grows

- How to benefit from intelligent defaulting and conventions

You will also see how Spring 2 introduces the new concept of custom XML dialects for simplifying configuration. These new dialects allow you to create domain specific configuration tags for your application components. This session illustrates a business case for implementing a custom configuration dialect.

Is this myth fact or fiction? Tune in and find out!

By Rob Harrop

This session is not to be missed. In it Rob will discuss the essentials necessary for true rapid webapp development in today's Web 2.0 market. Once those are outlined he will present solutions that build on Spring's foundations.

Spring MVC and Web Flow are two foundational web application technologies. Together they deliver a flexible model that allows for extension across each aspect of the MVC triad. With that said today's web application developer is less concerned about the ins-and-outs of low-level framework constructs. Developers just want to know they work. Today's developer is more interested in holistic, integrated solutions that solve common problems and enhance the overall end user experience. Developers have come to expect exponental productivity gains without a large ramp up period.

In this session Rob will discuss the essentials necessary for rapid webapp development in today's Web 2.0 market. O

By Rob Harrop and Brian Oliver

In this session Brian will introduce and examine the Data Grid paradigm, and together with Rob will demonstrate how Spring users may apply it to increase the availability, reliability, scalability and performance of their systems, while at the same time reducing system complexity and improving delivery.

While clustering applications may increase the overall availability of business services, it certainly does not imply that they may easily scale out to provide greater system capacity or performance. Further, most clustering solutions leave the effort of addressing non-trivial issues like data, space, recovery and process partitioning (affinity) across a cluster to the developer, ultimately increasing application and deployment complexity and impeding the rate at which solutions may be delivered.

In this session we will introduce and examine the Data Grid paradigm, and in particular how Spring applications may apply it to increase the availability, reliability, scalability and performanc

By Rob Harrop

Ruby is a neat little language that is growing in popularity. JRuby is an effort to bring the Ruby language to the Java VM. Come to this session for some fun learning Ruby and using it within a Java environment.

Come to this session for some fun learning Ruby and using it within a Java environment.

By Rob Harrop and Bram Smeets

The Ajax framework world is abuzz, with over 130 frameworks battling it out to become the next big thing. Who's winning? Who's not? Where do the winning frameworks fit within Spring's web stack? Come to this session to get a "state of the union" on the Ajax framework world, and learn new opportunities for Ajax integration within your Spring-powered application.

This is your "Ajax experience" in 90 minutes with a Spring twist.

By Juergen Hoeller

Transactions are essential to ensuring the integrity of data stored in enterprise information systems. A core part of Spring's middle tier support is the transaction management support. This session presents several interesting "mission critical" cases and shows you how to properly handle them using transactions driven by Spring 2.

You'll learn the ins-and-out of the "dark art" that is transaction management within a high-volume mission-critical JEE application.

By Juergen Hoeller

Structuring a large code base maintained by multiple teams working in parallel can be a real challenge. If you are not disciplined about code structure overtime you will end up with a tangled, unmaintainable mess that cannot adapt to change and risks ossifying into legacy. In this session Juergen will pull from his experiences working on large projects to provide important guidelines on code structure.

In this session Juergen will pull from his experiences working on large projects (including his role as chief architect of the Spring Framework) to provide general guidelines on:

Packaging and package interdependencies

Layering and module decomposition

Evolving a large code base

Juergen will also discuss how tools can play a role in enforcing architectural soundness.

Attendees will leave with practical techniques to improve and sustain the overall structure of their code bases, as well as an understanding of the benefits gained by doing so.

By Juergen Hoeller

Juergen's popular "Hidden Gems" session returns newly updated for 2006. Come to this session for 10 hidden gems tucked away in Spring you might not know about but definitely should.

Come to this session for 10 hidden gems tucked away in Spring you might not know about but definitely should.

By Juergen Hoeller

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

Spring includes sophisticated support for synchronous messaging via JMS since release 1.1, for J2EE as well as standalone environments. The newest addition to the family is support for asynchronous message listening based on POJOs, introduced in Spring 2.0. Come to this session to see the latest JMS support provided in Spring.

By Luke Hohmann

By Luke Hohmann

This hands on, "learning by doing" class describes 12 proven techniques for working with customers, and in the process understanding what your customers really want. They're fun, and they work.

The first step to creating truly successful products is understanding what customers really want. This can be harder than it sounds. Customers don't always know what they want. Because they don't know, they can't tell you. So, asking them to rank requirements or write stories isn't very effective at helping you understand what they really want.

This hands on, "learning by doing" class describes 12 proven techniques for working with customers, and in the process understanding what your customers really want. They're fun, and they work.

By Rod Johnson

By Rod Johnson, Mike Keith, and Patrick Linskey

The persistence part of EJB 3 (JSR 220) provides JPA, a standardized lightweight POJO persistence API for object/relational mapping. Today, your favorite ORMs such as Hibernate, Toplink, and Kodo are all now JPA implementations. To kick off the Enterprise track, this session will cover Spring's JPA support and the motivation behind it. It will demonstrate how Spring eases JPA development, testing, and deployment.

This session will cover Spring 2.0 JPA support, and the motivation behind it. It will demonstrate how Spring eases JPA development, testing, and deployment.

By Rod Johnson and Guillaume LaForge

Use of scripting languages within a enterprise Java environment is on the rise. In this session Rod and Guillaume will examine practical scenarios where scripting adds value. You'll not only learn where dynamic languages such as Groovy fit, you'll also learn how to work with them effectively in a Spring environment.

While Spring has had scripting support for awhile now, only recently have we seen much uptake in this support by our user community. Use of scripting languages within a enterprise Java environment is definitely on the rise.

In this session Rod and Guillaume will examine practical scenarios where scripting adds value. You'll not only learn where dynamic languages fit, you'll also learn how to work with them effectively in a Spring environment.

By Rod Johnson

By now you know that Dependency Injection facilitates unit testing. You also know you don't need Spring to properly unit test your code in isolation. However, when it comes to system integration testing Spring adds real value. Come to this highly-acclaimed session to experience the value in action.

Not only does Spring provide you an application configuration framework, it provides a holistic solution that makes your application's use cases and subsystems easier to test. The emphasis is on testing outside a JEE server or container, thus greatly improving productivity.

In this session, Rod will discuss:

* Integration testing and the support that Spring provides for it

* Issues around testing the persistence layer

* Testing web applications

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

By Mike Keith and Patrick Linskey

This talk will discuss some of the areas not covered by the current version of the JPA specification and give examples of how to be successful "outside the lines" while still staying within the reach of the JPA framework.

The Java Persistence API (JPA) is the enterprise standard for O/R mapping and persistence, and provides a portable way to map and operate on persistable Java objects. However, neither JPA nor any specification can ever be everything for everyone. There will always be areas where developers will venture beyond the specification coverage. This talk will discuss areas not covered by the current version of the JPA specification and give examples of how to be successful "outside the lines" while still staying within the reach of the JPA framework.

By Guillaume LaForge

This session will introduce Grails, a new and innovative web framework based on a dynamic language, Groovy, with a solid foundation in off the shelf enterprise-ready frameworks such as Spring, Hibernate and SiteMesh.

Based on the "convention over configuration" paradigm initiated by the Ruby on Rails framework, this session will demonstrate how Grails can help you build powerful web applications in no time, while still being able to take advantage of your existing knowledge and expertise on the Java EE platform and the wealth of components available in the Java ecosystem.

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

In this talk we will explore how to apply AOP and DI to implement a rich domain model. We will examine the need for domain driven design, technical obstacles in achieving it, and techniques to addressing those obstacles. This session will also present several examples that show the power behind the techniques.

Domain Driven Design (DDD) suggests dealing with complex software system using a domain model and preserving the model in implementation. While the idea behind DDD itself is simple, there are many obstacles in implementing it in practice. Combining Dependency Injection (DI) with a full-fledged aspect-oriented programming (AOP) system such as AspectJ help overcome many obstacles.

In this talk, we will explore ways to effectively apply AOP and DI to implement a domain model. We will examine the need for domain driven design, obstacles in achieving it, the basics of enabling behavior-richness for domain objects, and patterns of usages. This session will also present several examples that show

By Ramnivas Laddad

AspectJ provides powerful ways to modularize crosscutting concerns. With power comes responsibility. By the end of this presentation you will understand how to harness the power of AspectJ to develop clean, testable code while minimizing abuse.

AspectJ provides powerful ways to modularize crosscutting concerns. With power comes responsibility. It is easy to run amok with cool features in AspectJ and abuse its power. This presentation will address many design and implementation considerations in using AspectJ in enterprise applications: How to write good pointcuts? When to use signature-based pointcuts? When to use annotation-based pointcuts? How to use the simplest advice to get the job done? How to deal with exceptions thrown during advice? How to leverage tools in ensuring that you understand what you are doing? How to use the right syntax and weaving model? How to harness power of AOP design patterns?

By the end of this presen

By Scott Leberknight

Spring's Hibernate integration simplifies applications that use Hibernate by removing tedious and repetitive infrastructure code that you need to write. Spring JDBC achieves a similiar simplification for executing SQL statements using the lower level JDBC API. So when do you use one or the other, and what are the important usage guidelines? Come to this session to find out.

In this session you will learn best practices and tradeoffs when using Hibernate with Spring. We will consider Hibernate mapping strategies, session factory configuration, DAO and business service implementation, declarative transaction management, unit and integration testing, and dealing with Hibernate lazy-loading.

In addition, you will learn how to combine use of Hibernate with use of JDBC in the same application and the cases for when that is appropriate.

By Patrick Linskey

Open JPA aims to be a fully compliant, enterprise grade open-source JPA implementation suitable for production use. Now that you've seen what the JPA specification is all about, come to this session to get started with Open JPA in a Spring enviornment.

You'll see how Open JPA goes beyond the specification to include important features including custom lock groups, dynamic fetch group configuration, custom mapping capabilities, save point capabilities, and caching.

By Martin Lippert

Eclipse as a Rich Client Platform is increasingly mainstream. Organizations from NASA to IBM to major banks and airlines have adopted RCP as a core platform for building their applications. In this talk we look at various current RCP usecases and examples and discuss the synergies with Spring.

Eclipse still has even more to offer in the application space. Eclipse's inherent dynamism and the use of Eclipse on the server are largely hidden gems. Spring has its heritage on the server and has enjoyed some use as a rich client platform. In this talk we look at various current RCP usecases and examples, and discuss the evolution and integration opportunities of these technologies.

By Jan Machacek

Rule engines have started to make an impact in the Java community. In this session, Jan will demonstrate situations where a rule engine can simplify an application's business logic. Jan will show typical examples of rules-based Spring applications and explain the principles behind each example.

Attendees will learn the fundaments of rule engine programming and usage of rule engines in Java applications. After this session you will have enough knowledge to start using rules engines in your own applications.

By Floyd Marinescu and Alexandru Popescu

InfoQ.com is a next generation web app/portal implementation combining the latest advancements in portal technology (JSR 170) and web development (WebWork, Spring, AspectJ, DWR).

This session will walk the viewer through the good, the bad, and the ugly of building InfoQ.com. Walk with us from initial requirements (or lack theoreof), designs, implementation choices, and deployment issues, and all the lessons learned along the way.

The talk will examine some of the most interesting features of the site and show their implementation in the web layer, domain model, and DB. The audience should expect an educating and revealing presentation on how to transition from standard web development paradigms to modern tag-driven CMS approaches.

By Floyd Marinescu

There are a number of trends occurring that are rapidly changing the way we think about and develop Enterprise Java applications. This talk will give an update on the most important trends affecting Java that you should be paying close attention to.

Trends discussed include:

Annotations, Dependency Injection, and AOP

Web 2.0 turning the internet into an application platform

Domain Driven Design

SOA

Open Source in emerging economies

the rise of scripting languages

... and others that are changing the nature of software development in Java.

This talk, presented by author of the book EJB Design Patterns, creator of TheServerSide.com and co-founder/Chief Editor of InfoQ.com Enterprise Software Development Community, will give an update on the most important trends affecting Java that are currently growing and will become mainstream in 1-2 years that you should be paying close attention to.

By Ross Mason

In "Spring and the ESB" you learned how Enterprise Service Bus technology fits within the enterprise. Come to this session to learn the latest about Mule 2.0, a popular open-source ESB implementation.

This session drills down into the details of the Mule 2.0 ESB. Focus will be on the latest and greatest features, and how you can take advantage of them within a Spring environment.

By Eamonn McManus

The JMX (tm) API is a core part of the Java (tm) Standard Edition and Enterprise Edition platforms. The Spring Framework includes good support for JMX Technology in both those environments. In this session, the Specification Lead for the JMX API will present good practices for using JMX in your applications. He will also examine the Spring integration how best to exploit it.

JMX technology is also evolving through Java Specification Requests 255 and 262. We will see how those changes impact the latest Java platform (Java SE 6) and what is in store for the future (Java SE 7). We will also see what is planned for the integration of JMX technology with Web Services standards.

Attendees will benefit from some acquaintance with the concepts of the JMX API, but in-depth knowledge is not required.

By Jeff Patton

User Interface Design, User Centered Design, Interaction Design, Information Architecture, Visual Design, Human Computer Interaction, and Usability Engineering: what do all these terms mean? And exactly what do you need to do to improve your users' experience with your software? Now more than ever the quality of user experience separates the successful software products from the failures.

Effectively leveraging advanced user interactions such as Ajax requires a fundamental knowledge of user experience processes and techniques. In this tutorial you’ll learn what User Experience specialists do and how you can leverage Ux approaches to improve the quality of user interface in your software.

By Mark Pollack and Aleksandar Seovic

Join Aleksandar & Mark for a lively discussion on .NET & Java Interop

.NET & Java Interoperability

By Arjen Poutsma

The term "Service-Oriented Architecture" is very popular these days, but what does it mean exactly? Is SOA just an abbreviation for Same Old Architecture? And if it isn't, where does the old architecture fit in? In this session, we will cut through the SOA hype and get right to the substance.

In this session, we will talk about SOA's and Web services in a pragmatic fashion. We will talk about the proper place of a Web service within an application architecture, both from the client and the server perspective. And we will talk about the value of SOAP vs REST, and the multitude of WS-* specifications that are out there: what value do they add?

By Arjen Poutsma

In this presentation Arjen will show you how to implement a contract-first web service using Spring Web Services (WS). If you want to see how to implement standard, public, interoperable web services in Java "the right way" don't miss this session.

Web services experts agree that "contract-first" development is a best practice. That means starting with the public message contract before jumping right into Java code.

Traditionally, however, this best practice hasn't been followed in practice. One possible explanation are the cookie cutter tools that push developers towards a model where methods are exposed in a RPC-like fashion, instead of a document-central model where the public message contract is king.

In this presentation Arjen will show you how to implement a contract-first web service using Spring Web Services (WS), a product from the Spring community that simplifies the development of document-driven web services. We will st

By Matt Raible

The 2.0 version of AppFuse is designed to make developing Java web applications with Spring much easier. By using and leveraging Maven 2, users will be able to quickly add/remove dependencies, as well as develop their applications quickly and efficiently from their favorite IDE. This release will includes a move to annotations, JSP 2.0 and Spring 2.0.

This session will cover what's new in AppFuse 2.0, as well as describe experiences migrating from Ant to Maven, Spring 1.x to 2.0, and leveraging annotations for Java development.

By Colin Sampaleanu

With the advent of the Google Web Toolkit (GWT), Tibco's General Interface, Backbase and other similar frameworks, "fat clients" look to be making a comeback--this time on the web, with framework generated JavaScript running the show. Come to this session to see what this means to you.

Colin will explore and explain the difference between the three fundamental approaches to using AJAX in web applications:

- enriched web pages

- frameworks where server-side components generate AJAX views for the client

- true JavaScript fat apps such as enabled by Google Web Toolkit and Tibco GI

Focusing on the latter, Colin will explain some of the benefits, trade-offs and hidden costs of this approach. He will then show how these frameworks fit into a Spring-based architectures, showing integration into the middle tier of a web-based application written using Spring.

Are web fat clients the next big thing? Find out here.

By Bram Smeets

This session will focus on using DWR within a web application environment to add rich, dynamic behavior without the hassle of knowing the ins-and-outs of XmlHttpRequest.

Buzzwords like AJAX (Asynchronous JavaScript And XML) and HttpXmlRequest have been flying around Java blogs for months now. Frameworks around these technologies are growing more mature.

At the end of the day Ajaxian frameworks set out to accomplish one primary directive: make it as easy as possible to create rich web applications that enhance the overall user experience. The DWR (Direct Web Remoting) is one project that aims to support this directive by providing easy AJAX for Java.

This session will focus on using DWR within a web application environment to add rich, dynamic behavior without the hassle of knowing the ins-and-outs of HttpXmlRequest. Most importantly, attendees will learn

By Mike Stenhouse

Web applications are the new rock and roll. Everyone seems to either have one already or be thinking about writing one. In this session Mike will take a helter skelter dash through some of the front-end technologies and techniques that can make your web interface better, including web standards, progressive enhancement and unobtrusive Javascript.

As more and more companies move their interfaces online those with the knowledge of what is possible in the Internet medium will have the advantage in this fast-filling marketplace.

Themed on the progressive enhancement philosophy the session will run through proper HTML, Microformats, CSS, Dom Scripting, Ajax and unobtrusive Javascript. If properly applied, the result is more flexible, reliable and maintainable applications that work better and are available to a larger audience.

By Erwin Vervaet

In this session Erwin will address the challenges of designing and implementing web application dialogs to support a rich user experience. You'll learn how to manage state, enforce a linear progression, prevent duplicate submits, and deal with browser navigational button use (such as the infamous back button problem).

In addition, you'll learn how to achieve code reuse, elegance, and testability. This session will be backed up with a number of interesting live demos that are not to be missed.

By Eberhard Wolff

This session looks beyond the acronyms to distill the rationale behind the shift away from "anemic" domain models towards "rich" domain models. It explores several technical consequences that can arise when practicing DDD when dealing with large scale enterprise integration and SOA.

You may have overheard a confusing conversation like this before:

Developer 1: This rich domain model stuff is so hot right now.

Developer 2: Yes! And value objects are evil! Thanks to DDD and Spring we don't need those anymore!

Developer 1: Wait, don't you mean DTOs?

Developer 2: Whatever. They're evil too! One model for them all!

This session looks beyond the acronyms to distill the rationale behind the shift away from "anemic" domain models towards "rich" domain models. It also explores consequences that can arise if you're not careful, particularly when dealing with large scale enterprise integration and SOA.

Is this myth fact or fiction? Tune in and find out!

By Eberhard Wolff

This just in! Dependency injection improves testability. What, you mean you already knew that? While the positive effects of dependency injection on unit testing are understood, loose coupling also facilitates system, acceptance, and load testing. In this session you'll learn how to do acceptance testing with Spring and a tool called FitNesse.

Higher level acceptance and stress tests are important for meeting end user requirements. This session goes places where the others don't. You'll learn how to do acceptance testing with Spring and a tool called FitNesse. You'll also see techniques for stress testing, including using aspects to measure performance and debug issues in a production environment.