Spring AOP

Aspect-Oriented Programming (AOP) is one of the key elements of the Spring Framework. AOP
praises Object-Oriented Programming in such a way that it also provides modularity.
But the key point of modularity is the aspect than the class. AOP breaks the program logic into
separate parts called concerns.
The functions that span multiple points of a web application are named cross-cutting concerns
and these cross-cutting concerns are conceptually separate from the application's business logic.
AOP aims to increase modularity by allowing the separation of cross-cutting concerns.
A cross-cutting concern is a type of concern that has the power to impact the entire web
application and should always be centralized in one location in the program as possible.
It accomplishes this task by adding extra behavior to existing code without modifying and
changing the code of the software.
We can declare the new code and the new behaviors separately as per our software requirements.
Spring's AOP framework helps us to implement these cross-cutting concerns for our web
applications.
There are various common useful examples of aspects in software development like logging,
auditing, declarative transactions, security, caching, etc.
The key unit of modularity in OOP is the class, whereas in AOP the unit of modularity is the aspect.
Dependency Injections are the ones that are responsible for decoupling our application objects
from each other and AOP allows you to decouple cross-cutting concerns from the objects that they
affect in the development process.
AOP is more like a trigger in programming languages such as Perl, .NET, Java, and others.
Spring AOP module has some useful features like it provides interceptors to intercept an
application.
For example, when a method is executed in a system, then you can also add extra features and
functionality before or after the method has been executed.

Why Should We Use Spring AOP in Our Software Development?

• It can be used to provide declarative enterprise services such as declarative transaction
management for a particular organization or software.
• It allows users to implement custom elements. These elements can be really helpful for
adding some additional features and functionalities that were not present in the software
at the beginning.

Maven Dependencies
There are some dependencies that are needed to be added in the Spring's AOP library.
Spring core
Spring context
Spring aop
aspectjrt(aspectj runtime)
aspectjweaver

AOP Concepts
Let us begin by defining some central AOP concepts and terminology. These terms are not Spring-
specific. Unfortunately, AOP terminology is not particularly intuitive. However, it would be even
more confusing if Spring used its own terminology.

Aspect: A modularization of a concern that cuts across multiple classes. Transaction

management is a good example of a crosscutting concern in enterprise Java applications. In Spring
AOP, aspects are implemented by using regular classes (the schema-based approach) or regular
classes annotated with the @Aspect annotation (the @AspectJ style).

Join point: A point during the execution of a program, such as the execution of a method or
the handling of an exception. In Spring AOP, a join point always represents a method execution.

Advice: Action taken by an aspect at a particular join point. Different types of advice include
"around", "before", and "after" advice. Many AOP frameworks, including Spring, model an advice
as an interceptor and maintain a chain of interceptors around the join point.

Pointcut: A predicate that matches join points. Advice is associated with a pointcut expression
and runs at any join point matched by the pointcut (for example, the execution of a method with
a certain name). The concept of join points as matched by pointcut expressions is central to AOP,
and Spring uses the AspectJ pointcut expression language by default.

Introduction: Declaring additional methods or fields on behalf of a type. Spring AOP lets you
introduce new interfaces (and a corresponding implementation) to any advised object. For
example, you could use an introduction to make a bean implement an IsModified interface, to
simplify caching. (An introduction is known as an inter-type declaration in the AspectJ
community.)
Target object: An object being advised by one or more aspects. Also referred to as the "advised
object". Since Spring AOP is implemented by using runtime proxies, this object is always a proxied
object.

AOP proxy: An object created by the AOP framework in order to implement the aspect contracts
(advise method executions and so on). In the Spring Framework, an AOP proxy is a JDK dynamic
proxy or a CGLIB proxy.

Weaving: linking aspects with other application types or objects to create an advised object.
This can be done at compile time (using the AspectJ compiler, for example), load time, or at
runtime. Spring AOP, like other pure Java AOP frameworks, performs weaving at runtime.

Spring AOP includes the following types of advice:

