This is now an inbuilt feature in my new library, Redemptive https://github.com/Twister915/redemptive After using this pattern for the last few months, I've really found myself stunned at how much this simplifies. Check out, for example, the prompting system in commands. So few lines for such a cool feature! Today I wanted to demonstrate a new method for handling events entirely. I present- RxJavaBukkit- which is more of an idea than an implementation. I encountered RxJava a few months ago and started toying around with it. It was quite an interesting system- providing me with a whole new perspective when it came to the way I modeled my programs. Have a look for yourself if you want the detailed, but I'll give you a short (and graphical) rundown of what the philosophy is and how it relates to Bukkit. Below is a diagram explaining what an "observable" is. Imagine, for a moment, a "stream" of events of a particular type. This stream of events are "emitted" at certain times in a certain order. Time can be represented as a line, and the events can be represented as items on the line. This philosophy can be applied to Bukkit. We can make Bukkit's events emit themselves this way. In a way, this is already how it works, but the semantics are where the real improvement is needed. The major problem with Bukkit's listener system is the semantic design. Reflectively calling annotated methods is, in practice, easy for both the user and the programmer. However, you lack the control that an observable stream could provide. Allow me to demonstrate some of the powerful semantic features you have with this method of event observation: First, let's start with a basic PlayerJoinEvent listener, which should send Twister a message when he joins. Notice a few key advantages over Bukkit's inbuilt event handling system. You can filter, map, and do other operations who's origins are in functional programming. If you use the Java 8 stream system, you'll be familiar with this. Also notice, importantly, that when you subscribe to an observable, you are handed a subscription object, which can be used to unsubscribe from an observable, and thus unsubscribe your listener (if your implementation does this properly). Next, let's have a look at a few of the even more powerful operators- those that operate with time in mind. (notice also this is written without the use of lambdas so that this plugin could run on Java 7) Notice the "sample" operator. This operator takes the first event that occurs, then does not send any more until 500ms has passed, at which time it will emit the next and repeat this process. This is documented well by rxjava, so I'll link you there: http://reactivex.io/documentation/operators/sample.html Now let's spice it up a bit: I need to create a feature where users are not allowed to fly if they: * "can no longer fly" after moving. This typically means they walk out of faction territory. * Engage in PvP at any time while flying. Here's the RxJava implementation of this task: Notice a few key operators: * Sample, from before * merge, which merges two observables together. * takeWhile- an operator which checks a condition, and if it's found to be false, causes the subscription to automatically unsubscribe (which unregisters the listener from Bukkit) * take(1)- an operator which allows you to specify how many events you want sent to you. In this case, we only care about the first given to us, so we only ask for one. Then, like takeWhile, when there are no more events to come, the Subscription unsubscribes. Now, because we merged, the stream will only take whichever event comes first, of either type (the move event that occurred when you could no longer fly, or the damage event where either the damager or the entity was the target player) because the take(1) call is on the merged stream, not any particular one. I should also mention that you can easily design this to listen to many types of events simply, without merges. Take this for example: This is not difficult to implement and is demonstrated in my implementation. So, hopefully the power in this is illustrated well by my post, I'll toss up a copy of my implementation but I recommend you attempt to implement your own to get a better understanding of RxJava. Mine will not be packaged, except for in a gist. https://gist.github.com/Twister915/bd053583ffbb7a4d1e7f The implementation is the bridge between these ideas and Bukkit's API. It provides a class, EventStreamer, which has methods to listen to events. Some credit is given to: https://github.com/rmichela/rxjava-bukkit I rewrote all of this stuff in my gist myself, but this was my guide when I was first figuring this stuff out myself from scratch. Thanks Ryan Michela, you glorious bastard!