Aspect-oriented programming, or AOP, is a programming technique that allows programmers to modularize crosscutting concerns It is often defined as a programming technique that promotes separation of crosscutting concerns with in a software system concerns : A concern is a particular issue, concept, or area of interest for an application: typically, a goal the application must meet

1. Spring AOP
Onkar Deshpande
© Onkar Deshpande
1

2. Agenda
Understanding cross cutting concerns
Need of AOP
Aspect-oriented programming concepts
AOP Terminologies
Implementing aspect behavior
AspectJ APIs and annotations
Spring AOP application
© Onkar Deshpande
2

3. Functional Programming
© Onkar Deshpande
3

4. Object Oriented Programming
© Onkar Deshpande
4

5. Problem in OOP
© Onkar Deshpande
5

6. Object Oriented Solution
© Onkar Deshpande
6

7. Problem in solution provided by OOP
An aspect is scattered or tangled as code
Making it harder to understand and maintain
To many relationship with cross-cutting concerns
OOP creates a coupling between core and
crosscutting concerns. This causes
 Leads to duplicated code
 Hard to maintain code
 Hard to use code
© Onkar Deshpande
7

8. Better Solution
Logging Transaction
Aspect Configuration
© Onkar Deshpande
8

9. Advantages of this approach
Increase the modularity
By allowing separating cross-cutting concerns from
business logic
Making easy to understand and maintain
Spring AOP will take care of calling concerns, we just
need to declare about concerns once in configuration file
 You can focus on the concerns at one place
 Easier to add and remove concerns
 Easier to modify or fine tune concerns
 Easier to understand
 Efficient to implement
 More efficient
© Onkar Deshpande
9

10. What Is AOP
Aspect-oriented programming, or AOP, is a
programming technique that allows programmers to
modularize crosscutting concerns
It is often defined as a programming technique that
promotes separation of crosscutting concerns with in a
software system
concerns :
A concern is a particular issue, concept, or area of
interest for an application: typically, a goal the
application must meet
© Onkar Deshpande
10

11. Cross-cutting concerns
The systems or concerns that tend to cut across multiple
components in a system are referred as Cross-cutting concerns
System wide concerns that span multiple modules.
Cuts across the typical division of responsibility.
Examples such as
 Transaction Management
 Security
 Logging
© Onkar Deshpande
11

12. Cross Cutting Concerns in OOP Cont..
public class Account
{
public void deposit() {
// Transaction Management
// Logging
// Checking for the Privileged User
// Actual Deposit Logic comes here
}
public void withdraw() {
// Transaction Management
// Logging
// Checking for the Privileged User
// Actual Withdraw Logic comes here
}
}
AOP calls this kind of logic that cross-cuts the existing business logic as Cross-Cutting Concerns
© Onkar Deshpande
12

13. AOP vs OOP
Object Oriented Aspect Oriented
Class – code unit that encapsulates
methods and attributes
Aspect – code unit that encapsulates
pointcuts, advice, and attributes
Method signatures – define the entry
points for the execution of method
bodies
Pointcut – define the set of entry
points (triggers) in which advice is
executed
Method bodies – implementations of
the primary concerns
Advice – implementations of the cross
cutting concerns
Compiler – converts source code into
object code
Weaver – instruments code (source or
object) with advice
© Onkar Deshpande
13

14. AOP Terminologies
Terms Description
Aspect A module which has a set of APIs providing cross-cutting
requirements. For example, a logging module would be called
AOP aspect for logging. An application can have any number of
aspects depending on the requirement
Join Point This represents a point in your application where you can plug-in
AOP aspect. You can also say, it is the actual place in the
application where an action will be taken using Spring AOP
framework
Advice This is the actual action to be taken either before or after the
method execution. This is actual piece of code that is invoked
during program execution by Spring AOP framework
Pointcut This is a set of one or more join points where an advice should
be executed. You can specify point cuts using expressions or
patterns as we will see in our AOP examples
© Onkar Deshpande
14

15. AOP Terminologies
Transaction
Advice
Method1 Method2 Method3
Logging
Advisor
Join Point
© Onkar Deshpande
15

16. Types of Advice
Advice Description
before Run advice before the a method execution
after Run advice after the a method execution regardless of its
outcome
after-returning
Run advice after the a method execution only if method
completes successfully
after-throwing
Run advice after the a method execution only if method
exits by throwing an exception
Around Run advice before and after the advised method is invoked
© Onkar Deshpande
16

17. Declaring an aspect
A concern that cuts across multiple classses and
layers
import org.aspectj.lang.annotation.Aspect;
@Aspect
public class LoggingInterceptor
{
// ...
}
© Onkar Deshpande
17

18. Declaring a pointcut
An expression mapped to a join point (method
invocation)
@Aspect
Public class LoggingInterceptor
{
@Pointcut( "execution( * pack.dao.*.*(..) )" )
private void daoLayer()
{
// code
}
}
© Onkar Deshpande
18

19. Pointcut expression pattern
The execution pointcut designator is used most often
© Onkar Deshpande
19

20. Pointcut expression examples
Description Pointcut
Any public method execution( public * *(..) )
Any public method defined
in the dao package
execution( public * pack.dao.*.*(..)
)
Any method with a name
beginning with save
execution( * save*(..) )
Any method defined by the
EventDAO interface with
one param
execution( * pack.dao.EventDAO.*(*)
)
© Onkar Deshpande
20

21. Spring
© Onkar Deshpande
21

22. Thank You
© Onkar Deshpande
22