Spring AOP

Aspect Oriented programming in Spring: In Spring environment Aspects are nothing but
Middleware services. Spring AOP is methodology of applying Middleware services on our
Spring applications where Middleware services will be developed separately and will be linked
with Spring Beans either through Annotations or XML files. Middleware services are additional
and optional logics that can be applied on our applications to make our applications running
smoothly and perfectly.
EX: logging (keeps track of the application flow of execution)
Transaction Management applies do ever thing and nothing principle on sensitive logics.
Q) What is the difference between OOP and AOP?
Spring AOP is no way related with OOP because OOP is methodology of creating programming
languages. AOP is the methodology of applying middleware services on the Spring applications.
Logging Service
Transaction Management
Service
Security Service
Project1 Project2 Project3
Module1 (Student Module)
Module2 (Faculty Module)
Module3 (Admin Module)
In Spring AOP Middleware services are also called as Aspects or cross cutting concerns because
they reside outside the application logics but will executed along with the application logics.
For example scenario that talks about need of Spring AOP refer 100 to 102
Instead of writing Middleware service logics directly with application code it is
recommended to separate them from application code and apply them on application code using
XML, Annotations by taking the support of Spring AOP.
AOP Terminologies:
1. Aspect

2. Advice
3. Advisor
4. Point cut
5. Wiring
6. Weaving
7. Joint Point
8. Target Object
9. Proxy Object.
Logging Security Transaction management
(Advice1) (Advice2) (Advice3)
Point Cut Point Cut Point Cut Point Cut
Business Method Excution
JP1 JP1 JP1
Here JP represents Joint Point
1. Aspect: Contains the plan of implementing Middleware Service
2. Advice: It is the practical implementation of Middleware Services. The position in
business methods where advices are configured are called as Joint Point
EX: Beginning of the business methods, end of the business methods. Exception is resided in
the business method and etc., The XML or Annotation configurations that are used to link
advices with Joint Points are called Point Cuts.
3. Advisor: It is a combination of Advisor + Joint Point + Point Cut.

4. Wiring: The process of configuring bean properties for dependency injection is called
the process of configuring advices/Middleware services/Aspects on bean class business
methods is called as Weaving. The bean class object which we are planning to apply
Middleware services (but not apply) is called Target object.
Note: All Spring Bean objects are Target Objects by default.
Proxy Objects: It is Spring Bean object on which Middleware services are applied. If we
call business methods on Target object only business logic will be executed. If we call
business methods on Proxy Object the business logic will be executed along with
Middleware services. Generally we never apply Middleware services in small scale project
development. While we apply Middleware services in medium and large scale projects.
1. Programmatic Approach: keeping the logic of applying Middleware services as Java
statements directly in the applications (not recommended).
EX: problem scenario given in page no: 100
2. Declarative Approach: Middleware services will be applied on the applications either
through XML statements or through Annotations.
EX: All Spring AOP applications
There is possibility of developing four types of advices those are
i. BeforeAdvice (Executes at the beginning of the business method)
ii. AfterAdvice (executes at the end of the business method)
iii. ThrowsAdvice (executes when the business method throws an exception)
iv. Around Advice ( executes at beginning end at the end of business method)
For related information on different types of advices refer page numbers 104-106.
Spring AOP supports only method level Aspect oriented programming that means it does not
support Field level Aspect oriented programming.
Spring beans borrowed AOP fecilities from Alliance company but entire API is inbuilt of
Spring software.
Advice: Advice is the code that implements the Aspect.. In general an Aspect defines the
functionality in a more abstract manner. But, Advice that provides a Concrete Implementation
for the Aspect.

Example on AroundAdvice:
Public class MyAdvice implements MethodInterceptor
{
Public Object invoke(MethodInvocation i1) throws Exception
{
-------
-------- //executes at method beginning of the Method
--------- //executes business method
I1.process() //executes at the end of the business smethod.
----------------
--------------
Creating Advices in Spring:
There are four types of Advices available in Spring those are
1. Before Advice
2. After Advice
3. Throws Advice
4. Around Advice
1. BeforeAdvice: Before Advice is used to intercept before the method execution starts. In
AOP, Before Advice is represented in the form of
org.springframeword.aop.BeforeAdvice. For example a sytem makes security checks
before allowing then to accesing resources. In such a case, we can have a Before Advice
that contains code which consider the following piece of code.
EX:
Public class Authentication implements MethodBeforeAdvice // Here MethodBefore Advice
is manadatory to make the Java class BeforeAdvice
{
Public void beforeMethod method, Object[] args, Object target) throws Throwable
{

place the Authentication logic here.
}
}
Above class extends BeforeAdvice, there by telling before method will be called before the
execution of the method call. Note that the java.lang.reflect.Method method object represents
target method to be invoked, Object[] args refers to the various arguments that are passed on
the method and target refers to the object which is calling the method.
2. AfterAdvice: AfterAdvice will be useful if some logic has to be executed before running
the control with in a method execution. This advice is represented by the interface
org.springframework.aop.AfterReturningAdvice. For example, it is common in
Application to Delete the Session data and the various information pertaining to a user,
after he has logged out from the Application. These are ideal candidates for After Advice.
EX: CleanUpOperatoin.java
Public class CleanUpoperation implements AfterReturningAdvice
{
Public void afterReturningObject returnValue, Method method, Object[] arg, Object target
throws Throwable
//Here afterReturning method re[resents the retun value given by the business method.
{
//clean up session and user information
}
}
Note that, afterReturning) method will be called once the method returns normal execution.
If some exception happedns in the method execution the afterReturning method will never be
called.
3. Throws Advice: //represents the exception raised in the business method.
When some kind of exception happens during the execution of a method, then to handle the
exception properly, Throws Advice can be used through the means of
org.springframework.aop.ThrowsAdvice. Note that this interface is a marker interface.

