Java Listener: A Java Bedtime Story

package com.steven.demo;  

import java.util.EventListener;
import java.util.EventObject;  

public interface StevenEventListener extends EventListener {
    public void doListen(EventObject e);
}

package com.steven.demo;
public interface IAppraisable {
    public void appraise(String name, int degree);
}

package com.steven.demo;
import java.util.EventObject;
public class WorkEvent extends EventObject {  

    private String eventMsg = "Do Work";  

    public String getEventMsg() {
        return eventMsg;
    }
    public void setEventMsg(String eventMsg) {
        this.eventMsg = eventMsg;
    }  

    private static final long serialVersionUID = 6232430258434094316L;
    /**
     * @param source Event source
     */
    public WorkEvent(Object source) {
        super(source);
    }
}

package com.steven.demo;
import java.util.EventObject;
public abstract class LifeEvent extends EventObject {
    public abstract String getEventMsg();  

    public LifeEvent(Object source) {
        super(source);
    }
    private static final long serialVersionUID = -5117554641874171524L;
}

package com.steven.demo;
public class BornEvent extends LifeEvent {
    private String eventMsg = "Birth";  

    public String getEventMsg() {
        return eventMsg;
    }
    public void setEventMsg(String eventMsg) {
        this.eventMsg = eventMsg;
    }
    public BornEvent(Object source) {
        super(source);
    }
    private static final long serialVersionUID = 8880371520168303175L;
}

package com.steven.demo;
public class DieEvent extends LifeEvent {
    public DieEvent(Object source) {
        super(source);
    }
    private String eventMsg = "Death";
    public String getEventMsg() {
        return eventMsg;
    }
    public void setEventMsg(String eventMsg) {
        this.eventMsg = eventMsg;
    }
    private static final long serialVersionUID = 5643693360168396103L;
}

package com.steven.demo;
import java.util.EventObject;
public class Boss implements StevenEventListener{  

    /**
     * WorkEvent Listen
     */
    @Override
    public void doListen(EventObject e) {
        if(e instanceof WorkEvent){
            System.out.println("Boss"+e.getSource()+"work started!");  

            try {
                Thread.currentThread().sleep(500);
            } catch (InterruptedException e1) {
            }  

            Object source = e.getSource();
            if(source instanceof IAppraisable){
                IAppraisable ia = (IAppraisable)source;
                //Rating  
                ia.appraise("Boss", 5);
            }
        }
    }  

}

package com.steven.demo;  

import java.util.EventObject;  

public class God implements StevenEventListener {  

    @Override
    public void doListen(EventObject e) {
        if (e instanceof LifeEvent) {
            LifeEvent de = (LifeEvent) e;
            System.out.println("God:(Life Time)" + de.getSource() + de.getEventMsg());
        }  

        if (e instanceof WorkEvent) {
            WorkEvent de = (WorkEvent) e;  

            System.out.println("God:(Work Time)" + de.getSource() + de.getEventMsg());  

            try {
                Thread.currentThread().sleep(1000);
            } catch (InterruptedException e1) {
            }  

            Object source = e.getSource();
            if(source instanceof IAppraisable){
                IAppraisable ia = (IAppraisable)source;
                ia.appraise("God", 6);
            }
        }
    }
}

package com.steven.demo;  

import java.util.EventObject;  

public class Satan implements StevenEventListener {  

    @Override
    public void doListen(EventObject e) {
        if (e instanceof DieEvent) {
            DieEvent de = (DieEvent) e;
            System.out.println("Satan:" + de.getSource() + de.getEventMsg());
        }
    }  

}

package com.steven.demo;
import java.util.EventObject;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;  

public class Worker implements IAppraisable {
    private String name;
    private Map<Class<? extends EventObject>, List<StevenEventListener>> listenerMap;
    public Worker(String name) {
        this.name = name;
        listenerMap = new HashMap<Class<? extends EventObject>, List<StevenEventListener>>();
    }
    @Override
    public String toString() {
        return name;
    }
    // add Listener
    public synchronized void addListener(StevenEventListener listener,
            Class<? extends EventObject>... eventClass) {
        if (null != listenerMap) {
            if (eventClass.length <= 0) {
                throw new RuntimeException("Please specify an event to listen!");
            } else {
                for (int i = 0; i < eventClass.length; i++) {
                    Class<? extends EventObject> e = eventClass[i];
                    List<StevenEventListener> list = null;
                    if (listenerMap.containsKey(e)) {
                        list = listenerMap.get(e);
                    }
                    if (null == list) {
                        list = new LinkedList<StevenEventListener>();
                    }
                    if (list.contains(listener)) {  

                        continue;
                    }
                    list.add(listener);
                    listenerMap.put(e, list);
                }
            }
        }
    }
    // Remove Event Listener  
    public synchronized void removeEventListener(StevenEventListener listener,
            Class<? extends EventObject>... eventClass) {
        if (null != listenerMap) {
            if (eventClass.length <= 0) {
                for (Map.Entry<Class<? extends EventObject>, List<StevenEventListener>> entry : listenerMap
                        .entrySet()) {
                    List<StevenEventListener> list = entry.getValue();
                    if (null != list) {
                        list.remove(listener);
                    }
                }
            } else {
                for (int i = 0; i < eventClass.length; i++) {
                    Class<? extends EventObject> e = eventClass[i];
                    if (listenerMap.containsKey(e)) {
                        List<StevenEventListener> list = listenerMap.get(e);
                        if (null != list) {
                            list.remove(listener);
                        }
                    }
                }
            }
        }
    }
    public synchronized void removeListener(StevenEventListener listener) {
        if (null != listenerMap) {
        }
    }  

    public synchronized void removeAllListener() {
        if (null != listenerMap) {
            listenerMap.clear();
        }
    }  

    public void doEvent(final EventObject e) {
        if (null != listenerMap) {
            for (Map.Entry<Class<? extends EventObject>, List<StevenEventListener>> entry : listenerMap
                    .entrySet()) {
                if (entry.getKey().isInstance(e)) {
                    if (null != entry.getValue()) {
                        for (final StevenEventListener stevenEventListener : entry
                                .getValue()) {
                            if (null != stevenEventListener) {
                                // stevenEventListener.doListen(e);  

                                Thread t = new Thread(new Runnable() {
                                    public void run() {
                                        stevenEventListener.doListen(e);
                                    }
                                });  

                                // t.setDaemon(true);  

                                t.start();  

                                // try {  
                                // t.join();
                                // } catch (InterruptedException e1) {  
                                // }  
                            }
                        }
                    }
                }
            }
        }
    }  

    public void work() {
        System.out.println("@ I have been working!");
        doEvent(new WorkEvent(this));
    }
    public void born() {
        System.out.println("@ I was born in!");
        doEvent(new BornEvent(this));
    }
    public void die() {
        System.out.println("@ I am dead!");
        doEvent(new DieEvent(this));
    }  

    @Override
    public void appraise(String name, int degree){
        System.out.println(name+"evaluation Level"+degree);
    }  

}

package com.steven.demo;
public class Run {
    public static void main(String[] args) {
        System.out.println("\t Beginning of the process");  

        Worker worker = new Worker("My name");
        Boss boss = new Boss();
        God god = new God();
        Satan satan = new Satan();
        //The boss is only concerned with the work 
        worker.addListener(boss, WorkEvent.class);
        worker.addListener(god, WorkEvent.class, LifeEvent.class);
        worker.addListener(satan, DieEvent.class);
        worker.work();
        worker.born();
        worker.die();
        System.out.println("\t End of the process");
    }
}