自定义java事件监听

User defined Event listeners java

All of us who have used java.awt.event package in either applets

or in Frames or in swing JFrame, shall agree to the fact that event

propagation and listener concept is very very useful for capturing

any action initiated either by user or by system, should be caught

at the right place and without unneccessarily wasting time traversing

through all the way from begining to end of source code just to know

any takers for this event.

This concept is implemented in form of MouseEvent, KeyEvent, WindowEvent so on so forth.

JDK has given us a handle for creating our own event object and as well

as event handling framework using java.util.EventObject and java.util.EventListener.

You can imagine a scenario whereby you have to write an application, in

which a email notification feature in a forum.

Whenever a special event takes place , then your have to notify all the users

who have registered themselves for this program.

One solution is to use a Database and query all the users from the table

and send notification to each and every user.

But this is more of Database centric approach like old days thick client

and server model.

Think about the overhead on database and instead another solution is

to create an event notification framework, whereby you have to create

your own version of Event Object and Event Listeners.

Event object represents the special event and all the users who register

themselves for the event implements this Event listener.

Let us take a more deeper plunge into this:

1. Create a Demo event by creating a DemoEvent.java file that

extends to java.util.EventObject.

This class has a constructor that takes the event originator object (DemoSource).

and a method getSource(), that gives the reference to the object that originated

this event.

DemoEvent.java

package demo.listener; import java.util.EventObject; public class DemoEvent extends EventObject { Object obj; public DemoEvent(Object source) { super(source); obj = source; } public Object getSource() { return obj; } public void say() { System.out.println("This is say method..."); } }

2. Create the source of event notification file DemoSource.java

It has a java.util.Vector that acts like a repository for storing all the

listeners to the events this source provides.

It has two other common method such as addListener(..) is to add any

new user to this event.

And notifyDemoEvent(..) is to alert all the users about this perticular event

occurance.

DemoEvent.java

package demo.listener; import java.util.*; public class DemoSource { private Vector repository = new Vector(); DemoListener dl; public DemoSource() { } public void addDemoListener(DemoListener dl) { repository.addElement(dl); } public void notifyDemoEvent() { Enumeration enum = repository.elements(); while(enum.hasMoreElements()) { dl = (DemoListener)enum.nextElement(); dl.demoEvent(new DemoEvent(this)); } } }

3. Define a listener interface that extends to java.util.EventListener

and contains the method for invoking the Event, here it is demoEvent(DemoEvent de).

DemoListener.java

package demo.listener; import java.util.EventListener; public interface DemoListener extends EventListener { public void demoEvent(DemoEvent dm); }

4. Define all the users, who want to listen to this events.

These objects should implement DemoListener, to be able to

capture the event propagated from DemoSource.java.

Listener1.java

package demo.listener; public class Listener1 implements DemoListener { public void demoEvent(DemoEvent de) { System.out.println("Inside listener1..."); } }

Listener2.java

package demo.listener; public class Listener2 implements DemoListener { public void demoEvent(DemoEvent de) { System.out.println("Inside listener2..."); } }

Listener3.java

package demo.listener; public class Listener3 implements DemoListener { public void demoEvent(DemoEvent de) { System.out.println("Inside listener3..."); } }

5. Now it time to write the client for testing this Framework.

Create a client such as TestDemo.java and create a DemoSource

object and all the users such as Listener1, Listener2, Listener3.

And add all these listeners to the demo source by using the addDemoListener(..).

When the notifyDemoEvent(..) is called on the demo source object,

the event gets notified to all the users (listener1, listener2, listener3)

and the output comes out to be

Inside listener1...

Inside listener2...

Inside listener3...

TestDemo.java

package demo.listener;

public class TestDemo
{
DemoSource ds;

public TestDemo()
{
try{
ds = new DemoSource();
Listener1 l1 = new Listener1();
Listener2 l2 = new Listener2();
Listener3 l3 = new Listener3();

ds.addDemoListener(l1);
ds.addDemoListener(l2);
ds.addDemoListener(l3);

ds.notifyDemoEvent();

}catch(Exception ex){ex.printStackTrace();}
}

public static void main(String args[])
{
new TestDemo();
}
}