Spring Framework Intermediate

Agenda

Event Handling in Spring
Introduction to AOP
Writing Aspects
Pointcut and WildCard Expressions
Reusing pointcut definition
After advice
Around advice
Custom advice annotation
Understanding SpEL
Writing spring expression
Passing Objects to expressions
SpEL with Spring Bean (i) using systemProperties

(ii) Assigning values from property file

(iii) Collections with SpEL

(iv) Method factory wiring

(v) Static factory wiring

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.

Exercise 1

Create a class Database with 2 instance variables port and name.
Create a method in the Database class connect()
Configure the bean of type database in spring configuration file.
Get the bean of the type Database from Spring config.
Print the values of the instance variables.
Invoke context events start(), stop() and close().
Create listeners for spring events.
Create a CustomEvent which should get published when you invoke connect method of database bean.

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");
}

Exercise 2

Try all AOP wild expressions which we discussed, on the Database class which we created in the previous exercise.
Apply Before, After, AfterReturning, AfterThrowing and Around Advice for the methods of the database class.

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

Exercise 3

Apply execution, within, args, this and bean expressions on the before and after advice of database bean.
Reuse the expressions for getters and setters with the help of @Pointcut annotation and use || operator to run before advice on both the getters but after advice only one getter.
Access the properties of the JoinPoint in before advice.

Use cases of AOP

Logging

Auditing

Security

What is SpEL ?

The Spring Expression Language (SpEL) is a powerful expression language that support quering and manipulating an object at runtime.
Spel expressions can be used with XML or annotation based configurations for defining Bean Definations. In both the cases the syntax to define the expression is of the form #{<expressions>}

Where we can use SpEL ?

Inject a bean.
Placing a bean property in another bean.
Invoking a bean method in another bean.
It supports mathmatical, relational, logical operations at runtime.
Get the values of Map, List and Objects at runtime.

Writing a spring expression

Writing a spring expression
Create instance of Expression by calling parseExpression method on SpelExpressionParser instance.
Get the desired result by calling getValue() on expression object.

import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;

public class SpelDemo {
    public static void main(String[] args) {
        ExpressionParser expressionParser = new SpelExpressionParser();
        Expression expression = expressionParser.parseExpression("'hello'");
        System.out.println(expression.getValue());
    }
}

What all can we do inside Spring expression?

Literal expressions

ExpressionParser expressionParser = new SpelExpressionParser();
Expression expression = expressionParser.parseExpression("1");
System.out.println(expression.getValue());

Inline List

ExpressionParser expressionParser = new SpelExpressionParser();
Expression expression = expressionParser.parseExpression("{1,2,{3,4},5,6}");
System.out.println(expression.getValue());

Inline Map

 ExpressionParser expressionParser = new SpelExpressionParser();
 Expression expression = expressionParser.parseExpression("{framework:'Spring',version:4}");
 System.out.println(expression.getValue());

Array construction

ExpressionParser expressionParser = new SpelExpressionParser();
Expression expression = expressionParser.parseExpression("new int[]{1,2,3,4}");
System.out.println(expression.getValue());

Methods invocation

ExpressionParser expressionParser = new SpelExpressionParser();
Expression expression = expressionParser.parseExpression("'hello'.toUpperCase()");
System.out.println(expression.getValue());

Relational Operations

 ExpressionParser expressionParser = new SpelExpressionParser();
 Expression expression = expressionParser.parseExpression("2==2");
 System.out.println(expression.getValue());

Logical Operations and Mathmatical Operations

ExpressionParser expressionParser = new SpelExpressionParser();
Expression expression = expressionParser.parseExpression("true and false");
System.out.println(expression.getValue());
expression = expressionParser.parseExpression("1+1");
System.out.println(expression.getValue());

Passing Object to the expression

Data can be passed to a spring expression via an instance of StandardEvaluationContext.
If you already have the Object then pass it to the constructor of StandardEvaluationContext.

import com.spring.demo.Employee;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class SpelDemo {
    public static void main(String[] args) {
        Employee employee = new Employee("Dummy Employee", 26);
        StandardEvaluationContext standardEvaluationContext = new StandardEvaluationContext(employee);
        ExpressionParser expressionParser = new SpelExpressionParser();
        Expression expression = expressionParser.parseExpression("name");
        System.out.println(expression.getValue(standardEvaluationContext));
    }
}

