Spring Events and AOP

Agenda

Event Handling in Spring
Introduction to AOP
Writing Aspects
Pointcut and WildCard Expressions
Reusing pointcut definition
After advice
Around advice
Custom advice annotation

Spring Events

An event is an action or occurrence recognised and handled by the software.
Event handling in ApplicationContext is provided through the ApplicationEvent class and ApplicationListener interface.
If a bean that implements the ApplicationListener interface is deployed into the context, every time an ApplicationEvent gets published to the ApplicationContext, that bean is notified.

Built In Spring events

ContextRefreshedEvent : This event is published when the ApplicationContext is either initialized or refreshed.This can also be raised using the refresh() method on theConfigurableApplicationContext interface.
ContextStartedEvent :This event is published when the ApplicationContext is started using the start() method on the ConfigurableApplicationContext interface.
ContextStoppedEvent : This event is published when the ApplicationContext is stopped using the stop() method on the ConfigurableApplicationContext interface.
ContextClosedEvent : This event is published when the ApplicationContext is closed using the close() method on the ConfigurableApplicationContext interface. A closed context reaches its end of life; it cannot be refreshed or restarted.

Publishing Spring Events

Create a class Dummy

public class Dummy {
   public void display() {
        System.out.println("Display");
    }
}

Configure the dummy bean in spring configuration file

<bean id="dummy" class="com.spring.demo.Dummy"/>

Initialize Application context and invoke start and stop method on the context

ConfigurableApplicationContext ctx = new ClassPathXmlApplicationContext("config.xml");
ctx.start();
Dummy dummy = ctx.getBean("dummy", Dummy.class);
dummy.display();
ctx.stop();

Creating an Event Listener for Spring events

Create a class MyEventListener which implements ApplicationListener interface.
Implement onApplicationEvent method of ApplicationListener interface inside MyEventListener.

import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;

public class MyEventListener implements ApplicationListener {

    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        System.out.println(event);
    }
}

<bean class="com.spring.event.MyEventListener"/>

Capture a specific spring event

In order to catch a specific spring event we need to mention the name of that event class in generics with ApplicationListener

package com.spring.event;

import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextStartedEvent;

public class MyEventListener implements ApplicationListener<ContextStartedEvent> {
    @Override
    public void onApplicationEvent(ContextStartedEvent event) {
        System.out.println(event);
    }
}

Creating a custom Spring Event

Create a class CustomEvent which extends ApplicationEvent.
Define a constructor inside CustomEvent class which accepts one argument of type Object and pass that object to super class.

import org.springframework.context.ApplicationEvent;

public class CustomEvent extends ApplicationEvent {
   CustomEvent(Object object) {
        super(object);
    }
}

import com.spring.CustomEvent;
import org.springframework.context.ApplicationListener;

public class CustomEventListener implements ApplicationListener<CustomEvent> {
    @Override
    public void onApplicationEvent(CustomEvent event) {
        System.out.println(event.getSource());
    }
}

Create custom Event Listener

Create a class CustomEventListener which implements ApplicationListener interface and specify CustomEvent in generic with it.

Configure customEventListener bean in spring configuration file.

<bean class="com.spring.listener.CustomEventListener"/>

Introduce ApplicationEventPublisher

Implement ApplicationEventPublisherAware in Dummy class.
Define an instance variable of type ApplicationEventPublisher and set the its value via setApplicationEventPublisher which is provided by ApplicationEventPublisherAware interface.
Now in order publish the event create an instance of CustomEvent with passing the instance of Dummy class as constructor arument.
Now invoke publishEvent method with applicationEventPublisher and pass the CustomEvent instance in method as argument.

import com.spring.CustomEvent;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;

public class Dummy implements ApplicationEventPublisherAware {
    ApplicationEventPublisher applicationEventPublisher;
    void display() {
        CustomEvent customEvent = new CustomEvent(this);
        applicationEventPublisher.publishEvent(customEvent);
        System.out.println("Display");
    }
    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.applicationEventPublisher = applicationEventPublisher;
    } }

Using event Listener annotation

By using @EventListener annotation we can define we can define multiple event listeners in single class in following way:

import org.springframework.context.event.*;

public class MultipleEventListener {
    @EventListener(ContextStartedEvent.class)
    void start() {
        System.out.println("----------------start");
    }
    @EventListener(ContextStoppedEvent.class)
    void stopped() {
        System.out.println("----------------stopped");
    }
}

We need to place following line in spring configuration file in order to use this annotation.

 <context:annotation-config/>

Running spring event in separate Thread

In order to run event in separate thread we need to make following configurations in spring configuration file

<bean id="simpleAsyncTaskExecutor" 
  class="org.springframework.core.task.SimpleAsyncTaskExecutor"/>


<bean id="applicationEventMulticaster"                  
   class="org.springframework.context.event.SimpleApplicationEventMulticaster">
   <property name="taskExecutor" ref="simpleAsyncTaskExecutor"/>
</bean>

Advantages of Spring Events

Components are loosely coupled.
You might need to take more than one independent actions when event occurs.
The processing needs to be handed off to another thread to prevent blocking, e.g. sending an email.

AOP (Aspect Oriented Programming)

Aspect Oriented Programming complements Object-Oriented Programming by providing another way of thinking about program Structure.
The key unit of modularity in OOP is the class, whereas in AOP the unit of modularity is the Aspect.
Aspect enables the modularization of concerns that cut across multiple types and objects.

AOP terminologies

