学步园

JAVA自定义事件小例子（转）

package demo;

import java.util.EventObject;

/**
* Title: 事件处理类，继承了事件基类
* Description:
* Copyright: Copyright (c) 2005
* Company: cuijiang
* @author not attributable
* @version 1.0
*/
public class DemoEvent extends EventObject
{
   private Object obj;
   private String sName;
   public DemoEvent(Object source,String sName)   {
     super(source);
     obj = source;
     this.sName=sName;
   }
   public Object getSource()
   {
     return obj;
   }
   public void say()
   {
     System.out.println("这个是 say 方法...");
   }

   public String getName()
   {
     return sName;
   }
}


package demo;

import java.util.EventListener;

/**
* Title: 监听器接口
* Description:
* Copyright: Copyright (c) 2005
* Company: cuijiang
* @author not attributable
* @version 1.0
*/
public interface DemoListener extends EventListener{
   public void demoEvent(DemoEvent dm);
}

package demo;
import java.util.*;

/**
* Title: 使用事件的类
* Description: 该类实现了监听器的添加和监听器方法的执行，并且实现了由于属性的改变而执行事件
* Description: 在添加、删除、执行监听器的时候都要注意同步问题
* Copyright: Copyright (c) 2005
* Company: cuijiang
* @author not attributable
* @version 1.0
*/
public class DemoSource{
   private Vector repository = new Vector();
   private DemoListener dl;
   private String sName="";

   public DemoSource()
   {
   }

   //注册监听器，如果这里没有使用Vector而是使用ArrayList那么要注意同步问题
   public void addDemoListener(DemoListener dl)
   {
     repository.addElement(dl);//这步要注意同步问题
   }

   //如果这里没有使用Vector而是使用ArrayList那么要注意同步问题
   public void notifyDemoEvent(DemoEvent event) {
     Enumeration enum = repository.elements();//这步要注意同步问题
     while(enum.hasMoreElements())
     {
       dl = (DemoListener)enum.nextElement();
       dl.demoEvent(event);
     }
   }

   //删除监听器，如果这里没有使用Vector而是使用ArrayList那么要注意同步问题
   public void removeDemoListener(DemoListener dl)
   {
     repository.remove(dl);//这步要注意同步问题
   }

   /**
    * 设置属性
    * @param str1 String
    */
   public void setName(String str1)
   {
     boolean bool=false;
     if(str1==null && sName!=null) bool=true;
     else if(str1!=null && sName==null) bool=true;
     else if(!sName.equals(str1)) bool=true;

     this.sName=str1;

     //如果改变则执行事件
     if(bool) notifyDemoEvent(new DemoEvent(this,sName));
   }

   public String getName()
   {
     return sName;
   }
}

package demo;

import java.lang.Thread;

/**
* Title: 测试类
* Description: 测试了由于改变属性而引起的事件发生
* Copyright: Copyright (c) 2005
* Company: cuijiang
* @author not attributable
* @version 1.0
*/
public class TestDemo
     implements DemoListener {
   private DemoSource ds;

   public TestDemo()
   {
     ds=new DemoSource();
     ds.addDemoListener(this);
     System.out.println("添加监听器完毕");
     try {
       Thread.sleep(3000);
       //改变属性,触发事件
       ds.setName("改变属性,触发事件");
     }
     catch (InterruptedException ex) {
       ex.printStackTrace();
     }

     ds.addDemoListener(this);
     System.out.println("添加监听器完毕2");
     try {
       Thread.sleep(3000);
       //改变属性,触发事件
       ds.setName("改变属性,触发事件2");
     }
     catch (InterruptedException ex) {
       ex.printStackTrace();
     }

     ds.removeDemoListener(this);
     System.out.println("添加监听器完毕3");
     try {
       Thread.sleep(3000);
       //改变属性,触发事件
       ds.setName("改变属性,触发事件3");
     }
     catch (InterruptedException ex) {
       ex.printStackTrace();
     }


   }

   public static void main(String args[])
   {

     new TestDemo();
   }

   /**
    * demoEvent
    *
    * @param dm DemoEvent
    * @todo Implement this test.DemoListener method
    */
   public void demoEvent(DemoEvent dm) {
     System.out.println("事件处理方法");
     System.out.println(dm.getName());
     dm.say();
   }
}

  --sunfruit

    用户自定义事件

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

