Parleys.com

Structuring a large code base maintained by 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. This session presents typical challenges in evolving large code bases, focusing on package interdependencies and module decomposition according to 'conceptual boundaries'. We will discuss lessons learned from the Spring project itself, and investigate the use of tools for validating architectural soundness.

This follow-on to last year's JavaOne sleeper hit 'The Top 10 Ways to Botch an Enterprise Java Technology-Based Application' explores best practices for protecting against scalability and reliability in Java Enterprise Edition applications and compute grid environments. Starting with simple abuses of messaging and clustering technologies, this presentation navigates a wide swath of options available to enterprising architects seeking to limit the effectiveness of scale-out environments.

After last year's presentation, we were disappointed that some attendees mistakenly used this information to avoid pitfalls, errors, and other common causes of project failure. We hope for better results this year.

This session will introduce you to the basics of JSF 1.2 and will explain why JSF is different from other web-frameworks. The concepts of JSF will be shown using the JSF request lifecycle, a short overview of the JSF standard components will complete the picture. Additionally, we'll bring a little light into the jungle of JSF frameworks, add-ons and component libraries and introduce you to the most important ones briefly.

The Spring framework has an extremely rich set of features that span all tiers of the application. If you are relatively new to Spring you might be wondering which of the many features to focus on; which features to avoid; and how to use the various features together in an application. This talk describes how the Spring framework was used to build an enterprise Java application. We will walk through each tier of the application and describe how the Spring framework was used.

You will learn about how Spring was used to solve various design issues including:

• wiring application components together
• handling crosscutting concerns including transactions, audit logging, and security
• simplifying database access.
• testing

In the talk Paul will look at the capabilities and approach of Open Source ESBs, and argue that the Open Source approach is the best route to creating a long-term, robust and cost-effective Service Oriented Architecture. Paul will look at Open Source ESBs including Mule, ServiceMix, and Synapse, and explore the strengths and weaknesses of each approach, and compare to the offerings from the established vendors.

Whenever the need for reporting arises one has a broad spectrum to choose from. However if it comes down to integration with Spring, JasperReports is the way to go. With reports output coming from virtually anywhere JasperReports is capable of rendering into four different formats: CSV, Excel, HTML and PDF. In this session, Joris and Jan discuss the usability and hacks of JasperReports combined with Spring.

Writing unit tests should be easy and intuitively... at least in theory. In practice, you need a lot of infrastructure, libraries and boilerplate code before you get to do something productive on a database driven enterprise project.

Unitils is an open source library, written by a number of colleagues from Ordina J-Technologies , aimed at making unit testing easy and maintainable. Unitils builds further on existing libraries like DBUnit and EasyMock and integrates with JUnit and TestNG. The framework includes general assertion utilities, support for database testing, for testing with mock objects and offers integration with Spring and Hibernate. It has been designed to offer these services to unit tests in a very configurable and loosely coupled way.

During this presentation we will discuss unit test guidelines and best practices. We will make use of examples to demonstrate how Unitils can help you in writing simple and maintainable unit tests.

The debate about REST (REpresentational State Transfer) as an alternative to SOAP has been going on for several years now - with more and more respect for the REST point of view in the recent past. While many will agree that a RESTful approach is a better match for Web 2.0-style, public-facing Internet services, it's still often questioned how REST could be applied to 'Enterprise' scenarios. This talk will briefly summarize the REST principles behind the Web's architecture, and then show how an enterprise scenario can benefit from the properties that have made the Web a success.

Spring Beyond the Obvious - using Spring in complex enterprise projects. We all know how to dependency inject our service objects and our DAOs or Repository. We know how to set up a transactional service layer using @Transactional annotations or using <tx:advice> in XML. There are plenty situations however where is doesn't end here. Many development teams use multiple environments (staging environments, production environments, et cetera). How do you set up your application context(s) in such a way that it easy to transition from one environment to the other. How does internationalization affect your application, et cetera.

In this talk Joris Kuipers will review several complex scenarios they both saw in real projects and how Spring helped solve those issues. Ranging from Spring extension points to the set up of your project; this really takes Spring beyond the obvious.