Programming Languages
and Paradigms
Aspect Oriented Programming
Introduction
Currently, the dominant programming paradigm is object-
oriented programming that:
has been presented as a technology that can
fundamentally aid software engineering
is reflected in the entire spectrum of current software
development methodologies and tools
Object orientation is a good technique but has certain
limitations
Problems with OOP
OOP has difficulty handling the idea of
cross-cutting concerns
some functionalities(concerns) are meant to
be applied to several locations in your code
This usually results in code being duplicated
E.g. System.out.println() logging
Makes some tasks like disabling the feature
difficult since the code is in several locations
Terminology
Concern – is a particular goal, concept, or area of interest. An
engineering process deals with many concerns. High level vs. low
level, localized vs. system wide.
Crosscutting concerns – concerns that in conventional
implementations cannot be implemented without scattering code.
Code tangling – in conventional environments, implementing
crosscutting concerns is scattered in many modules.
Code scattering
Duplicated code blocks
Complementary code blocks
Cross-Cutting Concerns Visualized:
Logging in Tomcat
(From AspectJ tutorial)
Tracing class TraceSupport {
static int TRACELEVEL = 0;
static protected PrintStream stream = null;
static protected int callDepth = -1;
TraceSupport
static void init(PrintStream _s) {stream=_s;}
static void traceEntry(String str) {
if (TRACELEVEL == 0) return;
callDepth++;
printEntering(str);
}
static void traceExit(String str) {
if (TRACELEVEL == 0) return;
callDepth--;
printExiting(str);
}
class Point { }
void set(int x, int y) {
TraceSupport.traceEntry(“Point.set”);
_x = x; _y = y; Consistent trace
TraceSupport.traceExit(“Point.set”);
}
form but using it
} is cross-cutting...
Other Cross-Cutting Concerns
Systemic
security (authorization and auditing)
logging and debugging
synchronization and transactions
persistence and many more
Functional
business rules and constraints
traversal of complex object graphs
accounting mechanisms (timing and billing)
The Cost of Tangled Code
Redundant code
same or similar fragment of code in many places
Difficult to reason about
non-explicit structure
the big picture of the tangling isn’t clear
Difficult to change
have to find all the code involved
and be sure to change it consistently
and be sure not to break it by accident
AOP: Opening a New Dimension in
Software Development
Object
decomposition
is flatland
A cross-cutting concern is scattered
because it is realized in the wrong
dimension!
concerns
AOP: Opening a New Dimension in
Software Development
Object
decomposition
is flatland
Aspects are
aspect
orthogonal to the
primary decomposition
concerns
Expected Benefits of AOP
Good modularity, even for crosscutting
concerns
less tangled code
more natural code
shorter code
easier maintenance and evolution
easier to reason about, debug, change
more reusable
library aspects
plug and play aspects when appropriate
AOP Basic Concepts
The following are some of the fundamental
ideas in AOP
Aspect
Advice
Joinpoint
Pointcut
Target
Weaving
Aspect
Aspect - Think of this as the general
feature you want to apply globally to your
application
Logging
performance monitoring
exception handling
DB session/transaction management
E.g. Hibernate transaction handling via Spring
Advice
Advice - A chunk of code that is invoked
during program execution, and is a piece
of the logic for implementing your aspect
Different advice types exist, e.g. advise
before joinpoint
after joinpoint
around joinpoint
several others
Joinpoint
Joinpoint - A *single* location in the code
where an advice should be executed
A Joinpoint can represent things such as
access to a specific field
invocations to a specific method
constructor invocation
several others
Pointcut
Pointcut - A pointcut is a set of one or
more joinpoints where a given advice
should be applied to/executed.
Some implementations implement this via
some kind of Regular Expression mechanism to
define class and method signature patterns
Target
Targets/Target Objects - The objects you
want to apply an aspect or set of aspects
to
Most implementations allow a means to
apply an aspect to many target object at
once
Weaving
Weaving is the ability of the AOP
implementation to insert the aspect code
into the specified locations in the system
Weaving can be done at
the compilation level using a special compiler
(either by altering the source code or
generated byte code)
can be done at runtime via special class
loaders
Weaving
There are several types of AOP weaving
Source code based – source code is altered
with the new functionality during the
compilation phase
Byte code enhancement – byte code is altered
by the AOP compiler to add new functionality
JIT-weaving - when the .class is loaded the
data is directly altered by the Java classloader
to add the new functionality
General flow of AOP
1. Separate the actual code that will be applied to different
locations (e.g. logging, session management)
Advice
2. Define “where” the Advice will be applied
Pointcut – which is a set of Joinpoints
3. Let the AOP implementation add your aspect code to the
supplied locations
Weaving
AOP in Java
Over the years, several AOP implementations have been
made
Java Language Extension(new compiler, new keywords,
etc.)
AspectJ – most powerful/complete AOP
implementation for Java
Requires a new compiler to handle new AOP-related
keywords
AOP in Java
Add-on libraries
JBossAOP, SpringAOP, AspectWerkz
Does not alter the Java language (implements AOP
features via new classes or classloaders)
Differing levels of AOP functionality support
For our examples, we will be looking at Spring AOP
References
http://www.onjava.com/pub/a/onjava/20
04/07/14/springaop.html
http://www.javalobby.org/java/forums/t4
4746.html
http://www.onjava.com/pub/a/onjava/20
04/01/14/aop.html
spring-reference.pdf