java中的事件机制的参与者有3种角色：

1.event object：就是事件产生时具体的“事件”，用于listener的相应的方法之中，作为参数，一般存在于listerner的方法之中

2.event source：具体的接受事件的实体，比如说，你点击一个button，那么button就是eventsource，这样你必须使button对某些事件进行响应，你就需要注册特定的listener，比如说MouseEvent之中的MouseClicked方法，这时它就必须有了add方法

3.event listener：具体的进行监听的事件类，当有其对应的event object产生的时候，它就调用相应的方法，进行处理。在windows程序设计里边这种响应使用callback机制来实现的

首先，定义事件，使其继承java.util.EventObject类。(jdk使用1.6)

public class RunPerformEvent extends EventObject {

    /**
     * 序列化版本号
     */
    private static final long serialVersionUID = 1L;
   
    private Object objsource;
    private Object message;
   
    public RunPerformEvent(Object source,Object message) {
        super(source);
        // TODO Auto-generated constructor stub
        this.objsource = source;
        this.message = message;
    }
   
    public Object getObjsource() {
        return objsource;
    }

    public void setObjsource(Object objsource) {
        this.objsource = objsource;
    }

    public Object getMessage() {
        return message;
    }

    public void setMessage(Object message) {
        this.message = message;
    }
}

其次，定义事件监听实现 java.util.EventListener，包含对RunPerformEvent 事件的处理

public interface IRunPerformEventListener extends EventListener{
    void runMessageChanged(RunPerformEvent event); //自定义的实现方法
}

第三，定义事件监听管理类，实现对监听的添加，删除和启动

import java.util.ArrayList;
import java.util.List;
import com.szl.listenner.iface.IRunPerformEventListener;
import com.szl.listenner.model.RunPerformEvent;

public class ManagerListener {

    private List<IRunPerformEventListener> listeners = null;
   
    public ManagerListener()
    {
        this.listeners = new ArrayList<IRunPerformEventListener>();
    }   
   
    //添加一个监听
    public void addRunPerformEventListener(IRunPerformEventListener e)
    {
        this.listeners.add(e);
    }
   
    //删除一个监听
   
    public void deleteRunPerformEventListener(IRunPerformEventListener e)
    {
        this.listeners.remove(e);
    }
   
    //激活监听事件
    public void fireRunPerformEventListener(RunPerformEvent event)
    {
        for(IRunPerformEventListener listener : this.listeners)
        {
            listener.runMessageChanged(event);
        }
    }
}

第四步，添加监听事件，并调用测试

public class UseEventListener {
   
    ManagerListener ml;
    public UseEventListener()
    {
        ml =  new ManagerListener();
        ml.addRunPerformEventListener(new EventInterface());//添加自定义事件
    }
   
    //执行自定义事件的方法
    public void testListener(String str){
        ml.fireRunPerformEventListener(new RunPerformEvent(this,str)); //this 指本类，是将本类注入监听器
    }
   
    //内部类，实现监听
    private class EventInterface implements IRunPerformEventListener
    {
        public void runMessageChanged(RunPerformEvent event) {
            // TODO Auto-generated method stub
            do_runMessageChanged_actionevent(event);
        }
    }

    //触发自定义事件
    protected void do_runMessageChanged_actionevent(final RunPerformEvent e)
    {
        System.out.println("执行事件方法！"+e.getMessage());
    }
   
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        UseEventListener useEvent = new UseEventListener();
        useEvent.testListener("事件传过来的参数");
    }
}

ok。至此已写好一个自定义事件监听的例子。（好好学习，天天向上，一天一点进步！）