Sunday, 18 November 2018

Spring AOP AspectJ @Before Annotation Example | Spring Tutorial

🚀 Master Java with Ram N Java!

Want to simplify complex Spring concepts? Join our community for expert-led coding guides!

SUBSCRIBE NOW

Understanding the @Before Annotation

In this tutorial, we explore one of the cornerstones of Spring Aspect-Oriented Programming (AOP): the @Before advice. This tool is essential for any developer looking to write cleaner, more modular code.

What is @Before Advice?

The @Before advice tells Spring to execute specific logic—like logging or security checks—before the execution of a target method. It’s a powerful way to handle "cross-cutting concerns" without cluttering your business logic.

Key Implementation Steps

  • Create an Aspect: Use the @Aspect annotation on your class.
  • Define the Advice: Annotate your method with @Before.
  • Set the Pointcut: Specify which methods Spring should intercept.
  • Configure the Proxy: Enable AspectJ support in your Spring configuration.

Why It Matters for Beginners

Instead of copying and pasting the same logging code into ten different methods, you write it once in your Aspect class. This makes your application much easier to maintain and update as it grows!


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

Click the below Image to Enlarge:
Spring AOP AspectJ @Before Annotation Example | Spring Tutorial

Spring AOP AspectJ @Before Annotation Example | Spring Tutorial

Spring AOP AspectJ @Before Annotation Example | Spring Tutorial

Spring AOP AspectJ @Before Annotation Example | 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 void addEmployee()
    {
        System.out.println("Add Employee ");
    }
   
    public void modifyEmployee()
    {
        System.out.println("Modify Employee");
    }
   
    public void deleteEmployee()
    {
        System.out.println("Delete Employee");
    }

}

LoggingAspect.java

package com.ram.Aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class LoggingAspect
{

    @Before("execution(* com.ram.service.EmployeeService.addEmployee())")
    public void logBefore(JoinPoint joinPoint)
    {

        System.out.print("logBefore() is running!");
        System.out.println(", before "
                + joinPoint.getSignature().getName() + " method");
        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">


    <aop:aspectj-autoproxy />

    <bean id="employeeService" class="com.ram.service.EmployeeService"></bean>
   
    <!-- Aspect -->
    <bean id="logAspect" class="com.ram.Aspect.LoggingAspect" />

</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);

        employeeService.addEmployee();

        employeeService.modifyEmployee();

        employeeService.deleteEmployee();

    }

}

Output

Nov 02, 2018 9:38:03 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@3701eaf6: startup date [Fri Nov 02 09:38:03 IST 2018]; root of context hierarchy
Nov 02, 2018 9:38:03 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [applicationContext.xml]
---------------------------------------
logBefore() is running!, before addEmployee method
******
Add Employee
Modify Employee
Delete Employee

Click the below link to download the code:
https://sites.google.com/site/ramj2eev2/java_basics/SpringDemo_AspectJ_before.zip?attredirects=0&d=1

Github Link:
https://github.com/ramram43210/javaee/tree/master/Spring_2018/SpringDemo_AspectJ_before

Bitbucket Link:
https://bitbucket.org/ramram43210/spring/src/a5cdfdc3da3c676ee6dec77cfdb6b5c635be29d3/Spring_2018/SpringDemo_AspectJ_before/?at=master

See also:

  • All JavaEE Videos Playlist
  • All JavaEE Videos
  • All JAVA EE Links
  • Spring Tutorial
  • Servlets Tutorial
  • All Design Patterns Links
  • JDBC Tutorial
  • Java Collection Framework Tutorial
  • JAVA Tutorial
  • Kids Tutorial
  • Cooking Tutorial
  • No comments:

    Post a Comment

    Tutorials