Aspect Oriented Programming with Spring

2

Topics

• Introducing Spring AOP • Types of AOP • AOP in Spring • Advisors and Pointcuts in Spring • All About Proxies

3

Introduction

• The Spring AOP (Aspect-oriented programming) framework is used to modularize cross-cutting concerns in aspects.

• Put it simple, it’s just an interceptor to intercept some processes, for example, when a method is executed, Spring AOP can hijack the executing method, and add extra functionality before or after the method execution.

4

AOP• Aspect-Oriented Programming (AOP) complements

Object-Oriented Programming (OOP) by providing another way of thinking about program structure.

• key unit of modularity in OOP is the class, whereas in AOP the unit of modularity is the aspect.

• Aspects enable the modularization of concerns such as transaction management that cut across multiple types and objects. (Such concerns are often termed crosscutting concerns in AOP literature.)

• One of the key components of Spring is the AOP framework.

• While the Spring IoC container does not depend on AOP, meaning you do not need to use AOP if you don't want to, AOP complements Spring IoC to provide a very capable middleware solution.

Why AOP?

• Aspect-oriented programming (AOP) provides for simplified application of cross-cutting concerns

• Examples of cross-cutting concerns– Logging– Transaction management– Security– Auditing– Locking– Event handling

6

AOP is used in the Spring Framework

• To provide declarative enterprise services, especially as a replacement for EJB declarative services. The most important such service is declarative transaction management.

• To allow users to implement custom aspects, complementing their use of OOP with AOP.

7

AOP concepts

• Aspect• Join point • Advice • Pointcut • Introduction • Target object• AOP proxy • Weaving

AOP Concepts: Joinpoint

• Well-defined point during the execution of your application

• You can insert additional logic at Joinpoint's• Examples of Jointpoint's

– Method invocation

– Class initialization

– Object initialization

AOP Concepts: Advice

• The code that is executed at a particular joinpoint

• Types of Advice– before advice, which executes before joinpoint– after advice, which executes after joinpoint– around advice, which executes around joinpoint

AOP Concepts: Pointcuts

• A collection of joinpoints that you use to define when advice should be executed

• By creating pointcuts, you gain fine-grained control over how you apply advice to the components

• Example– A typical joinpoint is a method invocation.

– A typical pointcut is a collection of all method invocations in a particular class

• Pointcuts can be composed in complex relationships to further constrain when advice is executed

AOP Concepts: Aspects

• An aspect is the combination of advice and pointcuts

• It is a modularization of a concern that cuts across multiple classes.

• Transaction management is a good example of a crosscutting concern in J2EE applications.

• In Spring AOP, aspects are implemented using regular classes or regular classes annotated with the @Aspect annotation (the @AspectJ style).

AOP Concepts: Weaving

• Process of actually inserting aspects into the application code at the appropriate point

• Types of Weaving– Compile time weaving– Runtime weaving

AOP Concepts: Target

• An object whose execution flow is modified by some AOP process

• They are sometimes called advised object

AOP Concepts: Introduction

• Process by which you can modify the structure of an object by introducing additional methods or fields to it

• You use the Introduction to make any object implement a specific interface without needing the object's class to implement that interface explicitly

15

Spring AOP supports four types of advices

• Before advice – Run before the method execution • After returning advice – Run after the method returns a

result • After throwing advice – Run after the method throws an

exception • Around advice – Run around the method execution,

combine all three advices above.

Types of AOP

• Static AOP– The weaving process forms another step in the build process for an

application

– Example: In Java program, you can achieve the weaving process by modifying the actual bytecode of the application changing and modifying code as necessary

• Dynamic AOP– The weaving process is performed dynamically at runtime– Easy to change the weaving process without recompilation

Spring AOP

• Based on proxies– When you want to create an advised instance of

a class, you must use the ProxyFactory class to create a proxy of an instance of that class, first providing the ProxyFactory with all the aspects that you want to be woven into the proxy

– You typically use ProxyFactoryBean class to provide declarative proxy creation

HelloWorld Spring AOPHelloWorld Spring AOP

MessageWriter Class

• We want to display “Hello World !” through AOP

public class MessageWriter { public void writeMessage() { System.out.print("World"); }

}

Target

• The joinpoint is the invocation of the writeMessage() method

• What we need is an “around advice”

public class MessageWriter{ public void writeMessage() { System.out.print("World"); }

}

Around Advice

• MethodInterceptor is AOP Alliance standard interface for around interface• MethodInvocation object represents the method invocation that is being

advised

import org.aopalliance.intercept.MethodInterceptor;import org.aopalliance.intercept.MethodInvocation;public class MessageDecorator implements MethodInterceptor {

public Object invoke(MethodInvocation invocation) throws Throwable { System.out.print("Hello "); Object retVal = invocation.proceed(); System.out.println("!"); return retVal; }

}

To compile this class, you have to add aopalliance-1.0.jar in classpath

Weaving MessageDecorator Advice

• Use ProxyFactory class to create the proxy of the target object

import org.springframework.aop.framework.ProxyFactory; public static void main(String[] args) { MessageWriter target = new MessageWriter(); // create the proxy ProxyFactory pf = new ProxyFactory();

//Add the given AOP Alliance advice to the tail //of the advice (interceptor) chain pf.addAdvice(new MessageDecorator());

Weaving MessageDecorator Advice

//Set the given object as target pf.setTarget(target);

//Create a new proxy according to the //settings in this factory MessageWriter proxy = (MessageWriter)

pf.getProxy(); // write the messages target.writeMessage(); System.out.println(""); // use the proxy proxy.writeMessage(); }}

For runtime support you have to Add cglib-nodep-2.2.jar file in classpath