Tuesday, 4 December 2018

Spring AOP AspectJ throws Advice example using XML configuration | Spring Tutorial

Implementing Spring AOP AspectJ Throws Advice with XML Configuration

🔔 SUBSCRIBE TO RAM N JAVA FOR DAILY TECH TIPS!

What is Throws Advice in Spring AOP?

In Spring Aspect-Oriented Programming (AOP), Throws Advice is a type of "after advice" that only runs if a method exits by throwing an exception. It is incredibly useful for centralized error handling, logging specific failure details, or even triggering notification systems when something goes wrong in your application.

How to Configure it Using XML

While modern Spring often uses annotations, many enterprise systems still rely on XML configuration. To implement Throws Advice with XML, you define your aspect as a standard bean and then use the section to map it.

Step-by-Step Implementation

The Target Method: Create a service (like an Employee Service) that purposefully throws an exception under certain conditions.
The Aspect Class: Create a Java class with a method designed to catch the exception details.
XML Setup: Use the tag. You specify the pointcut (where the advice applies) and the method in your aspect class that should handle the error.

Why Use Throws Advice?

Instead of cluttering every single method with try-catch blocks, you can define one "Throws Advice" globally. This keeps your business logic clean and ensures that every error is handled or logged in a consistent way across your entire project.

Explore More Spring AOP Tutorials from Ram N Java:

Click here to watch on Youtube:
https://www.youtube.com/watch?v=dbrPfxCCS48&list=UUhwKlOVR041tngjerWxVccw

Click the below Image to Enlarge:

Spring AOP AspectJ throws Advice example using XML configuration | Spring Tutorial

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/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.ram.core</groupId>

    <artifactId>SpringDemo</artifactId>

    <packaging>jar</packaging>

    <version>1.0-SNAPSHOT</version>

    <name>SpringDemo</name>

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

    <properties>

        <spring.version>5.0.5.RELEASE</spring.version>

    </properties>

    <dependencies>

        <dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <version>3.8.1</version>

            <scope>test</scope>

        </dependency>

        <!-- Spring 5 dependencies -->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-core</artifactId>

            <version>${spring.version}</version>

        </dependency>

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-context</artifactId>

            <version>${spring.version}</version>

        </dependency>

        <!-- Spring AOP + AspectJ -->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-aop</artifactId>

            <version>${spring.version}</version>

        </dependency>

        <dependency>

            <groupId>org.aspectj</groupId>

            <artifactId>aspectjrt</artifactId>

            <version>1.9.1</version>

        </dependency>

        <dependency>

            <groupId>org.aspectj</groupId>

            <artifactId>aspectjweaver</artifactId>

            <version>1.9.1</version>

        </dependency>

    </dependencies>

</project>

EmployeeService.java

package com.ram.service;

public class EmployeeService

{

    public String addEmployee()

    {

        System.out.println("addEmployee() is called");

        String name = null;

        name.toLowerCase();

        return "Employee Peter information is added successfully";

    }

    public void modifyEmployee()

    {

        System.out.println("modifyEmployee() is called");

    }

    public void deleteEmployee()

    {

        System.out.println("deleteEmployee() is called");

    }

}

LoggingAspect.java

package com.ram.Aspect;

import org.aspectj.lang.JoinPoint;

public class LoggingAspect

{

    public void logAfterThrowing(JoinPoint joinPoint,

            Throwable exception)

    {

        System.out.print("logAfterThrowing() is running!");

        System.out.println(

                ", after " + joinPoint.getSignature().getName()

                        + " method throwing exception");

        System.out.println("exception = " + exception);

        System.out.println("******");

    }

}

applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 

    xmlns:context="http://www.springframework.org/schema/context"

    xmlns:aop="http://www.springframework.org/schema/aop"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd

    http://www.springframework.org/schema/context

    http://www.springframework.org/schema/context/spring-context-4.3.xsd

    http://www.springframework.org/schema/aop 

    http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

    <bean id="employeeService" class="com.ram.service.EmployeeService"></bean>

    <!-- Aspect -->

    <bean id="logAspect" class="com.ram.Aspect.LoggingAspect" />

    <aop:config>

        <aop:aspect id="aspectLoggging" ref="logAspect">

            <!-- @AfterThrowing -->

            <aop:pointcut id="pointCutAfterThrowing"

                expression="execution(* com.ram.service.EmployeeService.addEmployee()))" />

            <aop:after-throwing method="logAfterThrowing"

                throwing="exception" pointcut-ref="pointCutAfterThrowing" />

        </aop:aspect>

    </aop:config>

</beans>

App.java

package com.ram.core;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ram.service.EmployeeService;

public class App

{

    public static void main(String[] args)

    {

        ApplicationContext context = new ClassPathXmlApplicationContext(

                "applicationContext.xml");

        System.out.println("---------------------------------------");

        EmployeeService employeeService = context.getBean("employeeService",

                EmployeeService.class);

        try

        {

            employeeService.addEmployee();

        }

        catch (Exception exe)

        {

            System.out.println("exception message  = " + exe.getMessage());

        }

        employeeService.modifyEmployee();

        employeeService.deleteEmployee();

    }

}

Output

Nov 13, 2018 9:38:13 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh

INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@32709393: startup date [Tue Nov 13 09:38:13 IST 2018]; root of context hierarchy

Nov 13, 2018 9:38:13 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions

INFO: Loading XML bean definitions from class path resource [applicationContext.xml]

---------------------------------------

addEmployee() is called

logAfterThrowing() is running!, after addEmployee method throwing exception

exception = java.lang.NullPointerException

******

exception message  = null

modifyEmployee() is called

deleteEmployee() is called