Spring Boot AOP After Throwing Advice

After throwing is an advice type in Spring AOP. It ensures that an advice runs if a method throws an exception. We use @AfterThrowing annotation to implement the after throwing advice.

Syntax:

Where:

PointCut: It selects a function.

execution(expression): It is an expression on which advice is to be applied.

throwing: The name of the exception to be returned.

Let's implement the after throwing advice in an application.

Spring Boot After Throwing Advice Example

We will use the previous example in this section. You can download the project or make some modifications in the previous example.

Spring Boot After Throwing Advice Example

Step 1: Open Spring Initializr http://start.spring.io.

Step 2: Provide the Group name. We have provided the Group name com.javatpoint.

Step 3: Provide the Artifact Id. We have provided the Artifact Id aop-after-throwing-advice-example.

Step 4: Add the Spring Web dependency.

Step 5: Click on the Generate button. When we click on the Generate button, it wraps all the specifications in a jar file and downloads it to the local system.

Step 6: Extract the downloaded jar file.

Step 7: Import the folder by using the following steps:

File -> Import -> Existing Maven Projects -> Next -> Browse the Folder aop-after-throwing-advice-example -> Finish.

Step 8: Open the pom.xml file and add the following AOP dependency. It is a starter for aspect-oriented programming with Spring AOP and AspectJ.

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
</dependencies>

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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.javatpoint</groupId>
<artifactId>aop-after-throwing-advice-example</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>aop-after-throwing-advice-example</name>
<description>Demo project for Spring Boot</description>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.2.2.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>

Step 9: Create a package with the name com.javatpoint.model in src/main/java folder.

Step 10: Create a class with the name Account in the package com.javatpoint.model.

In the Account class, do the following:

Defined two variables accountNumber and accountType of type String.
Right-click on the file -> Source -> Generate Constructor using Fields
Generate Getters.
Right-click on the file -> Source -> Generate Getters and Setters -> Select Getters -> Generate
Generate a toString()
Right-click on the file -> Source -> Generate toString()

Account.java

package com.javatpoint.model;
public class Account 
{
private String accountNumber;
private String accountType;
public Account(String accountNumber, String accountType) 
{
super();
this.accountNumber = accountNumber;
this.accountType = accountType;
}
public String getAccountType() 
{
return accountType;
}
public String getAccountNumber() 
{
return accountNumber;
}
@Override
public String toString()
{
return "Account [accountNumber=" + accountNumber+ ", accountType=" + accountType + "]";
}
}

Step 11: Create another package with the name com.javatpoint.service.impl.

Step 12: In this package, create a class with the name AccountServiceImple.

In this class, we have defined account service.

AccountServiceImpl.java

package com.javatpoint.service.impl;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.springframework.stereotype.Service;
import com.javatpoint.model.Account;
@Service
public class AccountServiceImpl implements AccountService 
{
//storing account detail in the HashMap
private static Map<String,Account> map = null;
static
{
map = new HashMap<>();
//adding account detail in the map
map.put("M4546779", new Account("10441117000", "Saving Account"));
map.put("K2434567", new Account("10863554577", "Current Account"));
}
@Override
public Account getAccountByCustomerId(String customerId) throws Exception
{
if(customerId ==null)
{
throw new Exception("Invalid! Customer Id");
}
Account account= null;
Set<Entry<String, Account>> entrySet = map.entrySet();
for (Entry<String, Account> entry : entrySet) 
{
if(entry.getKey().equals(customerId))
{
account= entry.getValue();
}
}
return account;
}
}

Step 13: Create an interface with the name AccountService in the package com.javatpoint.service.impl.

AccountService.java

package com.javatpoint.service.impl;
import com.javatpoint.model.Account;
//creating interface that throws exception if the customer id not found 
public interface AccountService 
{
public abstract Account getAccountByCustomerId(String customerId)
throws Exception;
}

Step 14: Create a package with the name com.javatpoint.aspect.

Step 15: Create a class with the name AccountAspect in the package com.javatpoint.aspect.

In this class, we have implemented the after throwing advice by using the annotation @AfterThrowing. We have also defined a method afterThrowingAdvice() method.

Note: The name (ex) that we define in the throwing attribute must correspond to the name of a parameter in the advice method. Otherwise, advice will not run.

AccountAspect.java

package com.javatpoint.aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class AccountAspect 
{
//implementing after throwing advice	
@AfterThrowing(value="execution(* com.javatpoint.service.impl.AccountServiceImpl.*(..))",throwing="ex")
public void afterThrowingAdvice(JoinPoint joinPoint, Exception ex)
{
System.out.println("After Throwing exception in method:"+joinPoint.getSignature());
System.out.println("Exception is:"+ex.getMessage());
}	
}

Step 16: Open the AopAfterThrowingAdviceExampleApplication.java file and add an annotation @EnableAspectJAutoProxy.

The annotation enables support for handling components marked with AspectJ's @Aspect annotation. It is used with @Configuration annotation.

We have used the proxyTargetClass attribute of the annotation @EnableAspectJAutoProxy. The attribute proxyTargetClass=true allows us to use CGLIB (Code Generation Library) proxies instead of the default interface-based JDK proxy approach.

ConfigurableApplicationContext is an interface that provides facilities to configure an application context in addition to the application context client methods in the ApplicationContext.

AopAfterThrowingAdviceExampleApplication.java

package com.javatpoint;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import com.javatpoint.model.Account;
import com.javatpoint.service.impl.AccountService;
import com.javatpoint.service.impl.AccountServiceImpl;
@SpringBootApplication
//@EnableAspectJAutoProxy annotation enables support for handling the components marked with @Aspect annotation. It is similar to tag in the xml configuration.
@EnableAspectJAutoProxy(proxyTargetClass=true)
public class AopAfterThrowingAdviceExampleApplication
{
public static void main(String[] args)  
{
ConfigurableApplicationContext ac = SpringApplication.run(AopAfterThrowingAdviceExampleApplication.class, args);
//Fetching the account object from the application context
AccountService accountService = ac.getBean("accountServiceImpl", AccountServiceImpl.class);
Account account;
try 
{
//generating exception
account = accountService.getAccountByCustomerId(null);
if(account != null)
System.out.println(account.getAccountNumber()+"\t"+account.getAccountType());
} 
catch (Exception e) 
{
System.out.println(e.getMessage());
e.printStackTrace();
}
}
}

After creating all the class and packages, the project directory looks like the following: