Java에서 일종의 이벤트 프레임 워크를 만드는 방법은 무엇입니까?

GUI가 없습니다 (제 수업은 Minecraft Mod의 일부입니다). C # 이벤트 프레임 워크를 모방 할 수 있기를 원했습니다. 클래스는 이벤트를 선언하고 다른 사람들이 이벤트를 구독 할 수 있도록합니다.

내 첫 번째 접근 방식은라는 클래스 EventArgs를 만든 다음 다음과 같이하는 것이 었습니다 .

public class EventArgs
{
    public boolean handled;
}

@FunctionalInterface
public interface IEventHandler<TEvtArgs extends EventArgs>
{
    public void handle(Object source, TEvtArgs args);
}

public class Event<TEvtArgs extends EventArgs>
{
    private final Object owner;
    private final LinkedList<IEventHandler<TEvtArgs>> handlers = new LinkedList<>();

    public Event(Object owner)
    {
        this.owner = owner;
    }

    public void subscribe(IEventHandler<TEvtArgs> handler)
    {
        handlers.add(handler);
    }

    public void unsubscribe(IEventHandler<TEvtArgs> handler)
    {
        while(handlers.remove(handler));
    }

    public void raise(TEvtArgs args)
    {
        for(IEventHandler<TEvtArgs> handler : handlers)
        {
            handler.handle(owner, args);
            if(args.handled)
                break;
        }
    }
}

그런 다음 클래스는 다음과 같이 할 것입니다.

public class PropertyChangedEvtArgs extends EventArgs
{
    public final Object oldValue;
    public final Object newValue;

    public PropertyChangedEvtArgs(final Object oldValue, final Object newValue)
    {
        this.oldValue = oldValue;
        this.newValue = newValue;
    }
}

public class SomeEventPublisher
{
    private int property = 0;
    private final Random rnd = new Random();
    public final Event<PropertyChangedEvtArgs> PropertyChanged = new Event<>(this);

    public void raiseEventOrNot(int value)
    {
        if(rnd.nextBoolean())//just to represent the fact that the event is not always raised
        {
            int old = property;
            property = value;
            PropertyChanged.raise(new PropertyChangedEvtArgs("old(" + old + ")", "new(" + value + ")"));
        }                
    }
}

public class SomeSubscriber
{
    private final SomeEventPublisher eventPublisher = new SomeEventPublisher();

    public SomeSubscriber()
    {
        eventPublisher.PropertyChanged.subscribe(this::handlePropertyAChanges);
    }

    private void handlePropertyAChanges(Object source, PropertyChangedEvtArgs args)
    {
        System.out.println("old:" + args.oldValue);
        System.out.println("new:" + args.newValue + "\n");
    }

    public void someMethod(int i)
    {
        eventPublisher.raiseEventOrNot(i);
    }
}

public class Main
{
    private static final SomeSubscriber subscriber = new SomeSubscriber();

    public static void main(String[] args)
    {
        for(int i = 0; i < 10; ++i)
        {
            subscriber.someMethod(i);
        }
    }
}

이 순진한 접근 방식의 가장 큰 문제 raise는 공개적 으로 노출 하여 적절한 캡슐화를 깨뜨리는 것 입니다. 나는 그 주변의 길을 볼 수 없으며 아마도 내 전체 패턴이 잘못되었을 수 있습니다. 몇 가지 아이디어를 원합니다.

관련 문제도있다 : 나는 이벤트가 즉시 제기 할 싶습니다 후 그 수익을 올리는 방법. 스레드 또는 다른 구성을 사용하여 이것을 동기화하는 방법이 있습니까? 물론 호출자 코드는 동기화 작업에 포함될 수 없습니다. 완전히 투명해야합니다.