1. Sending async email: While executing a user registration flow, system may want to send and email and sending this email should not stop the registration process to complete so it requires an asynchronous way to do that. Application Event can help in this situation.
2. Auditing application actions: Another use case where you do not want to stop the execution of main thread and want to audit activities in an async way.

I am trying to list classes you will need to use your own Application Events and handle them:

a) Your custom event : UserEvent, AbstractEvent. AbstractEvent is an abstract class which can be extended based on requirement. As you can see in the code, Event Id is used to call its super class which is ApplicationEvent class of Spring framework. Another variable eventContext is used to carry context parameters to the handler of event(Check different constructors of UserEvent).

public class UserEvent extends AbstractEvent {
        public UserEvent(String eventId, Object eventContext) {
		super(eventId, eventContext);
	}
        public UserEvent(String eventId, User user, String tPassword) {
		super(eventId, new HashMap());
		Map<String, Object> params = (Map<String, Object>) this.getEventContext();
		params.put("user", user);
		params.put("tPassword", tPassword);
	}
}

public abstract class AbstractEvent extends ApplicationEvent {

        protected String eventId;
	protected Object eventContext;

	public AbstractEvent(String eventId, Object eventContext) {
		super(eventId);
		this.eventId = eventId;
		this.eventContext = eventContext;
	}

	public String getEventId() {
		return eventId;
	}

	public Object getEventContext() {
		return eventContext;
	}

	public Object getContextParams(String paramName){
		if(! (eventContext!= null && eventContext instanceof Map)){
			return null;
		}
		return ((Map)eventContext).get(paramName);
	}
}

b) Publish your custom event : You will like to publish your custom event generally from the flow of execution e.g. in this case UserService or RegistrationService. Spring gives a facility to make your class able to publish Application events by implementing ApplicationEventPublisherAware interface.

By implementing ApplicationEventPublisherAware, you need to implement setApplicationEventPublisher function and Spring will automatically call set function to inject ApplicationEventPublisher instance. This instance can be used for publishing the event.

This basically invokes all listeners waiting for this kind of Event in a separate thread to make it async.

public class RegistrationService implements ApplicationEventPublisherAware{
        protected ApplicationEventPublisher applicationEventPublisher;
        public static final String Event_RegisterUser = "registerUser";

        public void registerUser(User u) {
                .......
                .......
                try {
				applicationEventPublisher.publishEvent(new UserEvent(Event_RegisterUser, u));
			}
			catch(Exception e) {
				logger.error(e.getMessage(), e);
			}
                ..........
                ..........
        }
        public void setApplicationEventPublisher(
			ApplicationEventPublisher applicationEventPublisher) {
		this.applicationEventPublisher = applicationEventPublisher;
	}
}

c) Handle your custom event : An event listener would be required to handle the event published by the service and handle it. By implementing ApplicationListener, class has to implement onApplicationEvent function where it gets the Event object with eventId and eventContext.

public class UserEventListener implements ApplicationListener<UserEvent> {
        public void onApplicationEvent(UserEvent event) {
                String eventId = event.getEventId();
                User user = (User) event.getContextParams("user");
                String tempPassword = (String) event.getContextParams("tPassword");
                //Do your handling like send an email to newly added User
        }
}

One very probable scenario is that during the maintenance processes some thing is missed on some server(s). This may cause random issues to the user of the application as requests are distributed and can reach any server.This trick can be used to figure out which server is serving your page. Here i am adding the code which we used recently in our JSP pages to figure it out.

<%@page import="java.net.InetAddress;" %>
<%String ip = "";
  String hostName = "";
try{
    InetAddress inetAddress = InetAddress.getLocalHost();
    ip = inetAddress.getHostAddress();
	hostName = inetAddress.getHostName();
}catch(Exception e){}
%>
<div style="display:none;"> Server IP address : <%out.print(ip);%> <br/>
Server Host Name : <%out.print(hostName);%> <br/>
</div>

As you do not want to show this to user, you can add a hidden div element at the end of the page which can contain server address and server name by which you can differentiate servers. This can be accessed by viewing the page source (most of the browsers provide this option on right-click.)