Craig Walls

By Craig Walls

Writing tests is more than just writing JUnit test cases and hoping that they'll pass when your project is built. If you want assurance that your code is sound and provides the desired functionality, then you'll want to test it from every angle and run those tests as frequently as possible.

In this session, we'll look at a few testing tools that you may not be all that familiar with, including:

• Infinitest : A continuous testing tool that reports test failures almost as quickly as you can break them.
• Mockito : A relatively new tool for mocking objects in tests.
• Concordion : A framework for writing FIT-like functional specifications, without the hassles of FIT.
• jqUnit and JSTester : A xUnit-like framework for testing JavaScript.
• Selenium : A framework for in-container testing of web applications.

If you're ready to elevate your testing prowess to the next level, come see how these tools can help.

By Craig Walls

In this session, I'll lead a guided tour through the latest that Spring has to offer. Whether you're a Spring veteran or a Spring newbie, there will be something new for nearly everyone.

It's been just over 5 years since Spring 1.0 was released. In that time it has gone from a modest open-source project to being a de facto standard Java application framework. Now, as Spring enters its 6th year, it continues its attack on Java complexity with Spring 3.0, packed with many new features such as:

• First-class REST support
• A new expression language
• More options for annotation-driven bean wiring
• And much more

In this session, I'll lead a guided tour through the latest that Spring has to offer. Whether you're a Spring veteran or a Spring newbie, there will be something new for nearly everyone.

By Craig Walls

Spring 3.0 introduced the Spring Expression Language (SpEL), an extremely powerful yet succinct way to wire non-trivial values into Spring beans. In this presentation, we'll explore SpEL in great detail and see how SpEL opens up a whole new realm of bean wiring possibilities.

Spring's brand of dependency injection is quite awesome. But there are times when simple bean references and static values won't cut it. Sometimes it makes more sense to wire bean properties with values that are evaluated dynamically at runtime.

That's where the Spring Expression Language (SpEL) comes in. SpEL is one of the most interesting of the many new features in Spring 3.0. With SpEL you can succinctly wire in values derived...

• ...from system properties
• ...mathematically
• ...from the values of other bean properties
• ...from the results of static methods
• ...from almost anything you can conjure up

Previously, most of these types of wiring could only be accomplished with more XML configuration or special helper factory beans. But with SpEL, the seemingly impossible is not only possible, but is quite easy.

In this example-driven presentation, we'll explore SpEL in detail and you'll learn the tricks of SpEL that will make you a bean wiring wizard.

By Craig Walls

In this session, we'll look at the latest features of Spring 3.0's MVC framework, with an emphasis on building RESTful web applications. You'll see how Spring 3.0's new @PathVariable annotation can be used to develop controllers that respond to resource-oriented RESTful URLs and how ContentNegotiatingViewResolver can turn a user-facing web application into a powerful web-based API. We'll explore other ways Spring 3.0 supports working with REST, including how to write REST clients.

It is a very common practice to develop web applications that are use-case-oriented. This approach has a very procedural feel to it where URLs often involve imperative verbs: "showProduct", "deleteOrder", or "updateShoppingCart". While this approach has served us well, it does lead unnatural and difficult-to-follow URL schemes. Furthermore, the direct objects of the URLs' verbs are often specified in parameters, precluding any effective caching or indexing within search engines.

In contrast, RESTful web applications tend to be more resource-oriented. Rather than focus on verbs, REST places emphasis on the nouns. RESTful URLs tend to describe the target of an operation and rely on a fixed set of verbs (GET, PUT, DELETE, and POST) to indicate the operation itself. Moreoever, RESTful URLs identify resources, which themselves may be represented in many forms. This means that, if properly applied, REST can be used not only to create a web application, but to also define an API that can be used to access resources that are represented as JSON, Atom, RSS, XML, and/or (of course) HTML.

With the recent release of Spring 3.0, the Spring MVC web framework affords many opportunities for building RESTful applications. This includes a new set of annotations to support defining resource-oriented URLs and a new REST client template for consuming RESTful APIs.

By Craig Walls

In this example-driven session we'll see how to swiftly develop Spring applications using Spring Roo. We'll start with an empty directory and quickly work our way up to a fully functioning web application. You'll see how Roo handles a lot of heavy-lifting that you'd normally have to do yourself when working with Spring. And we'll stop at a few scenic points along the way to see how Roo accomplishes some of its magic.

In recent years, rapid application development frameworks such as Rails and Grails have earned a lot of attending. By employing code generation, convention-over-configuration, and the dynamic capabilities of their core languages (Ruby and Groovy) to offer unparalleled productivity, helping get projects off the ground quickly.

As awesome as these frameworks are, they do have one negative mark against them. Although developers love working with them, convincing the "boss" to build mission-critical applications in a relatively new development style based can be difficult. The mere mention of a word like "Groovy" conjures up images of tie-dye shirts and VW vans. Risk-averse project managers often think that free love may have been a big thing in the 70s, but it has no place in serious business.

If psychedelic frameworks are a tough-sell in your organization, then you can still feel much of the same productivity gains while developing Spring applications. Spring Roo mixes Spring and Java with a little code generation and a dash of compile-time AspectJ to achive a rapid development environment that resembles Rails and Grails. But instead of producing Ruby/Rails or Groovy/Grails code that may make your manager twitch, Roo produces Java-based projects that use the Spring Framework--which is already accepted in many organizations.

By Craig Walls

Contrary to what you may have heard, OSGi is neither complex, nor heavyweight. In this session, I'll show you how OSGi can actually simplify application development rather than complicate it. We'll look at the benefits of modularity, the fundamentals of OSGi, and see how to develop basic OSGi bundles. We'll also see how a few gadgets in the OSGi toolbox can ease the development of OSGi bundles.

The secret weapon for attacking complexity in any project is to break it down into smaller, cohesive, and more easily digestible pieces. Unfortunately, Java lacks critical ingredients necessary to achieve true modularity.

Enter OSGi. OSGi is a mature and established framework for dynamic modularity in Java. With OSGi, you'll be able to realize true modularity in your Java projects, making them more flexible, comprehensible, and testable.

By Craig Walls

This session will introduce you to Spring-DM. You'll learn how working with OSGi services can be as easy and as natural as declaring a in Spring. In addition, we'll look at how to use Spring-DM's web extender to develop modular web applications in OSGi. And we'll see how Spring-DM became part of the OSGi specification as Blueprint Services.

OSGi is a great framework for realizing true modularity in your Java applications. Unfortunately, however, working with OSGi services requires coding directly to the OSGi API and getting to know some new patterns for dealing with service availability.

If having to work with the OSGi API makes you feel uneasy, then have a look at Spring Dynamic Modules (aka, Spring-DM). Spring-DM brings a declarative service model to OSGi, relieving you from programatically servicing and consuming services. What's more, because Spring-DM is based on the popular Spring Framework, it brings all of the power of Spring to OSGi development.

Prerequisite: Modular Java: An introduction to OSGi