Nick Lesiecki

Presentations

AOP Applied, lessons from a J2EE project

Aspect Oriented Programming offers enhanced modularity and cleaner separation of crosscutting concerns. That's all fine and well for architecture geeks. But can it help your project today? Has anyone applied it in the real world? The answer is "yes," and in this session, an AOP expert and early adopter will demonstrate how his team used aspect oriented programming to implement non-trivial business concerns. Along the way attendees will learn about advantages of AOP and understand some of the problems encountered adopting it.

This session will give an overview of how the Adbase team at VMS (http://vmsinfo.com) brought AspectJ into a J2EE data integration project. It will start with showing how aspects provided a clean way to debug errors in a third party library. A more complex example will illustrate how AOP helped dynamically update shopping cart prices without requiring extensive modifications to the domain objects. Finally, the class will cover one of the first reusable aspects developed by the company—an aspect to manage relationships between persistent objects. The last part of the presentation will examine the challenges of and tactics for AOP adoption. Attendees will learn what compromises were necessary, how the team scaled the learning curve, and which development practices helped ease adoption and mitigate risk.

Introduction to Enterprise Aspect-Oriented Programming with AspectJ

Aspect-oriented programming (AOP) promises to revolutionize the practice of development by cleanly modularizing behavior that would otherwise scatter across entire programs. Because of this, it continues to gain momentum in the area of enterprise development, with support announced by IBM, BEA, JBoss, Spring, and others. Behind the headlines, however, are critical questions:

• How real is AOP?
• What problems can it solve today?
• How does it apply to enterprise applications?
• How can prospective adopters make an informed decision about trying to use AOP?
• What is the best adoption strategy?
• What are the long term possibilities?
• What standards are emerging?

This tutorial answers these questions and gives attendees the understanding they need to better evaluate AOP by showing AOP solutions to real problems in enterprise development. The first half of the tutorial focuses on AOP basics. Attendees will learn about the motivation for AOP and the sorts of problems that it aims to address. The first session also covers AspectJ syntax and key concepts. The second half of the tutorial presents examples of AOP applied to a range of problems in enterprise Java development, such as publishing business events, security, error handling, declarative transactions, and systems management.

Attendees gain a practical understanding of how AOP works, how it can be useful, and how to work effectively with AspectJ. Attendees learn AOP concepts, design patterns, and are in a good position to start applying the technology.

Goals/Key Points:

• Understand the case for AOP o Know what is meant by a crosscutting concern o See examples of concerns that are difficult to implement with OO • Review a "side by side" example of implementing a business concern (customer billing) with AOP and without • Gain an understanding of basic AOP concepts o Join points o Pointcuts o Advice o Static crosscutting • Master the AspectJ syntax to required to realize the above concepts in code • See how to write reusable aspects that can be re-applied to different problems • Review concrete examples of AOP in action in the following enterprise problem domains o Development-time  Tracing  Architectural policy enforcement with declare error and warning o Infrastructure  System management with JMX  Performance management (including caching strategies)  Error handling: how to implement a consistent error-handling policy across application layers  Declarative transactions, use them without a J2EE container o Domain specific  Security: going beyond the simplistic J2EE model with data-based security  Applying aspects to a specific business problem • Look at the future of AOP o Other frameworks and tools o Impact of Java 5 o Standardization?

Enhance Design Patterns with AOP

Design patterns have long been part of the experienced developer's tool chest. However, design patterns can affect multiple classes and this makes them invasive and hard to (re)use. This presentation will discuss how AOP solves this problem by fundamentally transforming pattern implementation. The class will examine examples of various traditional design patterns (including some of the famous GoF patterns) and discuss the practical and design benefits of implementing them with aspect-oriented techniques. This session will be of interest to anyone who has struggled with design patterns. It is also the perfect session for a programmer interested non-trivial applications of AOP, or who wishes to see aspect-oriented design in action.

Goals/Key Points:

• Review design patterns: what they are, how they can be thought of
• How AOP can affect pattern implementation
• Review AOP key concepts and AspectJ syntax
• The Decorator Pattern, in Java, then AspectJ
• Apply more advanced AOP to the Swing Thread Safety patter
• How to reuse open source pattern implementations (Observer)