正如this SO答案和同一问题中的其他帖子中已经提到的那样,可以使用接口或Java FuncationInterfaces.
但是,我希望在Java中实现适当的事件模型,而不是委托模型。有关两者的区别的简要介绍,请参见this。尤其是第一条评论。
以下是我到目前为止尝试过的内容:
Event.java
public class Event {
public interface EventHandler{
void invoke();
}
private Set<EventHandler> mEventHandlers = new HashSet<>();
public void add(EventHandler eventHandler){
mEventHandlers.add(eventHandler);
}
public void remove(EventHandler eventHandler){
mEventHandlers.remove(eventHandler);
}
public void invoke(){
for(EventHandler eventHandler : mEventHandlers){
if(eventHandler!=null) {
eventHandler.invoke();
}
}
}
}
EventPubisher.java
public class EventPublisher {
public Event ValueUpdatedEvent;
public void UpdateValue(){
ValueUpdatedEvent.invoke();
}
}
EventConsumer.java
public class EventConsumer {
EventPublisher ep = new EventPublisher();
public EventConsumer(){
ep.ValueUpdatedEvent.add(this::ValueUpdatedEventHandler);
}
private void ValueUpdatedEventHandler(){
// do stuff
}
}
这种设计的问题是我也可以编写如下代码:
public class EventConsumer {
.....
private void abuse(){
ep.ValueUpdatedEvent.invoke();
}
}
这尤其是事件所限制的。该事件仅应从声明类中提出,而不应从外部提出。
答案 0 :(得分:0)
正如@Jon Skeet在评论中提到的那样,如下更改代码符合我的要求:
EventPubisher.java
public class EventPublisher {
private final Event ValueUpdatedEvent = new Event();
public void addEventHandler(Event.EventHandler eventHandler){
ValueUpdatedEvent.add(eventHandler);
}
public void removeEventHandler(Event.EventHandler eventHandler){
ValueUpdatedEvent.remove(eventHandler);
}
public void UpdateValue(){
ValueUpdatedEvent.invoke();
}
}
EventConsumer.java
public class EventConsumer {
.....
private void abuse(){
// ep.ValueUpdatedEvent.invoke(); //Compilation error
}
}
答案 1 :(得分:0)
如果您想避免在发布者上使用添加/删除方法,可以使用下面的代码吗?它使用两个类(Event和EventImpl)来分隔添加/删除和调用,因此可以将调用设为发布者私有。它是通用的,因此可以使用不同的侦听器接口。
此代码可以节省很多重复的样板,但是您认为它会被视为惯用的@JonSkeet吗?
以下是事件类别:
class Event<TListener> {
private final Set<TListener> listeners;
Event(Set<TListener> listeners) {
this.listeners = listeners;
}
public void add(TListener listener) {
listeners.add(listener);
}
public void remove(TListener listener) {
listeners.remove(listener);
}
}
class EventImpl<TListener> {
private Set<TListener> listeners = new HashSet<>();
private Event<TListener> event = new Event<>(listeners);
Event<TListener> getEvent() {
return event;
}
interface Invoker<TListener> {
void invoke(TListener listener);
}
public void invoke(Invoker<TListener> invoker) {
for (TListener listener : listeners){
if (listener != null) {
invoker.invoke(listener);
}
}
}
}
这是一个发布者和订阅者的示例,其中包含一些测试代码来练习它们:
class MyEventPublisher {
interface Listener {
void listenToThis(int intArg, String stringArg, Object... etc);
}
private EventImpl<Listener> eventImpl = new EventImpl<>();
Event<Listener> getEvent() {
return eventImpl.getEvent();
}
void somethingCausingAnEvent() {
eventImpl.invoke(
listener -> listener.listenToThis(1, "blah", 10,11, 12));
}
}
class MyEventSubscriber {
private String eventRecord = "";
MyEventSubscriber(MyEventPublisher publisher) {
publisher.getEvent().add(
(intArg, stringArg, etc) -> eventRecord += intArg + stringArg + Arrays.toString(etc));
}
String getEventRecord() {
return eventRecord;
}
}
public class TestEvents {
@Test
public void testEvent() {
MyEventPublisher p = new MyEventPublisher();
MyEventSubscriber s = new MyEventSubscriber(p);
p.somethingCausingAnEvent();
assertEquals("1blah[10, 11, 12]", s.getEventRecord());
}
}