Aspect : A modularization of a concern that cuts across multiple classes.
Joint Point : A point during the execution of a program.
Advice : Action taken by an aspect at a particular joint point.
Pointcut : a predicate that matches joint points.

AOP in action

Enable aspectj autoproxy

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
         
     <aop:aspectj-autoproxy/>

</bean>

AOP in action (Cont.)

Create a class Dummy

class Dummy{
public void display(){
  System.out.println(“Dummy class display method“);
}}

Configure Dummy bean in spring configuration file.

<bean id="dummy" class="com.spring.demo.Dummy">

AOP in action (Cont.)

Create an aspect class and mark it with annotation @Aspect.
create a method inside MyAspect class with the name beforeAdvice and mark it with before annotation in following way.

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

@Aspect
public class MyAspect {

    @Before("execution(public void display())")
    void beforeAdvice() {
        System.out.println("Before advice is running");
    }
}

Configure MyAspect bean in Spring Configuration file.

Wild Expressions for AOP

@Before(execution(void display())) will envoke display an advice before any method that has the signature void display()

@Before("execution( void display())")
void beforeAdvice() {
    System.out.println("Running before advice");
}

@Before(execution(* get*())) will envoke an advice before any getter method

@Before("execution( * get*())")
void beforeAdvice() {
    System.out.println("Running before advice");
}

@Before("execution(* com.spring.demo.Dummy.*())") will envoke an advice before all the methods inside Dummy class which does not take any argument.

@Before("execution( * com.spring.demo.Dummy.*())")
void beforeAdvice() {
    System.out.println("Running before advice");
}

Wild Expressions for AOP (Cont.)

@Before("execution(* com.spring.demo.*.*())") will envoke an advice before all the methods inside com.spring.demo package which accepts no parameters.

@Before("execution( * com.spring.demo.Dummy.*())")
 void beforeAdvice() {
     System.out.println("Running before advice");
 }

@Before("execution(void *())") will envoke an advice before any method with void return type but does not accept any parameter.

@Before("execution(void *())")
void beforeAdvice() {
    System.out.println("Running before advice");
}

@Before("execution(* *())") will envoke an advice before any method which takes no argument

@Before("execution(* *())")
 void beforeAdvice() {
        System.out.println("Running before advice");
 }

Wild Expressions for AOP (Cont.)

@Before("execution(* *(..))") Will envoke an advice before any method

@Before("execution(* *(..))")
void beforeAdvice() {
    System.out.println("Running before advice");
}

Types of Advice

Before : Run advice before the a method execution.

@Before("execution(void display())")
void beforeAdvice() {
    System.out.println("Running before advice");
}

After-returning : Run advice after the a method execution only if method completes successfully.

@AfterReturning(pointcut = "execution(Integer getInteger())", returning = "returnValue")
void afterReturningAdvice(Integer returnValue) {
    System.out.println("Running AfterReturning " + returnValue);
}

After-throwing : Run advice after the a method execution only if method exits by throwing an exception.

@AfterThrowing(pointcut = "execution(void throwException())", throwing = "ex")
 void afterReturningAdvice(Exception ex) {
     System.out.println("Running AfterThrowing " + ex);
 }

Types of Advice (Cont.)

After (finally): Run advice after the a method execution regardless of its outcome.

@After("execution(void display())")
 void afterAdvice(){
     System.out.println("Running after advice");
 }

Around : Run advice before and after the advised method is invoked.

@Around("execution(void display())")
void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    System.out.println("Around before");
    proceedingJoinPoint.proceed();
    System.out.println("Around after");
}

Pointcut Expressions

execution for matching method execution join points.

within limits matching to join points within certain types.

bean limit the matching of join points to a particular named Spring bean.

@Before("execution(void display())")
void beforeAdvice() {
    System.out.println("Running before advice");
}

@Before("within(com.spring.demo.*)")
void beforeAdvice() {
    System.out.println("Running before advice");
}

@Before("bean(dummy))")
void beforeAdvice() {
    System.out.println("Running before advice");
}

Pointcut Expressions (Cont.)

args limits matching to join points where the arguments are instances of the given types.

@Before("args(Integer)")
void beforeAdvice() {
    System.out.println("Running before advice");
}

@Before("this(com.spring.demo.Dummy)")
void beforeAdvice() {
    System.out.println("Running before advice");
}

this limits matching to join points within certain types.

Reusing pointcut

We can define a pointcut via @Pointcut annotation and then use the name of the method where on which point cut expression is defined in other expressions.
We can also use || operator to provide the cobination od different pointcuts on which advice will run.

@Before("dummyClassPointcut() || getStringPointcut()")
void beforeAdvice() {
    System.out.println("Running before advice");
}

@After("displayPointcut()")
void afterAdvice(){
    System.out.println("Running after advice");
}

@Pointcut("execution(void display())")
void displayPointcut(){}

@Pointcut("execution(String getString())")
void getStringPointcut(){}

Accessing JoinPoint in advice

A joinpoint can be accessed within an advice with the help of an instance of JoinPoint class which should be passed as first parameter to an advice.

@Before("execution(Integer getInteger(Integer))")
void beforeAdvice(JoinPoint joinPoint) {
    System.out.println("Running before advice");
    System.out.println(joinPoint);
    System.out.println(joinPoint.getThis());
    System.out.println(joinPoint.getSignature());
    Object [] objects=joinPoint.getArgs();
    for (Object object:objects){
        System.out.println(object);
    }
}

Use cases of AOP

Logging

Auditing

Security

Spring Events and AOP

Thank you :)