We can also create data with the help of setVariable method provided by the instance of StandardEvaluationContext.
Pass the context object to the getValue() of the expression object to get the desired result.

import com.spring.demo.Employee;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class SpelDemo {
    public static void main(String[] args) {
        StandardEvaluationContext context = new StandardEvaluationContext();
        ExpressionParser expressionParser=new SpelExpressionParser();
        Expression expression = expressionParser.parseExpression("(#a * #b)+#c");
        context.setVariable("a", 2);
        context.setVariable("b", 4);
        context.setVariable("c", 1);
        System.out.println(expression.getValue(context));
    }
}

Exercise 4

Create a class Person with instance variables name, age and city.
Fetch the value of one of the instance variable using SpEL.
Perform Mathmatical calculation as follows using StandardEvaluationContext.

Spel with Spring Beans

#{<spring-expression>} can be used with @Value annotation in order to assign value to the properties of bean.

import org.springframework.beans.factory.annotation.Value;
import java.util.List;
import java.util.Map;

public class SpelBean {

    @Value("#{'SpEL'}")
    String name;

    @Value("#{23}")
    Integer age;

    @Value("#{{1,2,3,4}}")
    List list;

    @Value("#{{a:1,b:2,c:3}}")
    Map map;

// getters of all instance variables
}

Note: Setters are not required in this case.

SpEL can also be used to set values in spring beans in Spring Configuration File.

<bean id="spelBean2" class="com.spring.demo.SpelBean">
        <property name="age" value="#{23}"/>
        <property name="name" value="#{'config bean'}"/>
        <property name="list" value="#{{9,8,7,6}}"/>
        <property name="map" value="#{{a:1,b:2}}"/>
</bean>

Value of the bean can also be set by systemProperties.

@Value("#{systemProperties['user.country']}")
String country;

Note: In order to use systemProperties you need to place this line in spring configuration file.

<context:annotation-config/>

Getting value from a file and placing it in the instance variable of a bean

Create an application.properties file and place following content in it inside resources folder.

valueFromFile=Delhi

Now we need to tell Spring path of our file we will do it by placing following line in spring configuration file.

<context:property-placeholder location="classpath:application.properties"/>

Now we can set the value of instance variable of a bean by properties file with the help of $ sign in following way:

    @Value("${valueFromFile}")
    String state;

Exercise 5

Create a class Dummy with instance variables of Type Integer, String, Map and List.
Initialize instance variables with @Value annotation using SpeL.
Introduced two more variable countryCode and state in Dummy class. Set countryCode via systemProperties and state via property file.

Using Operators with Spring Beans

Create a class PersonalisedService as follows:

public class PersonalisedService {
    Integer age;
    Integer incrementedAge;
    Boolean isAgeGreaterThan10;
    Integer firstElementOfList;
    Integer mapValue;
    // generate getters and setters
}

Now set the values of its instance variables with the values of existing spelBean as follows:

<bean id="personalisedService" class="com.spring.demo.PersonalisedService">
        <property name="age" value="#{spelBean.age}"/>
        <property name="incrementedAge" value="#{spelBean.age + 1}"/>
        <property name="isAgeGreaterThan10" value="#{spelBean.age>10}"/>
        <property name="firstElementOfList" value="#{spelBean.list[0]}"/>
        <property name="mapValue" value="#{spelBean.map[a]}"/>
</bean>

Static Method wiring

For the reference of a static method we need to give fully qualified name with following syntax “#{T(full-qualified-name).staticMethod()}“

@Value("#{T(com.spring.demo.EmployeeService).getEmployeeViaStaticMethod()}")
Employee employee;

Method Factory Wiring

You can call an instance method of a spring bean inside spring expression language.

@Value("#{employeeService.getEmployeeViaInstanceMethod()}")
Employee employee;

Exercise 6

Create a PersonalizedService class as shown in slides and apply different operators for assigned the value to its instance variables.
Create a PersonService with one static method and one instance method both should return one instance of Person class.
Introduce a new field of type person in PersonalizedService and initialize it via static method and then via instance method.

Spring Framework Intermediate

Thank you :)