EX:
Public void afterThrowingException ex
{
Public void afterThrowingMethod method, Object[] args, Object target, Exception exception
//here afterThrowing method represents the exception raised in the business method.
AroundAdvice: The Advice is very different from the other types of the advices because of
the fact that, the Advice provides finer control whether the target method has to be called or
not. Considering the above advices, the return type of the method signature is always
meaning that, the Advice that can’t change the return arguments off the brand new object of
other type if needed.
Consider the following code
Public void relateObject o, Object o
{
O1.establishRelationo2);
}
Assume that we have a method that provides an Association llink between two objects, but
before that, we have to ensure the type fo objects being passed must conform to a standard,
by implementing some interfaces. We can have this arguments check in the Around Advice
rather that having it in the actual method implementation. The Around Advice is represented
by org.aopalliance.intercept.MethodInterceptor.
ValidateArguments.java
Public class ValidateArguments implements MEthodInterceptor
{
Public Object invoke(MethodInvocation invocation throws Throwable
{
Object arguments[]=invocation.getArguments
Ifarguments[]instance of Parent)&&arguments[] instanceof Child))

{
Object returnValue=invocation.proceed;
Return returnValue;
}
Throw new Exception”Arguments are of wrong yet”;
}
}
In the above code, the valiudation happens the arguments to check whether they implement
the right interface. It is important to make a call to MethodInvocation.proceed, if we happy
with the arguments validation, else the target method will never gets invoked.
Note: Based on the type of the advice we choose the JointPoint positions in the Business method
will be decided automatically.
To apply advices they are
i. NamedMatchMethodPointAdvisor: applies the advices based on the business method
names.
ii. RegexMethodPointAdvisor: Applies the advices based on the given regular
expression symbol
For related information on Pointcut advisors refer page numbers 107 to 109.
Procedure to develop Spring AOP style application with Advices:
1. Develop Spring interface having declaration of business smethods.
2. Develop Spring Bean class having implementation of business methods with business
logic.
3. Develop Advice class having Middleware service logic.
4. Develop the Spring configuration file to configure Spring Bean.
a) Cfg file.
b) Cfg Advice class

c) Cfg Advisor (NamedMatch/Regurlar expression specifying class bean id and business
method)
d) Cfg org.springframework.ProxyFactoryBean specifying target object id, Advisor Bean.
Note: The ProxyFactoryBean class converts given Spring Bean class object to Proxy object and
returns that object.
Note: When business methods are called on Proxy object the business logic will be executed
along with Advices.
5. Develop the Client Application to getProxy object and call business methods on the
Object.
Example Application on Spring AOP having the user defined advice.
Develop the following resources in the Application.
1. . MyAdviceBefore Advice)
2. MyAdviceSpring interface
3. DemoBean.java(SpringBean class
4. ClientApp(ClientApp)
5. Spring.cfg.xmlSpring configuration file
For complete program please refer E:\Frameworks\Spring\Spring AOP\NetBeans 7.1
projects\RegexpMethodPointcutAdvisor(MethodBeforeAdvice)
For more related examples on Around Advice based Sprig AOP refer following folders.
For demonstrating the behavior of Around Advice
For complete program please refer E:\Frameworks\Spring\Spring AOP\NetBeans 7.1
projects\NamedMatchMethodPointcutAdvisor(MethodBeforeAdvice) folder
For How to Change the retrun value
For Complete program please refer E:\Frameworks\Spring\Spring AOP\NetBeans 7.1
projects\BaseOnReturnValue folder
Modifying Buiness method argument values
For complete program please refer E:\Frameworks\Spring\Spring AOP\NetBeans 7.1
projects\ModifyingBusinessMethodArgsBaseOnReturnValue folder