Before advice: Advice that runs before a join point but that does not have the ability to prevent
execution flow proceeding to the join point (unless it throws an exception).

After returning advice: Advice to be run after a join point completes normally (for example,
if a method returns without throwing an exception).

After throwing advice: Advice to be run if a method exits by throwing an exception.

After (finally) advice: Advice to be run regardless of the means by which a join point exits
(normal or exceptional return).

Around advice: Advice that surrounds a join point such as a method invocation. This is the
most powerful kind of advice. Around advice can perform custom behaviour before and after the
method invocation. It is also responsible for choosing whether to proceed to the join point or to
shortcut the advised method execution by returning its own return value or throwing an
exception.

Around advice is the most general kind of advice. Since Spring AOP, like AspectJ, provides a full
range of advice types, we recommend that you use the least powerful advice type that can
implement the required behaviour. For example, if you need only to update a cache with the return
value of a method, you are better off implementing an after returning advice than an around
advice, although an around advice can accomplish the same thing. Using the most specific advice
type provides a simpler programming model with less potential for errors. For example, you do
not need to invoke the proceed() method on the JoinPoint used for around advice, and, hence, you
cannot fail to invoke it.

All advice parameters are statically typed so that you work with advice parameters of the
appropriate type (e.g. the type of the return value from a method execution) rather than Object
arrays.
The concept of join points matched by pointcuts is the key to AOP, which distinguishes it from
older technologies offering only interception. Pointcuts enable advice to be targeted
independently of the object-oriented hierarchy. For example, you can apply an around advice
providing declarative transaction management to a set of methods that span multiple objects
(such as all business operations in the service layer).

Steps for AOP project

Make Sure that you have an Internet Connection
Step1:create a New Maven Project
Step 2: Select Archtype as quickstart 1.1
Step 3: Enter Group ID as com.app
Step 4:Enter Artifact id as aopconcept
Step 5: Enter package name as com.aop

Step 6:Apply all dependencies in given file

pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.aop</groupId>
<artifactId>aopconcept</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>aopconcept</name>
<url>http://maven.apache.org</url>

<properties>
 <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<dependencies>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.3.5.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.5.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>4.3.5.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjrt -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.9.6</version>

</dependency>
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
 <artifactId>aspectjweaver</artifactId>
<version>1.9.6</version>

</dependency>

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>

</dependencies>
</project>

Step 7: create interface as PaymentService; enter correct

package name from code given below
package com.aop.services;
public interface PaymentService
{
public void makePayment(int amount);
}

Step 8 :create class as PaymentServiceImpl.java; enter correct

package name from code given below
package com.aop.services;

public class PaymentServiceImpl implements PaymentService

{

public void makePayment(int amount)

{
//payment code

System.out.println(amount+"Amount Debited");
 //
//
//
System.out.println(amount+"Amount Credited");
}

Step 9:Right click on com.aop package and create xml file as

config.xml

Config.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
">
<aop:aspectj-autoproxy />

<bean name="payment" class="com.aop.services.PaymentServiceImpl" />

<bean name="myAspect" class="com.aop.aspect.MyAspect"/>

</beans>

Step 10:Make changes in App.java from package com.aop as code

given below
App.java
package com.aop;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.aop.services.PaymentService;
public class App
{
public static void main( String[] args )
{
ApplicationContext context=new ClassPathXmlApplicationContext("com/aop/config.xml");
PaymentService paymentObject=context.getBean("payment",PaymentService.class);
paymentObject.makePayment(123);

}
}

Step 11:Create new Class as MyAspect inside package

com.aop.aspect as code given below

MyAspect.java
package com.aop.aspect;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class MyAspect
{
/* star(*) means any return type*/
@Before("execution(* com.aop.services.PaymentServiceImpl.makePayment(..))")
public void printBefore()
{
System.out.println("Payment started");
}

@After("execution(* com.aop.services.PaymentServiceImpl.makePayment(..))")
 public void printAfter()
{
System.out.println("Payment success");
}
}

Step 12:Run App.java file as Java Application and check the output