Showing posts with label Pointcut. Show all posts

Thursday, 15 November 2018

Spring AOP Example – Advice, Pointcut, Advisor - NamematchMethodPointCutAdvisor | Spring Tutorial

🔥 Want to Master Spring Framework?

Subscribe to Ram N Java for simplified tutorials and real-world coding examples!

Understanding Spring AOP: Pointcuts and Advisors

In this tutorial, we take a closer look at how to control where your "advice" (logic) is applied in a Spring application. We will specifically focus on the NameMatchMethodPointcutAdvisor.

What is a Pointcut?

In Aspect-Oriented Programming (AOP), a Pointcut is like a filter. It tells Spring where to apply your code. For example, you might only want to run a log message when a specific method like getEmployeeData() is called.

Introducing NameMatchMethodPointcutAdvisor

This advisor is incredibly useful when you want to target methods by their exact name. Instead of applying logic to every single method in a class, you can provide a list of specific method names.

Precision: Target exactly the methods you need.
Simplicity: No complex regex needed—just the method names.
Clean Code: Keeps your business logic separate from your cross-cutting concerns.

How We Built the Example

In the video, we create a simple service with multiple methods. We then configure the NameMatchMethodPointcutAdvisor in our XML file, passing in our "advice" and the specific method names we want to intercept. When the program runs, you'll see that only the chosen methods trigger the extra logic!

📺 Recommended for You

Check out these related videos to expand your Spring AOP knowledge:

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

Click the below Image to Enlarge:

Spring AOP Example – Advice, Pointcut, Advisor - NamematchMethodPointCutAdvisor | 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>

    </dependencies>

</project>

EmployeeService.java

package com.ram.service;

public class EmployeeService

{

    public String getEmployeeName()

    {

        System.out.println("Get Employee Name");

        return "Dave";

    }

    public int getEmployeeAge()

    {

        System.out.println("Get Employee Age");

        return 28;

    }

    public String getEmployeeAddress()

    {

        System.out.println("Get Employee Address");

        return "A111, East Street";

    }

}

AroundAdvice.java

package com.ram.Advice;

import org.aopalliance.intercept.MethodInterceptor;

import org.aopalliance.intercept.MethodInvocation;

public class AroundAdvice implements MethodInterceptor

{

    public Object invoke(MethodInvocation mi) throws Throwable

    {

        Object obj;

        System.out.println("AroundAdvice applied before actual method = "

                + mi.getMethod().getName());

        obj = mi.proceed();

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

        System.out.println("AroundAdvice applied after actual method =  "

                + mi.getMethod().getName());

        return obj;

    }

}

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"

    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">

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

    <bean id="aroundAdvice" class="com.ram.Advice.AroundAdvice"></bean>

    <bean id="employeeServiceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">

        <property name="target" ref="employeeService"></property>

        <property name="interceptorNames">

            <list>

                <value>employeeAdvisor</value>

            </list>

        </property>

    </bean>

    <bean id="employeeAdvisor" 

                 class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">

        <property name="mappedName" value="getEmployeeAge" />

        <property name="advice" ref="aroundAdvice" />

    </bean>

</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("employeeServiceProxy", EmployeeService.class);

        employeeService.getEmployeeName();

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

        employeeService.getEmployeeAge();

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

        employeeService.getEmployeeAddress();

    }

}

Output

Oct 22, 2018 10:08:36 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh

INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@6ebc05a6: startup date [Mon Oct 22 10:08:36 IST 2018]; root of context hierarchy

Oct 22, 2018 10:08:37 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions

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

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

Get Employee Name

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

AroundAdvice applied before actual method = getEmployeeAge

Get Employee Age

obj = 28

AroundAdvice applied after actual method =  getEmployeeAge

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

Get Employee Address

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

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

Bitbucket Link:
https://bitbucket.org/ramram43210/spring/src/7d2a171064f15a9cee482e820ec0271fa30b23b8/Spring_2018/SpringDemo_NameMatchMethodPointcutAdvisor/?at=master

See also:

All JavaEE Videos Playlist

All Design Patterns Links

JDBC Tutorial

Java Collection Framework Tutorial

JAVA Tutorial

Kids Tutorial

Cooking Tutorial

Wednesday, 14 November 2018

Spring AOP Example – Advice, Pointcut, Advisor - NameMatchMethodPointcut | Spring Tutorial

🚀 Want to Master Spring Framework?

Subscribe to Ram N Java for more deep dives into Java and Spring!

✅ SUBSCRIBE NOW

Spring AOP: Understanding Advice, Pointcuts, and Advisors

In this tutorial, we take a hands-on look at how to apply specific logic to certain methods in your application without cluttering your business logic. We focus on the NameMatchMethodPointcut to filter exactly where our advice runs.

1. What is a Pointcut?

Think of a Pointcut as a targeting system. It defines where in your code the extra logic (Advice) should be applied. Instead of applying logic to every method in a class, a pointcut helps you pick and choose specific methods.

2. Using NameMatchMethodPointcut

The NameMatchMethodPointcut class is perfect for beginners. It allows you to specify method names directly. For example, if you only want to intercept a method named getEmployeeName, you can simply tell the pointcut to look for that exact name.

3. Bringing it Together with an Advisor

An Advisor is a simple object that groups your Advice (the logic) and your Pointcut (the target) together. In our XML configuration, we link these components so that Spring knows exactly which logic to run for which method.

Why Use This Approach?

Granular Control: You decide exactly which methods are affected.
Separation of Concerns: Your main code stays clean of logging or security logic.
Flexibility: You can change which methods are intercepted just by editing your configuration file.

🎥 Related Tutorials from Ram N Java

Continue building your expertise with these selected videos:

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

Click the below Image to Enlarge: