Spring Core

Event Handling Spring Framework

In this article, we will explore about event handling Spring application. Spring Framework also provide an another feature to promote loose coupling ,which is Application Event handling. Using Events, an Event publisher object can communicate with other objects without even knowing which object is listen.and event listener can work to event without knowing which object publish the events. Publisher Object that object ,who publish the event or call the event and Listener always listen the events that are occurs.

To make a custom event extends the class with ApplicationEvent class.The ApplicationEventPublisher has contain publishEvent() method that enable to publish ApplicationEvents (Custom Events).Any ApplicationListener that is registered with the onApplicationEvent() method in application,listen the events.
To understand The Event handling Lets illustrate a simple example-

Circle.java

package com.dineshonjava.sdnext.eventHandling.tutorial;

import javax.annotation.Resource;

import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.context.MessageSource;
import org.springframework.stereotype.Controller;

/**
 * @author Dinesh Rajput
 *
 */
@Controller
public class Circle implements ApplicationEventPublisherAware
{
 private Point             center;
 private ApplicationEventPublisher publisher;
 
 /**
  * @param center the center to set
  */
 @Resource(name="pointB")
 public void setCenter(Point center)
 {
  this.center = center;
 }

 public void draw()
 {
             System.out.println("Circle is Drawn");
             DrawEvent drawEvent = new DrawEvent(this);
             publisher.publishEvent(drawEvent);
 }

 @Override
 public void setApplicationEventPublisher(ApplicationEventPublisher publisher)
 {
  this.publisher = publisher;
 }
}

Point.java

package com.dineshonjava.sdnext.eventHandling.tutorial;

/**
 * @author Dinesh Rajput
 *
 */
public class Point 
{
 private int x;
 private int y;
 /**
  * @return the x
  */
 public int getX() 
 {
  return x;
 }
 /**
  * @param x the x to set
  */
 public void setX(int x) 
 {
  this.x = x;
 }
 /**
  * @return the y
  */
 public int getY()
 {
  return y;
 }
 /**
  * @param y the y to set
  */
 public void setY(int y)
 {
  this.y = y;
 } 
}

MyEventListener.java

package com.dineshonjava.sdnext.eventHandling.tutorial;

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

@Component
public class MyEventListener implements ApplicationListener
{

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

}

DrawEvent.java

package com.dineshonjava.sdnext.eventHandling.tutorial;

import org.springframework.context.ApplicationEvent;

public class DrawEvent extends ApplicationEvent
{

 /**
  * Dinesh Rajput
  */
 private static final long serialVersionUID = 6973014356268900607L;

 public DrawEvent(Object source)
 {
  super(source);
 }
 
 public String toString()
 {
  return "Draw event occurred";
 }
}

spring.xml

<beans xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:schemalocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<context:annotation-config></context:annotation-config>
<bean class="com.sdnext.dineshonjava.eventHandling.tutorial.Point" id="pointB">
    <property name="x" value="10"></property>
    <property name="y" value="20"></property>
</bean>
<context:component-scan base-package="com.sdnext.dineshonjava.eventHandling.tutorial"></context:component-scan>
</beans>

DrawingApp.java

package com.dieshonjava.sdnext.eventHandling.tutorial;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author Dinesh Rajput
 *
 */
public class DrawingApp
{

 /**
  * @param args
  */
 public static void main(String[] args)
 {
ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
Circle circle = (Circle)context.getBean("circle");
circle.draw();
 }
}

 

Output:

Circle is Drawn
Draw event occurred

 

Spring Related Topics you may like

 

 

Previous
Next
Dinesh Rajput

Dinesh Rajput is the chief editor of a website Dineshonjava, a technical blog dedicated to the Spring and Java technologies. It has a series of articles related to Java technologies. Dinesh has been a Spring enthusiast since 2008 and is a Pivotal Certified Spring Professional, an author of a book Spring 5 Design Pattern, and a blogger. He has more than 10 years of experience with different aspects of Spring and Java design and development. His core expertise lies in the latest version of Spring Framework, Spring Boot, Spring Security, creating REST APIs, Microservice Architecture, Reactive Pattern, Spring AOP, Design Patterns, Struts, Hibernate, Web Services, Spring Batch, Cassandra, MongoDB, and Web Application Design and Architecture. He is currently working as a technology manager at a leading product and web development company. He worked as a developer and tech lead at the Bennett, Coleman & Co. Ltd and was the first developer in his previous company, Paytm. Dinesh is passionate about the latest Java technologies and loves to write technical blogs related to it. He is a very active member of the Java and Spring community on different forums. When it comes to the Spring Framework and Java, Dinesh tops the list!

Share
Published by
Dinesh Rajput

Recent Posts

Strategy Design Patterns using Lambda

Strategy Design Patterns We can easily create a strategy design pattern using lambda. To implement…

2 years ago

Decorator Pattern using Lambda

Decorator Pattern A decorator pattern allows a user to add new functionality to an existing…

2 years ago

Delegating pattern using lambda

Delegating pattern In software engineering, the delegation pattern is an object-oriented design pattern that allows…

2 years ago

Spring Vs Django- Know The Difference Between The Two

Technology has emerged a lot in the last decade, and now we have artificial intelligence;…

2 years ago

TOP 20 MongoDB INTERVIEW QUESTIONS 2022

Managing a database is becoming increasingly complex now due to the vast amount of data…

2 years ago

Scheduler @Scheduled Annotation Spring Boot

Overview In this article, we will explore Spring Scheduler how we could use it by…

3 years ago