Pointcut – Regular Expression Example

In this article, you will see how to use intercept a method name by using regular expression pointcut with Spring AOP framework.

First create a new Java Project and configure it as Maven Project. For Reference, Click Here

Add the following dependencies in pom.xml

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.8.2</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring</artifactId>
        <version>2.5.6</version>
    </dependency>
 
    <!-- Proxy class need this library -->
    <dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>2.2.2</version>
    </dependency>
 
</dependencies>

1. Business Logic and Implementation

We will first write our business logic and then we will add Spring AOP to profile our business methods.

Create an interface BusinessService and write a following method. We will intercept this via Advice

BusinessService.java

package com.kruders.spring.aop;
 
public interface BusinessService {
    void doSomeThing();
    void printHelloWorld();
}

Now create a class BusinessImpl.java that implements the above interface.

BusinessImpl.java

package com.kruders.spring.aop;
  
public class BusinessImpl implements BusinessService {
    public void doSomeThing() {
        System.out.println("Do Something Here");
    }
     
    public void printHelloWorld() {
        System.out.println("Hello World!!!");
    }
}

2. Configure Spring AOP

Create Spring-Business.xml and write the following code

Spring-Business.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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 
    <bean id="businessService" class="com.kruders.spring.aop.BusinessImpl" />
    <!-- Advice -->
    <bean id="businessAdvice" class="com.kruders.spring.advice.BusinessAdvice" />
     
    <bean id="businessAdvisor"
        class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <property name="patterns">
            <list>
                <value>.*Hello.*</value>
            </list>
        </property>
        <property name="advice" ref="businessAdvice" />
    </bean>
     
    <bean id="businessServiceProxy"
                 class="org.springframework.aop.framework.ProxyFactoryBean">
  
        <property name="target" ref="businessService" />
  
        <property name="interceptorNames">
            <list>
                <value>businessAdvisor</value>
            </list>
        </property>
    </bean>
</beans>

We defined two normal Spring beans – one for our Business class and the other for Business Profiler (i.e. our advice).

We also create a new proxy object named ‘businessServiceProxy‘.

target‘ – Define which bean you want to intercept. ‘interceptorNames‘ – Define which class (advice) you want to apply on this proxy /target object.

Create a RegexpMethodPointcutAdvisor advisor bean, and associate both advice and pointcut.

<bean id="businessAdvisor"
    class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
    <property name="patterns">
        <list>
            <value>.*Hello.*</value>
        </list>
    </property>
    <property name="advice" ref="businessAdvice" />
</bean>

Here we intercept all the methods that contains Hello within the method name.

Pass “businessAdvisor” as interceptorNames value.

<property name="interceptorNames">
    <list>
        <value>businessAdvisor</value>
    </list>
</property>

3. Advice Class

Now write a Advice which will profile our business method.

BusinessAdvice.java

package com.kruders.spring.advice;
 
import java.util.Arrays;
 
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
 
public class BusinessAdvice implements MethodInterceptor {
     
    @Override
    public Object invoke(MethodInvocation method) throws Throwable {
        System.out.println("Method name : " + method.getMethod().getName());
        System.out.println("Method arguments : " + Arrays.toString(method.getArguments()));
  
        System.out.println("Around method is called");
        System.out.println("Around before is running");
  
        method.proceed();
        System.out.println("Around after is running");
  
        return null;
    }
}

4. Helper Class

Create Main.java class that loads our Business bean from Spring Context and then calling our business method.

Main.java

package com.kruders.spring.core;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.kruders.spring.aop.BusinessService;
 
public class Main {
    public static void main(String args[]) {
        ApplicationContext appContext = new ClassPathXmlApplicationContext("Spring-Business.xml");
        BusinessService businessService = (BusinessService)appContext.getBean("businessServiceProxy");
        businessService.printHelloWorld();
    }
}

The folder structure of the example is shown below in Figure 16.1

Figure 16.1 Figure 16.1

You can download the source code of this example here.


No comments yet.

Leave a Reply