爪哇 - 信号事件模式 [英] Java - Signals events Pattern

问题描述

我的灵感来自信号在AS3事件模式，即取代Flash的原生事件。它的工作要好得多，无论是在性能和​​可读性。

I been inspired by Signals events pattern in AS3, that replace the native events of flash. And it's work much better, both in performance and readability.

所以我试图用Java来实现它。

So I am trying to implement it in Java.

这种模式的主要思想是，你正在使用的对象，而不是类型，节约这个时间来找到调度员的类来处理你的事件调度（调度事件发送事件给所有的听众）

the main Idea of this pattern is that you are working with objects instead of types, saving by this the time to find the "Dispatcher" class to handle your event dispatch.(Dispatching event is sending event to all the listeners)

所以，让我们跳进code： 在这个示例中，我将创建AlarmManager和处理他的报警事件。

So lets jump into the code: In this sample I will create AlarmManager and handle his alarm event.

首先，我们需要创建我们的接口为这个事件

First we need to create our Interface for this event

public interface IAlarmEvent {
    void alarmEventHandler(String alert);
}

现在事件本身：

public class AlarmEvent extends Signal<IAlarmEvent> implements IAlarmEvent {

    public void alarmEventHandler(String alert) {
        dispatch("alarmEventHandler", alert);
    }
}

这里是AlarmManger：

And here is the AlarmManger:

public class AlarmManager {

    public final AlarmEvent alarmEvent = new AlarmEvent();

    public void init(){
        // Dispatching the event
        alarmEvent.alarmEventHandler("Wake up");
    }

}

下面是一个活动是谁监听此事件：

Here is an Activity who is listening for this event:

public class MainActivity extends Activity implements IAlarmEvent{

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        AlarmManager alarmManager = new AlarmManager();
        alarmManager.alarmEvent.addListener(this);

        alarmManager.init();
    }

    public void alarmEventHandler(String alert) {
        Log.d("MyLog", "Event : " + alert);
    }
}

这是我写的信号类

public abstract class Signal<T> {
    private LinkedHashMap<T, T> listeners = new LinkedHashMap<T, T>();

    protected void dispatch(String methodName, Object...arguments){
        Set<T> keySet = listeners.keySet();
        if(keySet.size() == 0){
            return;
        }

        Iterator<T> iterator = keySet.iterator();

        Method method = null;
        do{
            T listener = iterator.next();
            if(method == null){
                try {
                    Class<?>[] classes = new Class<?>[arguments.length];
                    for(int i = 0; i < arguments.length; i++){
                        classes[i] = arguments[i].getClass();
                    }
                    method = listener.getClass().getMethod(methodName, classes);
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                }
            }

            try {
                method.invoke(listener, arguments);
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }

        }while(iterator.hasNext());
    }

    public void addListener(T listener) {
        listeners.put(listener, listener);
    }

    public void removeListener(T listener) {
        listeners.remove(listener);
    }
}

此模式是：

• 快 - 无需搜索的类型和触发的EventDispatcher，它立即进行。
• 有很大的可读性 - 只要看一眼的类，你确切地知道事件，他派遣，以及每个事件看起来像
。

但它不尽如人意。如果我使用的原语对我的接口，信号未能找到方法，并调用它。而且我不喜欢这个想法传递方法名称的信号。任何想法如何改进呢？您怎么看待这个模式？

However it's not working well. If I am using primitives for my interface, the Signal fails to find the Method and invoke it. And I don't like the idea passing the Method name to the signal. Any Ideas how to improve this? And what do you think about this pattern?

推荐答案

好像这种模式在这些类已经实现了。

Seems like this pattern is already implemented in these classes

 java.util.Observable
 java.util.Observer

这篇关于爪哇 - 信号事件模式的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！