Aspect-Oriented Refactoring of the Apache Cocoon Shared-Object Resource Allocation System

Jeff Dalton

February 28th, 2003

Advisor: David G. Hannay

Client: Robert Berry, IBM UKArthur Octopus

The AspectJ Mascot

Agenda

AOP & Cocoon Background

Refactoring Goals & Process

Challenges and Obstacles

The Future

What is Aspect Oriented Programming?

Concern – “a specific requirement or consideration that must be addressed in order to satisfy the overall system goal.”

AOP introduces a new unit of modularization—an aspect–that crosscuts other modules.

Aspect = pointcut + advice + intertype declaration– intertype declaration

Fields and methods that the aspect manages on behalf of other types

- The Java AOP implementation

A Cross-cutting concern

• Logging in org.Apache.Tomcat- Red shows lines of code that handles logging

- Not in one place. Not in a small number of places.

Apache Cocoon: Dynamic multi-channel web publishing

“Apache Cocoon is a web development framework built around the concepts of separation of concerns and component-based web development.”

– Cocoon website

Usage example:– Take data from a database and publish the content onto a web portal in HTML,

PDF, Office format, and text format all simultaneously.

Performance as crosscutting concern

Performance optimizations: Caching & Pooling– Effective techniques to improve performance

Caching – recycling of resources that are expensive to create and discard where more than one user can use a single object

– “Read only”– A.K.A. – “Shared Object Resource Allocation”

Cocoon Caching Architecture

Caching happens at the pipeline level with each different phase of the transformation being cached, if possible.

Caching

Cocoon Caching Architecture

SAX events and caching management is done in a central location: CacheManager

However, to be cached the classes must implement the abstract interface ...cocoon.caching.CacheableProcessingComponent

Two methods to be implemented:– Serializable generateKey();– SourceValdity generateValidity();

Refactoring Cocoon Caching

The Challenge: – Implementing the CacheableProcessingComponent and its methods

is the crosscutting concern, we need to abstract it.

Accomplished through– Introductions – in AspectJ “Intertype Declarations”

The addition of methods, fields, interfaces, or inheritance information that does not directly affect the class’s behavior

Simple in concept, not trivial in practice.– Large, complex web application (~4600 class files with all blocks)

AOP Adoption

Val

ue

Development Support forExisting Code

• 15 minutes• 30 lines• unpluggable• testing• tracing• performance measurement

• limited use• design• error handling• standards & contracts• monitoring

AddAuxiliaryFunctionality

Re-factor CoreFunctionality

ReusableLibraries

Aspect-OrientedArchitecture

• module design• persistence• management• security• feature variations

• aspect libraries• design patterns• enterprise, department standards

• new services, programming model• product lines• extend J2EE• Web services, mobile, P2P...

Goals

Project Task– Refactor the caching system in Cocoon

Goals- Gain experience with application of AOP to a large scale, well

structured application environment.

- Identify and quantify opportunities for using AOP to simplify an already modular code base.     

- Use AOP to enhance modularity/componentization of Cocoon.

Process: Approach

1. Used AspectJ to define a compiler warning in order to identify locations in Cocoon that implement the CacheableProcessingComponent abstract interface.

2. Wrote aspects to encapsulate the functionality.

3. Removed the code encapsulated into aspects from the base classes identified in step 1.

4. Wove the aspects into Cocoon using AspectJ compiler.

Step 1: Identify Locations

public aspect ExploreCaching {

declare warning: staticinitialization(org.apache.cocoon.caching.CacheableProcessingComponent+) && !within(org.apache.cocoon.caching..*): "Class implements cacheable";

}

Step 2: Write Caching Aspects

Excerpt:

privileged public aspect CachingAspect {

/* Ascii art generator */ declare parents: org.apache.cocoon.generation.asciiart.AsciiArtSVGGenerator implements

CacheableProcessingComponent;

public Serializable org.apache.cocoon.generation.asciiart.AsciiArtSVGGenerator.generateKey() {

return this.inputSource.getURI(); }

public SourceValidity org.apache.cocoon.generation.asciiart.AsciiArtSVGGenerator.generateValidity(){

return this.inputSource.getValidity(); } ….

Introduce Interface

Introduce Methods

Step 3 & 4: Remove References & Weave

Code Removed

Testing & Verification

Finished:– Cocoon without caching deployed

In process– Integrating AspectJ Compiler into build process

Challenges & Obstacles

Domain knowledge is the biggest challenge– Ex. Cache (external pipeline cache) vs. Store (Internal Object cache)

Eclipse AspectJ Development Tools (1.1.4)– Scalability issues: over 4600 classes in Cocoon– Bug: Memory Leak (Fix coming in 1.2 – ‘Lancaster’)

– Bug: Abstract class that extend abstract class with concrete subclasses are woven too early - (Fixed in 1.1.6)

Ongoing modifications to cocoon caching system

Future work

Use AOP to refactor the ‘internal cache’

Refactor other non-performance crosscutting concerns into aspects

– Object Recycling, Logging, etc…

An event-aware AOP caching system– Use AOP to catch SAX events and perform cache

invalidations

The Future: AOP

New versions, better tools– AspectJ 1.2 – “Lancaster” for Eclipse 3.0

– “Aspect Mining” – Better ways towards aspect discovery Concern Modeling Environment

– http://www.eclipse.org/cme/– “To general software developers it offers a suite of tools for use in creating,

manipulating, and evolving aspect-oriented software, across the full software lifecycle”

– IBM Watson Lab – Yorktown Heights Aspect Mining Tool More work to be done: AI and pattern recognition

– AOSD 2004 in Lancaster, UK, March 22-25th

Results I

Question– How should you structure your application to simplify AO extendibility?

Answer– Good coding practice makes AO adoption easier

Standard variable naming Standard accessor methods

Question– How can we improve the AO implementation?

Answer– Refactor ‘similar’ code to remove differences

Question– How should aspects be viewed on a design level?

Answer– Still open!

Results II

Summary:

Abstracted 39 implementations of CacheableProcessingComponent.

Used AOP to condense and remove 24 methods from the base implementation.

Example: Duplicate code:

public Serializable org.apache.cocoon.transformation.LexicalTransformer.generateKey() {

return this.lexiconSource.getURI();}public Serializable

org.apache.cocoon.transformation.ParserTransformer.generateKey() {return this.grammarSource.getURI();

}

Questions

Oliver the Octopus

Concept and name credited to:

AspectJ team, IBM Hursley, UK

AOP: The here, the now, and the future!