Compare commits

...

112 Commits

Author SHA1 Message Date
Kai S. K. Engelbart cc5c07079a
Merge pull request 'Handler Caching' (#37) from f/handler-caching into develop
zdm/event-bus/pipeline/head This commit looks good Details
Reviewed-on: https://git.kske.dev/zdm/event-bus/pulls/37
Reviewed-by: delvh <leon@kske.dev>
2022-01-18 17:11:38 +01:00
Kai S. K. Engelbart 8fae4f6d76
Remove print statements from test
zdm/event-bus/pipeline/head This commit looks good Details
2022-01-18 17:09:21 +01:00
Kai S. K. Engelbart 2d276a1d74
Compare listener using equals() during removal 2022-01-18 17:09:05 +01:00
Kai S. K. Engelbart 8609c6a90c
Simplify binding cache usage
zdm/event-bus/pipeline/head This commit looks good Details
2022-01-18 15:00:18 +01:00
Kai S. K. Engelbart ee9d08b2b8
Test binding cache
zdm/event-bus/pipeline/head This commit looks good Details
2022-01-18 13:44:33 +01:00
Kai S. K. Engelbart 5468bddb35
Add handler cache
zdm/event-bus/pipeline/head This commit looks good Details
The cache has the same structure as the bindings and is updated
accordingly. To ensure the correctness and efficiency of the cache, more
testing has to be conducted.
2022-01-14 15:44:21 +01:00
Kai S. K. Engelbart a8d858e8c7
Merge pull request 'Remove USE_PARAMETER' (#35) from f/remove-use-parameter into develop
zdm/event-bus/pipeline/head This commit looks good Details
Reviewed-on: https://git.kske.dev/zdm/event-bus/pulls/35
Reviewed-by: delvh <leon@kske.dev>
2022-01-13 14:40:13 +01:00
Kai S. K. Engelbart 6ee4e11161
Fix inconsistent test
zdm/event-bus/pipeline/head This commit looks good Details
2022-01-12 20:17:24 +01:00
Kai S. K. Engelbart 8615a0e021
Fix Event Bus Proc module name
zdm/event-bus/pipeline/head There was a failure building this commit Details
2022-01-12 20:10:44 +01:00
Kai S. K. Engelbart 3aef7d5bcb
Only update handler accessibility if necessary
zdm/event-bus/pipeline/head This commit looks good Details
2022-01-12 20:04:02 +01:00
Kai S. K. Engelbart 36ed55fd71
Use void.class to determine how the event handler type is defined
zdm/event-bus/pipeline/head There was a failure building this commit Details
The dummy class USE_PARAMETER was necessary when the IEvent interface
still existed, as void.class could not be used as a Class<? extends
IEvent>. As no explicit reference to USE_PARAMETER should be present
anywhere, a proper deprecation would've made little sense.
2022-01-12 19:41:53 +01:00
Kai S. K. Engelbart 999a172e72
Merge pull request 'Inherit Event Handlers' (#34) from f/handler-inheritance into develop
zdm/event-bus/pipeline/head This commit looks good Details
Reviewed-on: https://git.kske.dev/zdm/event-bus/pulls/34
Reviewed-by: delvh <leon@kske.dev>
2022-01-12 17:19:57 +01:00
Kai S. K. Engelbart 722bf2b999
Test priorities for inheritance
zdm/event-bus/pipeline/head This commit looks good Details
2022-01-12 15:59:45 +01:00
Kai S. K. Engelbart 7fb633d69f
Inherit event handlers
zdm/event-bus/pipeline/head This commit looks good Details
When registering an event listener, Event Bus recursively walks the
entire inheritance tree and looks for event handlers.
2022-01-09 14:16:30 +01:00
Kai S. K. Engelbart c5607d12ae
Fix SonarQube scan
zdm/event-bus/pipeline/head This commit looks good Details
2022-01-09 11:49:10 +01:00
Kai S. K. Engelbart a8810c497f
Merge pull request 'Jenkinsfile with SonarQube Analysis' (#33) from f/jenkinsfile into develop
zdm/event-bus/pipeline/head There was a failure building this commit Details
Reviewed-on: https://git.kske.dev/zdm/event-bus/pulls/33
Reviewed-by: delvh <leon@kske.dev>
2022-01-09 11:32:25 +01:00
Kai S. K. Engelbart ebb2191f4a
Make unit tests package-private
zdm/event-bus/pipeline/head This commit looks good Details
2022-01-09 09:37:27 +01:00
Kai S. K. Engelbart 09d251a02a
Add Jenkinsfile
zdm/event-bus/pipeline/head This commit looks good Details
The Jenkinsfile performs packaging and testing on the project. When on
the develop branch, a SonarQube analysis is conducted.
2022-01-09 09:27:44 +01:00
Kai S. K. Engelbart 27d14a844d
Merge pull request 'Exception Wrapper' (#32) from f/exception-wrapper into develop
Reviewed-on: https://git.kske.dev/kske/event-bus/pulls/32
Reviewed-by: delvh <leon@kske.dev>
Reviewed-by: DieGurke <maxi@kske.dev>
2022-01-08 16:54:05 +01:00
Leon Hofmeister adbcc64e94
Add ExceptionWrapper documentation 2022-01-08 16:44:49 +01:00
Maximilian P. Käfer 84ae42b44f
Remove unnecessary new line 2022-01-08 15:02:35 +01:00
Kai S. K. Engelbart e53f356c54
Add exception wrapper with transparent delivery to the caller 2022-01-08 14:32:24 +01:00
Kai S. K. Engelbart d649f377b7
Merge pull request 'Shorten Module Names' (#30) from f/improve-project-structure into develop
Reviewed-on: https://git.kske.dev/kske/event-bus/pulls/30
Reviewed-by: delvh <leon@kske.dev>
2021-12-24 13:57:16 +01:00
Kai S. K. Engelbart 897f1a20f3
Shorten module names 2021-12-24 11:09:14 +02:00
Kai S. K. Engelbart 856a2e8cbf
Bump version to 1.2.0 2021-11-26 15:54:37 +01:00
Kai S. K. Engelbart 11860d1469
Merge pull request 'Document Latest Features in README' (#27) from f/improved-readme into develop
Reviewed-on: https://git.kske.dev/kske/event-bus/pulls/27
Reviewed-by: delvh <leon@kske.dev>
2021-11-26 13:54:58 +01:00
Kai S. K. Engelbart f620f06208
Merge branch 'develop' into f/improved-readme
Conflicts:
	event-bus-core/src/test/java/dev/kske/eventbus/core/DispatchTest.java
2021-11-25 14:36:07 +01:00
Kai S. K. Engelbart 5a6d8bcf35
Rename EventBus#printExecutionOrder(Class) to debugExecutionOrder
The method doesn't print anything, but rather returns a string
containing the debug information.
2021-11-25 14:34:13 +01:00
Kai S. K. Engelbart 39ffb5c82a
Fix module-info instructions in README
Reflective access has to be allowed from the Event Bus core package to a
package in the user's project, not the entire module. Thank you @delvh
for noticing this!
2021-11-25 14:29:06 +01:00
Kai S. K. Engelbart 5ddef71c26
Merge pull request 'Support JDK-style Javadoc Tags' (#28) from b/javadoc-tags into develop
Reviewed-on: https://git.kske.dev/kske/event-bus/pulls/28
Reviewed-by: delvh <leon@kske.dev>
2021-11-25 12:05:32 +01:00
Kai S. K. Engelbart 85b2da391a
Merge pull request 'Make Unit Tests Executable by Maven' (#29) from b/unit-test-execution into develop
Reviewed-on: https://git.kske.dev/kske/event-bus/pulls/29
Reviewed-by: delvh <leon@kske.dev>
2021-11-25 12:04:26 +01:00
Kai S. K. Engelbart 46a358da97
Make unit tests executable by Maven 2021-11-24 12:52:59 +01:00
Kai S. K. Engelbart 6bf9e1097a
Support JDK-style Javadoc tags 2021-11-24 11:30:36 +01:00
Kai S. K. Engelbart 3fccb809c8
Move installation section up in README 2021-11-24 10:49:30 +01:00
Kai S. K. Engelbart d1c4bcc7eb
Add callback listener section to README 2021-11-24 10:45:58 +01:00
Kai S. K. Engelbart ad29a93ccb
Add debugging section to README 2021-11-24 10:37:21 +01:00
Kai S. K. Engelbart e67b64678b
Merge pull request 'Add Callback Event Handling' (#26) from f/callback-handler into develop
Reviewed-on: https://git.kske.dev/kske/event-bus/pulls/26
Reviewed-by: delvh <leon@kske.dev>
2021-11-05 08:49:07 +01:00
Kai S. K. Engelbart c614beb063
Make CallbackEventHandler final 2021-11-04 15:55:24 +01:00
Kai S. K. Engelbart d3abb0aca3
Improve parameter naming for listener registration 2021-11-04 15:54:36 +01:00
Kai S. K. Engelbart ee688929fd
Add callback event handling
The EventHandler class has been converted to an interface, with the
reflection specific part being moved to the new ReflectiveEventHandler
class. Callback event handlers implement the same interface through the
CallbackEventHandler class.

The event handlers are defined in the new handler package, which is not
exported by the eventbus.core module.
2021-11-02 19:33:18 +01:00
Kai S. K. Engelbart 897d794b86
Merge pull request 'Handler Execution Order Debugging' (#25) from f/handler-introspection into develop
Reviewed-on: https://git.kske.dev/kske/event-bus/pulls/25
Reviewed-by: delvh <leon@kske.dev>
2021-11-02 09:03:10 +01:00
Kai S. K. Engelbart 40d48cb959
Merge pull request 'Improve Documentation in Code' (#24) from f/improved-documentation into develop
Reviewed-on: https://git.kske.dev/kske/event-bus/pulls/24
Reviewed-by: DieGurke <maxi@kske.dev>
2021-11-01 21:48:51 +01:00
Kai S. K. Engelbart b760c58298
Add a handler execution order debugging method 2021-11-01 21:36:24 +01:00
Kai S. K. Engelbart 872b395374
Rephrase some Javadoc
As suggested by @delvh.
2021-11-01 20:52:14 +01:00
Kai S. K. Engelbart 82c66c45ec
Improve EventBus Javadoc, make EventBusException final 2021-11-01 09:42:12 +01:00
Kai S. K. Engelbart 866a547114
Merge pull request 'Initialize the Default Event Bus Statically' (#23) from f/static-singleton-initialization into develop
Reviewed-on: https://git.kske.dev/kske/event-bus/pulls/23
Reviewed-by: delvh <leon@kske.dev>
2021-10-16 08:33:08 +02:00
Kai S. K. Engelbart 33ebf0302b
Initialize the default event bus statically
The previous method that used double checked synchronization offers
little performance benefits over a plain static initialization.

Reported-by @harkle-the-cake
2021-10-16 08:32:28 +02:00
Kai S. K. Engelbart b915a5c490
Merge pull request 'Properly Handle Nested Dispatches' (#19) from b/nested-dispatch into develop
Reviewed-on: https://git.kske.dev/kske/event-bus/pulls/19
Reviewed-by: delvh <leon@kske.dev>
2021-07-12 11:25:04 +02:00
Kai S. K. Engelbart 205a183db7
Allow nested dispatches by keeping track of nesting count 2021-07-12 10:24:48 +02:00
Kai S. K. Engelbart 74447dea59
Add nested dispatch test
The test performs a nested event dispatch then cancels the dispatch. If
Both operations are successful, the test is successful.

Currently, the test fails, but should be successful once the nested
dispatch bug is fixed.
2021-07-12 10:17:46 +02:00
Kai S. K. Engelbart 6eebd3c121
Pass errors caused during system event dispatch to caller
When an error is caused during the dispatch of a system event, a warning
has been logged instead instead of rethrowing the error. This has been
fixed.

This enables failing a JUnit test when an exception event handler is
invoked.
2021-07-07 22:06:07 +02:00
Kai S. K. Engelbart b758f4cef1
Remove obsolete paragraph from README 2021-04-04 10:09:12 +02:00
Kai S. K. Engelbart 0dcad7d178
Bump version to 1.1.0 2021-03-28 10:37:41 +02:00
Kai S. K. Engelbart c0cda7341b
Merge pull request 'Add @delvh as Contributor' (#15) from add-delvh-as-contributor into develop
Reviewed-on: https://git.kske.dev/kske/event-bus/pulls/15
Reviewed-by: delvh <leon@kske.dev>
2021-03-17 17:25:30 +01:00
Kai S. K. Engelbart b804243f4e
Add @delvh as contributor 2021-03-17 13:10:20 +01:00
Kai S. K. Engelbart 0aef1c299b
Change license to Apache-2.0
This should allow for more compatibility with other Java applications,
including proprietary ones.
2021-03-17 12:57:43 +01:00
Kai S. K. Engelbart 51f10c4144
Merge pull request 'Listener-Level Properties' (#13) from f/listener-level-properties into develop
Reviewed-on: https://git.kske.dev/kske/event-bus/pulls/13
Reviewed-by: delvh <leon@kske.dev>
2021-03-17 07:56:22 +01:00
Kai S. K. Engelbart f74b953db8
Replace hardcoded priority value by constant 2021-03-16 10:17:24 +01:00
Kai S. K. Engelbart 52719d22d4
Merge pull request 'Transparently Propagate Event Handler Errors' (#14) from b/error-passthrough into develop
Reviewed-on: https://git.kske.dev/kske/event-bus/pulls/14
Reviewed-by: delvh <leon@kske.dev>
Reviewed-by: DieGurke <maxi@kske.dev>
2021-03-16 08:17:41 +01:00
Kai S. K. Engelbart 122106bf39
Transparently propagate event handler errors
When an exception occurs during the execution of an event handler, it is
caught, wrapped inside an exception event and dispatched on the event
bus.

This applies to any throwable, but is not very useful for errors, as
these are not normally caught. Assertion errors in particular, which are
used in unit tests, should not be caught, as this would cause the test
runner to miss a failed test.

Therefore, errors are now transparently passed through to the caller of
the dispatch method.
2021-03-15 08:29:15 +01:00
Kai S. K. Engelbart 7357198d45
Warn about useless handler property redefinitions
When polymorphism or a priority is defined at listener-level and then
identically defined for a specific handler, a warning is issued.

This does not affect redefinitions of default values.
2021-03-14 14:38:43 +01:00
Kai S. K. Engelbart 32dfe64c0f
Add listener-level properties section to README 2021-03-14 11:44:56 +01:00
Kai S. K. Engelbart 2ec0a82a96
Respect listener-level properties 2021-03-14 11:18:11 +01:00
Kai S. K. Engelbart 6c74af608c
Allow @Polymorphic and @Priority on types, add value to @Polymorphic
This is the first step for listener level handler properties.

To allow a handler inside a polymorphic listener to be non-polymorphic,
the @Polymorphic annotation now has a boolean value that defaults to
true. In that case, it can be explicitly set to false to override the
listener-level default.
2021-02-22 19:12:06 +01:00
Kai S. K. Engelbart d9ddc0e1a9
Merge pull request 'Add ExceptionEvent' (#12) from f/exception-event into develop
Reviewed-on: https://git.kske.dev/kske/event-bus/pulls/12
Reviewed-by: delvh <leon@kske.dev>
Reviewed-by: DieGurke <maxi@kske.dev>
2021-02-21 14:04:26 +01:00
Kai S. K. Engelbart 7c3cd017de
Add system events section to README 2021-02-21 13:50:12 +01:00
Kai S. K. Engelbart 6a2cad4ae5
Add ExceptionEvent
An exception event wraps an event that caused an exception inside of an
event handler while being dispatched and is then dispatched to dedicated
handlers.
2021-02-21 10:36:06 +01:00
Kai S. K. Engelbart 0f9b64be48
Merge pull request 'Add DeadEvent' (#9) from f/dead-event into develop
Reviewed-on: https://git.kske.dev/kske/event-bus/pulls/9
Reviewed-by: delvh <leon@kske.dev>
Reviewed-by: DieGurke <maxi@kske.dev>
2021-02-21 09:16:32 +01:00
Kai S. K. Engelbart b2fe3a9d6c
Log unhandled dead events 2021-02-20 22:10:48 +01:00
Kai S. K. Engelbart 9379e6bb94
Merge pull request 'Additional Warnings in Event Bus Proc' (#8) from f/additional-warnings into develop
Reviewed-on: https://git.kske.dev/kske/event-bus/pulls/8
Reviewed-by: delvh <leon@kske.dev>
2021-02-20 21:46:08 +01:00
Kai S. K. Engelbart 0036dc4829
Add DeadEvent
A dead events wraps an event that was dispatched but not delivered to
any handler. The dead event is than dispatched to dedicated handlers.
2021-02-19 16:05:11 +01:00
Kai S. K. Engelbart 8a30493c52
Warn about unused event handler return values
If an event handler has a non-void return type, a warning is issued as
the event bus cannot use the returned value.

In rare cases this might be justified as the event handler could be
invoked directly.
2021-02-19 11:34:58 +01:00
Kai S. K. Engelbart b56f08e441
Warn about unnecessarily polymorphic event handlers
When Event Bus Proc detects a handler for a final type that uses the
@Polymorphic annotation, it issues a warning.
2021-02-19 11:30:09 +01:00
Kai S. K. Engelbart 4a5b94a9b7
Allow event handlers with non-void return type
Also removed unnecessary files from the Event Bus Proc JAR and
configured GPG signing as well as deployment to Sonatype OSSRH.
2021-02-19 11:14:43 +01:00
Kai S. K. Engelbart ff35e7f37d
Fix several edge cases in EventProcessor
When encountering an event handler with an invalid signature, the
processor doesn't crash anymore. Also, event parameters that aren't
objects are now reported as errors.
2021-02-17 08:22:48 +01:00
Kai S. K. Engelbart 1dd9e05c38
Rename event-bus-ap to event-bus-proc 2021-02-15 21:02:34 +01:00
Kai S. K. Engelbart 39c51c8953
Merge pull request 'Split @Event Parameters Into @Polymorphic and @Property, Remove Marker Interfaces' (#5) from f/new-annotations into develop
Reviewed-on: https://git.kske.dev/kske/event-bus/pulls/5
Reviewed-by: delvh <leon@kske.dev>
2021-02-15 20:38:18 +01:00
Kai S. K. Engelbart 002180ed3b
Remove EventListener and IEvent marker interfaces
This allows Event Bus to interface with existing classes without
modification.
2021-02-15 20:36:09 +01:00
Kai S. K. Engelbart 603fe80df6
Merge pull request 'Restructure Project, Add Annotation Processor' (#4) from f/annotation-processor into develop
Reviewed-on: https://git.kske.dev/kske/event-bus/pulls/4
Reviewed-by: delvh <leon@kske.dev>
2021-02-15 13:42:27 +01:00
Kai S. K. Engelbart cd2e7ad023
Rename Event#eventType to Event#value for more concise usage 2021-02-15 13:42:20 +01:00
Kai S. K. Engelbart 9b1c708514
Replace priority with @Priority
The new @Priority annotation serves the exact same purpose as
@Event(priority = ...), but should be easier to read in complex handler
declarations. It has to be used in conjunction with the @Event
annotation, not instead of it.
2021-02-15 12:06:33 +01:00
Kai S. K. Engelbart 3a6ebe9a19
Replace includeSubtypes with @Polymorphic
The new @Polymorphic annotation serves the exact same purpose as
@Event(includeSubtypes = true), but should be easier to read in complex
handler declarations. It has to be used in conjunction with the @Event
annotation, not instead of it.
2021-02-15 10:55:30 +01:00
Kai S. K. Engelbart e040f6ab1b
Simplify binding access calls in EventBus 2021-02-15 09:25:16 +01:00
Kai S. K. Engelbart ebc11555f6
Fix developer connection string in POM 2021-02-15 08:26:07 +01:00
Kai S. K. Engelbart 955e2d82b4
Add Event Bus AP section to README
Additionally bump version to 1.0.0 and adjust package names.
2021-02-14 21:48:24 +01:00
Kai S. K. Engelbart ab01845178
Refactor EventProcessor for improved readability 2021-02-14 21:29:06 +01:00
Kai S. K. Engelbart 023acb9172
Add simple annotation processor, generate shaded processor JAR 2021-02-14 14:34:19 +01:00
Kai S. K. Engelbart fd255d65cc
Rename event-bus module to event-bus-core, add event-bus-ap module
event-bus is now a parent project containing the two modules
event-bus-core (the previous event-bus) and event-bus-ap (annotation
processor).

The version of the parent project (and thus that of the modules) has
been bumped to 1.0.0, as this change breaks compatibility with previous
versions due to the different artifact, module and package names.
2021-02-09 09:52:26 +01:00
Kai S. K. Engelbart 9701e862df
Add parent project, convert existing project to Maven module 2021-02-08 19:30:37 +01:00
Kai S. K. Engelbart dcc578076a
Move project to subdirectory, adjust .gitignore 2021-02-08 18:49:37 +01:00
Kai S. K. Engelbart 883efed342
Update license in POM 2021-02-06 14:05:48 +01:00
Kai S. K. Engelbart 273531e352
Link the Maven repository in README 2021-01-08 09:45:07 +01:00
Kai S. K. Engelbart 8b1e3a8c4a
Rewrite a paragraph in README 2021-01-03 17:00:20 +01:00
Kai S. K. Engelbart d098b83d85
Change license to GPL-3.0 2021-01-03 15:29:36 +01:00
Kai S. K. Engelbart cc266ca408
Add CODE_OF_CONDUCT 2020-12-14 11:57:55 +01:00
Kai S. K. Engelbart 748cb8b71a
Merge pull request 'Add Event Cancellation' (#3) from f/cancel-event into develop
Reviewed-on: https://git.kske.dev/zdm/event-bus/pulls/3
2020-11-26 08:57:46 +01:00
Kai S. K. Engelbart 0e5f31b63e
Merge branch 'develop' into f/cancel-event
Conflicts:
	src/test/java/dev/kske/eventbus/EventBusTest.java
2020-11-26 08:16:01 +01:00
Kai S. K. Engelbart ec73be9046
Split EventBusTest into DispatchTest and CancelTest, add Javadoc 2020-11-26 08:14:11 +01:00
Kai S. K. Engelbart 659bd7888f
Simplify cancellation test, fix a typo 2020-11-25 08:35:51 +01:00
Leon Hofmeister 8aefb43823
Add Test for Cancellation 2020-11-23 23:42:17 +01:00
Leon Hofmeister 9d1707de5b
Add event consumption section to README 2020-10-11 11:31:51 +02:00
Kai S. K. Engelbart 1d2102d729
Add event cancellation mechanism to EventBus 2020-10-02 17:50:11 +02:00
Leon Hofmeister cd2598d5d3 Add Section About Static Methods in README (#2)
Add paragraph about static methods in README

Co-authored-by: kske <kai@kske.dev>
Reviewed-on: https://git.kske.dev/zdm/event-bus/pulls/2
Reviewed-by: kske <kai@kske.dev>
2020-09-26 09:59:08 +02:00
Leon Hofmeister f6e5c90a44
Add static event handler test 2020-09-25 16:22:27 +02:00
Kai S. K. Engelbart dbb816c6cb
Add double checked synchronization to EventBus instance initializer 2020-09-24 17:41:08 +02:00
Leon Hofmeister 603a838640 Add Missing Javadoc to EventBusException (#1)
Removed annoying Javadoc error
Reviewed-on: https://git.kske.dev/zdm/event-bus/pulls/1
Reviewed-by: kske <kai@kske.dev>
2020-09-23 20:55:16 +02:00
Kai S. K. Engelbart b6b73d335a
Add logging to EventBus using the Platform Logging API 2020-09-20 15:28:13 +02:00
Leon Hofmeister 8cf51441ad Add priority section to README 2020-09-20 14:35:50 +02:00
Kai S. K. Engelbart 001c0eea7e
Fix Maven plugin versions for sources and Javadoc, fix <ul> in Javadoc 2020-09-20 14:05:35 +02:00
Kai S. K. Engelbart ba06b49368
Add subtype inclusion for event handlers 2020-09-20 12:20:29 +02:00
Kai S. K. Engelbart 7a3debe444
Support parameter-less event handlers
- Add eventType value to Event
- Move semantic event handler checks to EventHandler
- Use Objects#requireNonNull(T) on public API method parameters
- Update README with a parameter-less event handlers section
2020-09-08 20:13:42 +02:00
Kai S. K. Engelbart 5f88ad6095
Add a module descriptor for the entire library 2020-09-08 17:06:45 +02:00
51 changed files with 2254 additions and 421 deletions

10
.gitignore vendored
View File

@ -1,2 +1,8 @@
/target/
/.settings/
# Maven build directories
target/
# Dependency reduced POM from Maven Shade Plugin
dependency-reduced-pom.xml
# Eclipse settings directories
.settings/

View File

@ -5,11 +5,6 @@
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.jdt.core.javabuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.m2e.core.maven2Builder</name>
<arguments>
@ -17,7 +12,6 @@
</buildCommand>
</buildSpec>
<natures>
<nature>org.eclipse.jdt.core.javanature</nature>
<nature>org.eclipse.m2e.core.maven2Nature</nature>
</natures>
</projectDescription>

View File

@ -0,0 +1,5 @@
# Contributor Code of Conduct
This project adheres to No Code of Conduct. We are all adults. We accept anyone's contributions. Nothing else matters.
For more information please visit the [No Code of Conduct](https://nocodeofconduct.com) homepage.

41
Jenkinsfile vendored 100644
View File

@ -0,0 +1,41 @@
pipeline {
agent any
options {
ansiColor('xterm')
}
stages {
stage('Build') {
steps {
sh 'mvn -DskipTests clean package'
}
}
stage('Test') {
steps {
sh 'mvn test'
}
post {
always {
junit '*/target/surefire-reports/*.xml'
publishCoverage adapters: [jacocoAdapter(mergeToOneReport: true, path: '*/target/site/jacoco/jacoco.xml')]
}
}
}
stage('SonarQube Analysis') {
when {
branch 'develop'
}
steps {
withSonarQubeEnv('KSKE SonarQube') {
sh 'mvn sonar:sonar'
}
}
}
}
post {
success {
archiveArtifacts artifacts: '*/target/event-bus-*.jar'
}
}
}

26
LICENSE
View File

@ -1,19 +1,13 @@
MIT License Copyright (c) 2020 Kai S. K. Engelbart
Copyright 2021 Kai S. K. Engelbart
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is furnished
to do so, subject to the following conditions:
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
The above copyright notice and this permission notice (including the next
paragraph) shall be included in all copies or substantial portions of the
Software.
https://www.apache.org/licenses/LICENSE-2.0
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

242
README.md
View File

@ -3,33 +3,31 @@
## Introduction
This library allows passing events between different objects without them having a direct reference to each other.
Any class can be made an event by implementing the `IEvent` interface.
Any object can serve as an event.
Using an instance of the `EventBus` class, an instant of the event class can be dispatched.
Using an instance of the `EventBus` class, an instance of the event class can be dispatched.
This means that it will be forwarded to all listeners registered for it at the event bus.
In addition, a singleton instance of the event bus is provided by the `EventBus#getInstance()` method.
To listen to events, register event handling methods using the `Event` annotation.
For this to work, the method must have a return type of `void` and declare a single parameter of the desired event type.
Additionally, the class containing the method must implement the `EventListener` interface.
For this to work, the method must declare a single parameter of the desired event type.
Alternatively, a parameter-less event handler can be declared as shown [below](#parameter-less-event-handlers).
## A Simple Example
Lets look at a simple example: we declare the empty class `SimpleEvent` that implements `IEvent` and can thus be used as an event.
Lets look at a simple example: we declare the empty class `SimpleEvent` whose objects can be used as events.
```java
import dev.kske.eventbus.IEvent;
public class SimpleEvent implements IEvent {}
public class SimpleEvent {}
```
Next, an event listener for the `SimpleEvent` is declared:
```java
import dev.kske.eventbus.*;
import dev.kske.eventbus.core.*;
public class SimpleEventListener implements EventListener {
public class SimpleEventListener {
public SimpleEventListener() {
@ -47,26 +45,226 @@ public class SimpleEventListener implements EventListener {
}
```
In this case, an event bus is created and used locally. In a more sophisticated example the class would acquire an external event bus that is used by multiple classes.
Note that creating static event handlers like this
```java
@Event
private static void onSimpleEvent(SimpleEvent event) { ... }
```
is technically possible, however you would still have to create an instance of the event listener to register it at an event bus.
## Installation
Event Bus is currently hosted at [kske.dev](https://kske.dev).
To include it inside your project, just add the Maven repository and the dependency to your `pom.xml`:
Event Bus is available in Maven Central.
To include it inside your project, just add the following dependency to your `pom.xml`:
```xml
<repositories>
<repository>
<id>kske-repo</id>
<url>https://kske.dev/maven-repo</url>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>dev.kske</groupId>
<artifactId>event-bus</artifactId>
<version>0.0.2</version>
<artifactId>event-bus-core</artifactId>
<version>1.2.0</version>
</dependency>
</dependencies>
```
Then, require the Event Bus Core module in your `module-info.java`:
```java
requires dev.kske.eventbus.core;
```
If you intend to use event handlers that are inaccessible to Event Bus by means of Java language access control, make sure to allow reflective access to your package for Event Bus:
```java
opens my.package to dev.kske.eventbus.core;
```
## Polymorphic Event Handlers
On certain occasions it's practical for an event handler to accept both events of the specified type, as well as subclasses of that event.
To include subtypes for an event handler, use the `@Polymorphic` annotation in addition to `@Event`:
```java
@Event
@Polymorphic
private void onSimpleEvent(SimpleEvent event) { ... }
```
## Event Handler Execution Order
Sometimes when using multiple handlers for one event, it might be useful to define in which order they will be executed.
Event Bus assigns a priority to every handler, which is `100` by default, but can be explicitly set using the `@Priority` annotation in addition to `@Event`:
```java
@Event
@Priority(250)
private void onSimpleEvent(SimpleEvent event) { ... }
```
**Important:**
Events are dispatched to handlers in descending order of their priority.
The execution order is undefined for handlers with the same priority.
## Parameter-Less Event Handlers
In some cases an event handler is not interested in the dispatched event instance.
To avoid declaring a useless parameter just to specify the event type of the handler, there is an alternative:
```java
@Event(SimpleEvent.class)
private void onSimpleEvent() {
System.out.println("SimpleEvent received!");
}
```
Make sure that you **do not** both declare a parameter and specify the event type in the annotation, as this would be ambiguous.
## Callback listeners
While defining event handlers as annotated methods is rather simple and readable, sometimes a more flexible approach is required.
For this reason, there are callback event handlers that allow the registration of an "inline" event listener consisting of just one handler in the form of a consumer:
```java
EventBus.getInstance().registerListener(SimpleEvent.class, e -> System.out.println("Received " + e));
```
The event type has to be defined explicitly, with the priority and polymorphism parameters being optional.
If you intend to remove the listener later, remember to keep a reference to it, as you would have to clear the entire event bus if you didn't.
## Listener-Level Properties
When defining a dedicated event listener that, for example, performs pre- or post-processing, all event handlers will probably have the same non-standard priority.
Instead of defining that priority for each handler, it can be defined at the listener level by annotating the listener itself.
The same applies to polymorphism.
## Event Consumption
In some cases it might be useful to stop the propagation of an event.
Event Bus makes this possible with event consumption:
```java
@Event(SimpleEvent.class)
@Priority(100)
private void onSimpleEvent() {
EventBus.getInstance().cancel();
}
@Event(SimpleEvent.class)
@Priority(50)
private void onSimpleEvent2() {
System.out.println("Will not be printed!");
}
```
In this example, the second method will not be executed as it has a lower priority and the event will not be propagated after consumption.
This applies to all event handlers that would have been executed after the one consuming the event.
**Important:**
Avoid cancelling events while using multiple event handlers with the same priority.
As event handlers are ordered by priority, it is not defined which of them will be executed after the event has been consumed.
## System Events
To accommodate for special circumstances in an event distribution, system events have been introduced.
At the moment, there are two system events, which are explained in this section.
### Detecting Unhandled Events
When an event is dispatched but not delivered to any handler, a dead event is dispatched that wraps the original event.
You can declare a dead event handler to respond to this situation:
```java
private void onDeadEvent(DeadEvent deadEvent) { ... }
```
### Detecting Exceptions Thrown by Event Handlers
When an event handler throws an exception, an exception event is dispatched that wraps the original event.
An exception handler is declared as follows:
```java
private void onExceptionEvent(ExceptionEvent ExceptionEvent) { ... }
```
Both system events reference the event bus that caused them and a warning is logged if they are unhandled.
#### Yeeting Exceptions Out of an Event Handler
In some cases, a warning about an `Exception` that was thrown in an event handler is not enough, stays unnoticed, or an exception should be catched explicitly.
Event Bus explicitly dispatches no `ExceptionEvent` when an `ExceptionWrapper` exception is thrown and instead simply rethrows it.
`ExceptionWrapper` is an unchecked exception that (as the name says) simply wraps an exception that caused it.
This means the following is possible and results in a normal program exit:
```java
@Event(String.class)
void onString() {
throw new ExceptionWrapper(new RuntimeException("I failed!"));
}
void helloStackTrace() {
EventBus.getInstance().registerListener(this);
try {
EventBus.getInstance().dispatch("A string!");
System.exit(-1);
} catch(ExceptionWrapper e) {
e.getCause().printStackTrace();
System.exit(0);
}
}
```
### What About Endless Recursion Caused By Dead Events and Exception Events?
As one might imagine, an unhandled dead event would theoretically lead to an endless recursion.
The same applies when an exception event handler throws an exception.
To avoid this, system events never cause system events and instead just issue a warning to the logger.
## Inheritance
When a superclass or an interface of an event listener defines event handlers, they will be detected and registered by Event Bus, even if they are `private`.
If an event handler is overridden by the listener, the `@Event` annotation of the overridden method is automatically considered present on the overriding method.
If the overridden method already contains an implementation in the superclass, the superclass implementation is ignored as expected.
The `@Priority` and `@Polymorphic` annotations are inherited both on a class and on a method level.
If the priority or polymorphism has to be redefined on an inherited handler, the `@Event` annotation has to be added explicitly.
## Debugging
In more complex setups, taking a look at the event handler execution order can be helpful for debugging.
Event Bus offers a method for this purpose which can be used as follows:
```java
System.out.println(EventBus.getInstance().debugExecutionOrder(SimpleEvent.class));
```
Then, the execution order can be inspected in the console.
## Compile-Time Error Checking with Event Bus Proc
To assist you with writing event listeners, the Event Bus Proc (Annotation Processor) module enforces correct usage of the `@Event` annotation during compile time.
This reduces difficult-to-debug bugs that occur during runtime to compile-time errors which can be easily fixed.
The event annotation processor detects invalid event handlers and event type issues with more to come in future versions.
When using Maven, it can be registered using the Maven Compiler Plugin:
```xml
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<annotationProcessorPaths>
<annotationProcessorPath>
<groupId>dev.kske</groupId>
<artifactId>event-bus-proc</artifactId>
<version>1.2.0</version>
</annotationProcessorPath>
</annotationProcessorPaths>
</configuration>
</plugin>
```
Alternatively, a JAR file containing the processor is offered with each release for the use within IDEs and environments without Maven support.

23
core/.project 100644
View File

@ -0,0 +1,23 @@
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>event-bus-core</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.jdt.core.javabuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.m2e.core.maven2Builder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.eclipse.jdt.core.javanature</nature>
<nature>org.eclipse.m2e.core.maven2Nature</nature>
</natures>
</projectDescription>

66
core/pom.xml 100644
View File

@ -0,0 +1,66 @@
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<artifactId>event-bus-core</artifactId>
<name>Event Bus Core</name>
<parent>
<groupId>dev.kske</groupId>
<artifactId>event-bus</artifactId>
<version>1.2.0</version>
</parent>
<dependencies>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>5.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<!-- Disable resource folder -->
<resources />
<plugins>
<!-- Run unit tests -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>3.0.0-M5</version>
<configuration>
<argLine>
${argLine}
--add-opens dev.kske.eventbus.core/dev.kske.eventbus.core=ALL-UNNAMED
--add-opens dev.kske.eventbus.core/dev.kske.eventbus.core.handler=ALL-UNNAMED
</argLine>
</configuration>
</plugin>
<!-- Generate coverage report -->
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.7</version>
<executions>
<execution>
<goals>
<goal>prepare-agent</goal>
</goals>
</execution>
<execution>
<id>report</id>
<phase>test</phase>
<goals>
<goal>report</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

View File

@ -0,0 +1,37 @@
package dev.kske.eventbus.core;
/**
* Wraps an event that was dispatched but for which no handler has been bound.
* <p>
* Handling dead events is useful as it can identify a poorly configured event distribution.
*
* @author Kai S. K. Engelbart
* @since 1.1.0
*/
public final class DeadEvent {
private final EventBus eventBus;
private final Object event;
DeadEvent(EventBus eventBus, Object event) {
this.eventBus = eventBus;
this.event = event;
}
@Override
public String toString() {
return String.format("DeadEvent[eventBus=%s, event=%s]", eventBus, event);
}
/**
* @return the event bus that dispatched this event
* @since 1.1.0
*/
public EventBus getEventBus() { return eventBus; }
/**
* @return the event that could not be delivered
* @since 1.1.0
*/
public Object getEvent() { return event; }
}

View File

@ -0,0 +1,34 @@
package dev.kske.eventbus.core;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.*;
/**
* Indicates that a method is an event handler.
* <p>
* To be successfully used as such, the method has to specify the event type by either declaring one
* parameter of that type or setting the annotation value to the corresponding class.
*
* @author Kai S. K. Engelbart
* @since 0.0.1
* @see Polymorphic
* @see Priority
*/
@Documented
@Retention(RUNTIME)
@Target(METHOD)
public @interface Event {
/**
* Defines the event type the handler listens for. If this value is set, the handler is not
* allowed to declare parameters.
* <p>
* This is useful when the event handler does not utilize the event instance.
*
* @return the event type accepted by the handler
* @since 1.0.0
*/
Class<?> value() default void.class;
}

View File

@ -0,0 +1,503 @@
package dev.kske.eventbus.core;
import java.lang.System.Logger;
import java.lang.System.Logger.Level;
import java.lang.annotation.Annotation;
import java.lang.reflect.*;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Consumer;
import dev.kske.eventbus.core.handler.*;
/**
* Event listeners can be registered at an event bus to be notified when an event is dispatched.
* <p>
* A singleton instance of this class can be lazily created and acquired using the
* {@link EventBus#getInstance()} method.
*
* @implNote This is a thread-safe implementation.
* @author Kai S. K. Engelbart
* @since 0.0.1
* @see Event
*/
public final class EventBus {
/**
* Holds the state of the dispatching process on one thread.
*
* @since 0.1.0
*/
private static final class DispatchState {
/**
* Indicates that the last event handler invoked has called {@link EventBus#cancel}. In that
* case, the event is not dispatched further.
*
* @since 0.1.0
*/
boolean isCancelled;
/**
* Is incremented when {@link EventBus#dispatch(Object)} is invoked and decremented when it
* finishes. This allows keeping track of nested dispatches.
*
* @since 1.2.0
*/
int nestingCount;
}
/**
* The priority assigned to every event handler without an explicitly defined priority.
*
* @since 1.1.0
* @see Priority
*/
public static final int DEFAULT_PRIORITY = 100;
private static final EventBus singletonInstance = new EventBus();
private static final Logger logger = System.getLogger(EventBus.class.getName());
/**
* Compares event handlers based on priority, but uses hash codes for equal priorities.
*
* @implNote As the priority comparator by itself is not consistent with equals (two handlers
* with the same priority are not necessarily equal, but would have a comparison
* result of 0), the hash code is used for the fallback comparison. This way,
* consistency with equals is restored.
* @since 1.2.0
*/
private static final Comparator<EventHandler> byPriority =
Comparator.comparingInt(EventHandler::getPriority).reversed()
.thenComparingInt(EventHandler::hashCode);
/**
* Returns the default event bus, which is a statically initialized singleton instance.
*
* @return the default event bus
* @since 0.0.2
*/
public static EventBus getInstance() {
return singletonInstance;
}
/**
* Event handler bindings (target class to handlers registered for that class), does not contain
* other (polymorphic) handlers.
*
* @since 0.0.1
*/
private final Map<Class<?>, TreeSet<EventHandler>> bindings = new ConcurrentHashMap<>();
/**
* A cache mapping an event class to all handlers the event should be dispatched to. This
* includes polymorphic handlers that don't reference the event class explicitly. If an event
* class is not contained inside this cache, the {@link #bindings} have to be traversed manually
* in search of applicable handlers.
*
* @since 1.3.0
*/
private final Map<Class<?>, TreeSet<EventHandler>> bindingCache = new ConcurrentHashMap<>();
/**
* Stores all registered event listeners (which declare event handlers) and prevents them from
* being garbage collected.
*
* @since 0.0.1
*/
private final Set<Object> registeredListeners = ConcurrentHashMap.newKeySet();
/**
* The current event dispatching state, local to each thread.
*
* @since 0.1.0
*/
private final ThreadLocal<DispatchState> dispatchState =
ThreadLocal.withInitial(DispatchState::new);
/**
* Dispatches an event to all event handlers registered for it in descending order of their
* priority.
*
* @param event the event to dispatch
* @throws EventBusException if an event handler isn't accessible or has an invalid signature
* @throws ExceptionWrapper if it is thrown by an event handler
* @throws NullPointerException if the specified event is {@code null}
* @since 0.0.1
*/
public void dispatch(Object event) {
Objects.requireNonNull(event);
logger.log(Level.INFO, "Dispatching event {0}", event);
// Look up dispatch state
var state = dispatchState.get();
// Increment nesting count (becomes > 1 during nested dispatches)
++state.nestingCount;
Iterator<EventHandler> handlers = getHandlersFor(event.getClass()).iterator();
if (handlers.hasNext()) {
while (handlers.hasNext())
if (state.isCancelled) {
logger.log(Level.INFO, "Cancelled dispatching event {0}", event);
state.isCancelled = false;
break;
} else {
try {
handlers.next().execute(event);
} catch (InvocationTargetException e) {
if (e.getCause() instanceof Error)
// Transparently pass error to the caller
throw (Error) e.getCause();
else if (e.getCause() instanceof ExceptionWrapper)
// Transparently pass exception wrapper to the caller
throw (ExceptionWrapper) e.getCause();
else if (event instanceof DeadEvent || event instanceof ExceptionEvent)
// Warn about system event not being handled
logger.log(Level.WARNING, event + " not handled due to exception", e);
else
// Dispatch exception event
dispatch(new ExceptionEvent(this, event, e.getCause()));
}
}
} else if (event instanceof DeadEvent || event instanceof ExceptionEvent) {
// Warn about the dead event not being handled
logger.log(Level.WARNING, "{0} not handled", event);
} else {
// Dispatch dead event
dispatch(new DeadEvent(this, event));
}
// Decrement nesting count (becomes 0 when all dispatches on the thread are finished)
--state.nestingCount;
logger.log(Level.DEBUG, "Finished dispatching event {0}", event);
}
/**
* Searches for the event handlers bound to an event class. This includes polymorphic handlers
* that are bound to a supertype of the event class.
*
* @implNote If the given event type was requested in the past, the handlers are retrieved from
* the {@link #bindingCache}. If not, the entire {@link #bindings} are traversed in
* search of polymorphic handlers compatible with the event type.
* @param eventType the event type to use for the search
* @return a navigable set containing the applicable handlers in descending order of priority
* @since 1.2.0
*/
private NavigableSet<EventHandler> getHandlersFor(Class<?> eventType) {
return bindingCache.computeIfAbsent(eventType, k -> {
// Get handlers defined for the event class
TreeSet<EventHandler> handlers =
bindings.getOrDefault(eventType, new TreeSet<>(byPriority));
// Get polymorphic handlers
for (var binding : bindings.entrySet())
if (binding.getKey().isAssignableFrom(eventType))
for (var handler : binding.getValue())
if (handler.isPolymorphic())
handlers.add(handler);
return handlers;
});
}
/**
* Cancels an event that is currently dispatched from inside an event handler.
*
* @throws EventBusException if the calling thread is not an active dispatching thread
* @since 0.1.0
*/
public void cancel() {
var state = dispatchState.get();
if (state.nestingCount > 0 && !state.isCancelled)
state.isCancelled = true;
else
throw new EventBusException("Calling thread not an active dispatching thread!");
}
/**
* Registers an event listener at this event bus.
*
* @param listener the listener to register
* @throws EventBusException if the listener is already registered or a declared event
* handler does not comply with the specification
* @throws NullPointerException if the specified listener is {@code null}
* @since 0.0.1
* @see Event
*/
public void registerListener(Object listener) {
Objects.requireNonNull(listener);
if (registeredListeners.contains(listener))
throw new EventBusException(listener + " already registered!");
logger.log(Level.INFO, "Registering event listener {0}", listener.getClass().getName());
boolean handlerBound = false;
// Predefined handler polymorphism
boolean polymorphic = false;
if (listener.getClass().isAnnotationPresent(Polymorphic.class))
polymorphic = listener.getClass().getAnnotation(Polymorphic.class).value();
// Predefined handler priority
int priority = DEFAULT_PRIORITY;
if (listener.getClass().isAnnotationPresent(Priority.class))
priority = listener.getClass().getAnnotation(Priority.class).value();
registeredListeners.add(listener);
for (var method : getHandlerMethods(listener.getClass())) {
Event annotation = method.getAnnotation(Event.class);
// Skip methods without annotations
if (annotation == null)
continue;
// Initialize and bind the handler
bindHandler(
new ReflectiveEventHandler(listener, method, annotation, polymorphic, priority));
handlerBound = true;
}
if (!handlerBound)
logger.log(
Level.WARNING,
"No event handlers bound for event listener {0}",
listener.getClass().getName());
}
/**
* Searches for event handling methods declared inside the inheritance hierarchy of an event
* listener.
*
* @param listenerClass the class to inspect
* @return all event handling methods defined for the given listener
* @since 1.3.0
*/
private Set<Method> getHandlerMethods(Class<?> listenerClass) {
// Get methods declared by the listener
Set<Method> methods = getMethodsAnnotatedWith(listenerClass, Event.class);
// Recursively add superclass handlers
Class<?> superClass = listenerClass.getSuperclass();
if (superClass != null && superClass != Object.class)
methods.addAll(getHandlerMethods(superClass));
// Recursively add interface handlers
for (Class<?> iClass : listenerClass.getInterfaces())
methods.addAll(getHandlerMethods(iClass));
return methods;
}
/**
* Searches for declared methods with a specific annotation inside a class.
*
* @param enclosingClass the class to inspect
* @param annotationClass the annotation to look for
* @return all methods matching the search criteria
* @since 1.3.0
*/
private Set<Method> getMethodsAnnotatedWith(Class<?> enclosingClass,
Class<? extends Annotation> annotationClass) {
var methods = new HashSet<Method>();
for (var method : enclosingClass.getDeclaredMethods())
if (method.isAnnotationPresent(annotationClass))
methods.add(method);
return methods;
}
/**
* Registers a callback listener, which is a consumer that is invoked when an event occurs. The
* listener is not polymorphic and has the {@link #DEFAULT_PRIORITY}.
*
* @param <E> the event type the listener listens for
* @param eventType the event type the listener listens for
* @param eventListener the callback that is invoked when an event occurs
* @since 1.2.0
* @see #registerListener(Class, Consumer, boolean, int)
*/
public <E> void registerListener(Class<E> eventType, Consumer<E> eventListener) {
registerListener(eventType, eventListener, false, DEFAULT_PRIORITY);
}
/**
* Registers a callback listener, which is a consumer that is invoked when an event occurs. The
* listener has the {@link #DEFAULT_PRIORITY}.
*
* @param <E> the event type the listener listens for
* @param eventType the event type the listener listens for
* @param eventListener the callback that is invoked when an event occurs
* @param polymorphic whether the listener is also invoked for subtypes of the event type
* @since 1.2.0
* @see #registerListener(Class, Consumer, boolean, int)
*/
public <E> void registerListener(Class<E> eventType, Consumer<E> eventListener,
boolean polymorphic) {
registerListener(eventType, eventListener, polymorphic, DEFAULT_PRIORITY);
}
/**
* Registers a callback listener, which is a consumer that is invoked when an event occurs. The
* listener is not polymorphic.
*
* @param <E> the event type the listener listens for
* @param eventType the event type the listener listens for
* @param eventListener the callback that is invoked when an event occurs
* @param priority the priority to assign to the listener
* @since 1.2.0
* @see #registerListener(Class, Consumer, boolean, int)
*/
public <E> void registerListener(Class<E> eventType, Consumer<E> eventListener, int priority) {
registerListener(eventType, eventListener, false, priority);
}
/**
* Registers a callback listener, which is a consumer that is invoked when an event occurs.
*
* @param <E> the event type the listener listens for
* @param eventType the event type the listener listens for
* @param eventListener the callback that is invoked when an event occurs
* @param polymorphic whether the listener is also invoked for subtypes of the event type
* @param priority the priority to assign to the listener
* @since 1.2.0
*/
public <E> void registerListener(Class<E> eventType, Consumer<E> eventListener,
boolean polymorphic,
int priority) {
Objects.requireNonNull(eventListener);
if (registeredListeners.contains(eventListener))
throw new EventBusException(eventListener + " already registered!");
logger.log(Level.INFO, "Registering callback event listener {0}",
eventListener.getClass().getName());
registeredListeners.add(eventListener);
bindHandler(new CallbackEventHandler(eventType, eventListener, polymorphic, priority));
}
/**
* Inserts a new handler into the {@link #bindings} map. Additionally, the handler is placed
* inside the {@link #bindingCache} where applicable.
*
* @param handler the handler to bind
* @since 1.2.0
*/
private void bindHandler(EventHandler handler) {
// Bind handler
logger.log(Level.DEBUG, "Binding event handler {0}", handler);
bindings.computeIfAbsent(handler.getEventType(), k -> new TreeSet<>(byPriority))
.add(handler);
// Insert handler into cache
bindingCache.computeIfAbsent(handler.getEventType(), k -> new TreeSet<>(byPriority))
.add(handler);
// Handler is polymorphic => insert where applicable
if (handler.isPolymorphic())
for (var binding : bindingCache.entrySet())
if (binding.getKey().isAssignableFrom(handler.getEventType()))
binding.getValue().add(handler);
}
/**
* Removes a specific listener from this event bus.
*
* @param listener the listener to remove
* @since 0.0.1
*/
public void removeListener(Object listener) {
Objects.requireNonNull(listener);
logger.log(Level.INFO, "Removing event listener {0}", listener.getClass().getName());
// Remove bindings from binding map
for (var binding : bindings.values()) {
var it = binding.iterator();
while (it.hasNext()) {
var handler = it.next();
if (handler.getListener().equals(listener)) {
logger.log(Level.DEBUG, "Unbinding event handler {0}", handler);
it.remove();
}
}
}
// Remove bindings from cache
for (var binding : bindingCache.values()) {
var it = binding.iterator();
while (it.hasNext()) {
var handler = it.next();
if (handler.getListener().equals(listener)) {
logger.log(Level.TRACE, "Removing event handler {0} from cache", handler);
it.remove();
}
}
}
// Remove the listener itself
registeredListeners.remove(listener);
}
/**
* Removes all event listeners from this event bus.
*
* @since 0.0.1
*/
public void clearListeners() {
logger.log(Level.INFO, "Clearing event listeners");
bindings.clear();
bindingCache.clear();
registeredListeners.clear();
}
/**
* Generates a string describing the event handlers that would be executed for a specific event
* type, in order and without actually executing them.
*
* @apiNote Using this method is only recommended for debugging purposes, as the output depends
* on implementation internals which may be subject to change.
* @implNote Nested dispatches are not accounted for, as this would require actually executing
* the handlers.
* @param eventType the event type to generate the execution order for
* @return a human-readable event handler list suitable for debugging purposes
* @since 1.2.0
*/
public String debugExecutionOrder(Class<?> eventType) {
var handlers = getHandlersFor(eventType);
var sj = new StringJoiner("\n");
// Output header line
sj.add(String.format("Event handler execution order for %s (%d handler(s)):", eventType,
handlers.size()));
sj.add(
"==========================================================================================");
// Individual handlers
for (var handler : handlers)
sj.add(handler.toString());
// Bottom line
sj.add(
"==========================================================================================");
return sj.toString();
}
/**
* Provides an unmodifiable view of the event listeners registered at this event bus.
*
* @return all registered event listeners
* @since 0.0.1
*/
public Set<Object> getRegisteredListeners() {
return Collections.unmodifiableSet(registeredListeners);
}
}

View File

@ -0,0 +1,39 @@
package dev.kske.eventbus.core;
/**
* This unchecked exception is specific to the event bus and can be thrown under the following
* circumstances:
* <ul>
* <li>An event handler throws an exception (which is stored as the cause)</li>
* <li>An event listener with an invalid event handler is registered</li>
* <li>{@link EventBus#cancel()} is invoked from outside an active dispatch thread</li>
* </ul>
*
* @author Kai S. K. Engelbart
* @since 0.0.1
*/
public final class EventBusException extends RuntimeException {
private static final long serialVersionUID = 7254445250300604449L;
/**
* Creates a new event bus exception.
*
* @param message the message to display
* @param cause the cause of this exception
* @since 0.0.1
*/
public EventBusException(String message, Throwable cause) {
super(message, cause);
}
/**
* Creates a new event bus exception.
*
* @param message the message to display
* @since 0.0.1
*/
public EventBusException(String message) {
super(message);
}
}

View File

@ -0,0 +1,47 @@
package dev.kske.eventbus.core;
/**
* Wraps an event that was dispatched but caused an exception in one of its handlers.
* <p>
* Handling exception events is useful as it allows the creation of a centralized exception handling
* mechanism for unexpected exceptions.
*
* @author Kai S. K. Engelbart
* @since 1.1.0
*/
public final class ExceptionEvent {
private final EventBus eventBus;
private final Object event;
private final Throwable cause;
ExceptionEvent(EventBus eventBus, Object event, Throwable cause) {
this.eventBus = eventBus;
this.event = event;
this.cause = cause;
}
@Override
public String toString() {
return String.format("ExceptionEvent[eventBus=%s, event=%s, cause=%s]", eventBus, event,
cause);
}
/**
* @return the event bus that dispatched this event
* @since 1.1.0
*/
public EventBus getEventBus() { return eventBus; }
/**
* @return the event that could not be handled because of an exception
* @since 1.1.0
*/
public Object getEvent() { return event; }
/**
* @return the exception that was thrown while handling the event
* @since 1.1.0
*/
public Throwable getCause() { return cause; }
}

View File

@ -0,0 +1,24 @@
package dev.kske.eventbus.core;
/**
* This unchecked exception acts as a wrapper for an arbitrary exception to prevent an
* {@link ExceptionEvent} from being dispatched. Instead, the wrapped exception is rethrown by
* {@link EventBus#dispatch(Object)}.
*
* @author Kai S. K. Engelbart
* @since 1.2.1
*/
public final class ExceptionWrapper extends RuntimeException {
private static final long serialVersionUID = -2016681140617308788L;
/**
* Creates a new exception wrapper.
*
* @param cause the exception to wrap
* @since 1.2.1
*/
public ExceptionWrapper(Exception cause) {
super(cause);
}
}

View File

@ -0,0 +1,31 @@
package dev.kske.eventbus.core;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.*;
/**
* Allows an event handler to receive events that are subtypes of the declared event type.
* <p>
* When used on a type, the value applies to all event handlers declared within that type that don't
* define a value on their own.
* <p>
* This is useful when defining an event handler for an interface or an abstract class.
*
* @author Kai S. K. Engelbart
* @since 1.0.0
* @see Event
*/
@Documented
@Inherited
@Retention(RUNTIME)
@Target({ METHOD, TYPE })
public @interface Polymorphic {
/**
* @return whether the event handler is polymorphic
* @since 1.1.0
*/
boolean value() default true;
}

View File

@ -0,0 +1,34 @@
package dev.kske.eventbus.core;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.*;
/**
* Defines the priority of an event handler. Handlers are executed in descending order of their
* priority.
* <p>
* When used on a type, the value applies to all event handlers declared within that type that don't
* define a value on their own.
* <p>
* Handlers without this annotation have the default priority of 100.
* <p>
* The execution order of handlers with the same priority is undefined.
*
* @author Kai S. K. Engelbart
* @since 1.0.0
* @see Event
*/
@Documented
@Inherited
@Retention(RUNTIME)
@Target({ METHOD, TYPE })
public @interface Priority {
/**
* @return the priority of the event handler
* @since 1.0.0
*/
int value();
}

View File

@ -0,0 +1,73 @@
package dev.kske.eventbus.core.handler;
import java.lang.reflect.InvocationTargetException;
import java.util.function.Consumer;
/**
* An event handler wrapping a callback method.
*
* @author Kai S. K. Engelbart
* @since 1.2.0
*/
public final class CallbackEventHandler implements EventHandler {
private final Class<?> eventType;
private final Consumer<Object> callback;
private final boolean polymorphic;
private final int priority;
/**
* Constructs a callback event handler.
*
* @param <E> the event type of the handler
* @param eventType the event type of the handler
* @param callback the callback method to execute when the handler is invoked
* @param polymorphic whether the handler is polymorphic
* @param priority the priority of the handler
* @since 1.2.0
*/
@SuppressWarnings("unchecked")
public <E> CallbackEventHandler(Class<E> eventType, Consumer<E> callback, boolean polymorphic,
int priority) {
this.eventType = eventType;
this.callback = (Consumer<Object>) callback;
this.polymorphic = polymorphic;
this.priority = priority;
}
@Override
public void execute(Object event) throws InvocationTargetException {
try {
callback.accept(event);
} catch (RuntimeException e) {
throw new InvocationTargetException(e, "Callback event handler failed!");
}
}
@Override
public String toString() {
return String.format(
"CallbackEventHandler[eventType=%s, polymorphic=%b, priority=%d]",
eventType, polymorphic, priority);
}
@Override
public Consumer<?> getListener() {
return callback;
}
@Override
public Class<?> getEventType() {
return eventType;
}
@Override
public int getPriority() {
return priority;
}
@Override
public boolean isPolymorphic() {
return polymorphic;
}
}

View File

@ -0,0 +1,53 @@
package dev.kske.eventbus.core.handler;
import java.lang.reflect.InvocationTargetException;
import dev.kske.eventbus.core.*;
/**
* Internal representation of an event handling method.
*
* @author Kai S. K. Engelbart
* @since 1.2.0
* @see EventBus
*/
public interface EventHandler {
/**
* Executes the event handler.
*
* @param event the event used as the method parameter
* @throws EventBusException if the event handler isn't accessible or has an invalid
* signature
* @throws InvocationTargetException if the handler throws an exception
* @throws EventBusException if the handler has the wrong signature or is inaccessible
* @since 1.2.0
*/
void execute(Object event) throws EventBusException, InvocationTargetException;
/**
* @return the listener containing this handler
* @since 1.2.0
*/
Object getListener();
/**
* @return the event type this handler listens for
* @since 1.2.0
*/
Class<?> getEventType();
/**
* @return the priority of this handler
* @since 1.2.0
* @see Priority
*/
int getPriority();
/**
* @return whether this handler also accepts subtypes of the event type
* @since 1.2.0
* @see Polymorphic
*/
boolean isPolymorphic();
}

View File

@ -0,0 +1,105 @@
package dev.kske.eventbus.core.handler;
import java.lang.reflect.*;
import dev.kske.eventbus.core.*;
/**
* An event handler wrapping a method annotated with {@link Event} and executing it using
* reflection.
*
* @author Kai S. K. Engelbart
* @since 1.2.0
*/
public final class ReflectiveEventHandler implements EventHandler {
private final Object listener;
private final Method method;
private final Class<?> eventType;
private final boolean useParameter;
private final boolean polymorphic;
private final int priority;
/**
* Constructs a reflective event handler.
*
* @param listener the listener containing the handler
* @param method the handler method
* @param annotation the event annotation
* @param defPolymorphism the predefined polymorphism (default or listener-level)
* @param defPriority the predefined priority (default or listener-level)
* @throws EventBusException if the method or the annotation do not comply with the
* specification
* @since 1.2.0
*/
public ReflectiveEventHandler(Object listener, Method method, Event annotation,
boolean defPolymorphism, int defPriority) throws EventBusException {
this.listener = listener;
this.method = method;
useParameter = annotation.value() == void.class;
// Check handler signature
if (method.getParameterCount() == 0 && useParameter)
throw new EventBusException(method + " does not define an event type!");
if (method.getParameterCount() == 1 && !useParameter)
throw new EventBusException(method + " defines an ambiguous event type!");
if (method.getParameterCount() > 1)
throw new EventBusException(method + " defines more than one parameter!");
// Determine handler properties
eventType = useParameter ? method.getParameterTypes()[0] : annotation.value();
polymorphic = method.isAnnotationPresent(Polymorphic.class)
? method.getAnnotation(Polymorphic.class).value()
: defPolymorphism;
priority = method.isAnnotationPresent(Priority.class)
? method.getAnnotation(Priority.class).value()
: defPriority;
// Try to allow access if the method is not accessible
if (!method.canAccess(Modifier.isStatic(method.getModifiers()) ? null : listener))
method.setAccessible(true);
}
@Override
public void execute(Object event) throws EventBusException, InvocationTargetException {
try {
if (useParameter)
method.invoke(getListener(), event);
else
method.invoke(getListener());
} catch (IllegalArgumentException e) {
throw new EventBusException("Event handler rejected target / argument!", e);
} catch (IllegalAccessException e) {
throw new EventBusException("Event handler is not accessible!", e);
}
}
@Override
public String toString() {
return String.format(
"ReflectiveEventHandler[eventType=%s, polymorphic=%b, priority=%d, method=%s, useParameter=%b]",
eventType, polymorphic, priority, method, useParameter);
}
@Override
public Object getListener() {
return listener;
}
@Override
public Class<?> getEventType() {
return eventType;
}
@Override
public int getPriority() {
return priority;
}
@Override
public boolean isPolymorphic() {
return polymorphic;
}
}

View File

@ -0,0 +1,8 @@
/**
* Contains the internal representation of event handling methods.
*
* @author Kai S. K. Engelbart
* @since 1.2.0
* @see dev.kske.eventbus.core.handler.EventHandler
*/
package dev.kske.eventbus.core.handler;

View File

@ -0,0 +1,9 @@
/**
* Contains the public API and implementation of the Event Bus library.
*
* @author Kai S. K. Engelbart
* @since 0.0.1
* @see dev.kske.eventbus.core.Event
* @see dev.kske.eventbus.core.EventBus
*/
package dev.kske.eventbus.core;

View File

@ -0,0 +1,12 @@
/**
* Contains the public API and implementation of the Event Bus library.
*
* @author Kai S. K. Engelbart
* @since 0.0.3
* @see dev.kske.eventbus.core.Event
* @see dev.kske.eventbus.core.EventBus
*/
module dev.kske.eventbus.core {
exports dev.kske.eventbus.core;
}

View File

@ -0,0 +1,54 @@
package dev.kske.eventbus.core;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.*;
/**
* Tests the event cancellation mechanism of the event bus.
*
* @author Kai S. K. Engelbart
* @author Leon Hofmeister
* @since 0.1.0
*/
class CancelTest {
EventBus bus;
int hits;
/**
* Constructs an event bus and registers this test instance as an event listener.
*
* @since 0.1.0
*/
@BeforeEach
void registerListener() {
bus = new EventBus();
bus.registerListener(this);
}
/**
* Tests {@link EventBus#cancel()} with two event handlers, of which the first cancels the
* event.
*
* @since 0.1.0
*/
@Test
void testCancellation() {
bus.dispatch(new SimpleEvent());
assertEquals(1, hits);
}
@Event(SimpleEvent.class)
@Priority(100)
void onSimpleFirst() {
++hits;
bus.cancel();
}
@Event(SimpleEvent.class)
@Priority(50)
void onSimpleSecond() {
++hits;
}
}

View File

@ -0,0 +1,49 @@
package dev.kske.eventbus.core;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
/**
* Tests the dispatching of a dead event if an event could not be delivered.
*
* @author Kai S. K. Engelbart
* @since 1.1.0
*/
class DeadTest {
EventBus bus = new EventBus();
String event = "This event has no handler";
boolean deadEventHandled;
/**
* Tests dead event delivery.
*
* @since 1.1.0
*/
@Test
void testDeadEvent() {
bus.registerListener(this);
bus.dispatch(event);
assertTrue(deadEventHandled);
bus.removeListener(this);
}
/**
* Tests how the event bus reacts to an unhandled dead event. This should not lead to an
* exception or an endless recursion and should be logged instead.
*
* @since 1.1.0
*/
@Test
void testUnhandledDeadEvent() {
bus.dispatch(event);
}
@Event
void onDeadEvent(DeadEvent deadEvent) {
assertEquals(bus, deadEvent.getEventBus());
assertEquals(event, deadEvent.getEvent());
deadEventHandled = true;
}
}

View File

@ -0,0 +1,88 @@
package dev.kske.eventbus.core;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.*;
/**
* Tests the dispatching mechanism of the event bus.
*
* @author Kai S. K. Engelbart
* @since 0.0.1
*/
@Polymorphic
@Priority(150)
class DispatchTest {
EventBus bus;
/**
* Constructs an event bus and registers this test instance as an event listener.
*
* @since 0.0.1
*/
@BeforeEach
void registerListener() {
bus = new EventBus();
bus.registerListener(this);
bus.registerListener(SimpleEvent.class, e -> {
e.increment();
assertEquals(3, e.getCounter());
});
}
/**
* Tests {@link EventBus#dispatch(Object)} with multiple handler priorities, a polymorphic
* handler and a static handler.
*
* @since 0.0.1
*/
@Test
void testDispatch() {
bus.dispatch(new SimpleEventSub());
bus.dispatch(new SimpleEvent());
}
/**
* Tests {@link EventBus#debugExecutionOrder(Class)} based on the currently registered handlers.
*
* @since 1.2.0
*/
@Test
void testDebugExecutionOrder() {
assertEquals(
"Event handler execution order for class dev.kske.eventbus.core.SimpleEvent (3 handler(s)):\n"
+ "==========================================================================================\n"
+ "ReflectiveEventHandler[eventType=class dev.kske.eventbus.core.SimpleEvent, polymorphic=true, priority=200, method=void dev.kske.eventbus.core.DispatchTest.onSimpleEventFirst(dev.kske.eventbus.core.SimpleEvent), useParameter=true]\n"
+ "ReflectiveEventHandler[eventType=class dev.kske.eventbus.core.SimpleEvent, polymorphic=false, priority=150, method=static void dev.kske.eventbus.core.DispatchTest.onSimpleEventSecond(dev.kske.eventbus.core.SimpleEvent), useParameter=true]\n"
+ "CallbackEventHandler[eventType=class dev.kske.eventbus.core.SimpleEvent, polymorphic=false, priority=100]\n"
+ "==========================================================================================",
bus.debugExecutionOrder(SimpleEvent.class));
}
/**
* Tests whether the handlers bound to an event type are correct when retrieved from the binding
* cache. On the second call of {@link EventBus#debugExecutionOrder(Class)} the cache is used.
*
* @since 1.3.0
*/
@Test
void testBindingCache() {
assertEquals(bus.debugExecutionOrder(SimpleEventSub.class),
bus.debugExecutionOrder(SimpleEventSub.class));
}
@Event
@Priority(200)
void onSimpleEventFirst(SimpleEvent event) {
event.increment();
assertTrue(event.getCounter() == 1 || event.getCounter() == 2);
}
@Event
@Polymorphic(false)
static void onSimpleEventSecond(SimpleEvent event) {
event.increment();
assertEquals(2, event.getCounter());
}
}

View File

@ -0,0 +1,62 @@
package dev.kske.eventbus.core;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
/**
* Tests the dispatching of an exception event if an event handler threw an exception.
*
* @author Kai S. K. Engelbart
* @since 1.1.0
*/
class ExceptionTest {
EventBus bus = new EventBus();
String event = "This event will cause an exception";
RuntimeException exception = new RuntimeException("I failed");
boolean exceptionEventHandled;
/**
* Tests exception event delivery.
*
* @since 1.1.0
*/
@Test
void testExceptionEvent() {
bus.registerListener(this);
bus.registerListener(new ExceptionListener());
bus.dispatch(event);
assertTrue(exceptionEventHandled);
bus.clearListeners();
}
/**
* Tests how the event bus reacts to an unhandled exception event. This should not lead to an
* exception or an endless recursion and should be logged instead.
*
* @since 1.1.0
*/
@Test
void testUnhandledExceptionEvent() {
bus.registerListener(this);
bus.dispatch(event);
bus.removeListener(this);
}
@Event(String.class)
void onString() {
throw exception;
}
class ExceptionListener {
@Event
void onExceptionEvent(ExceptionEvent exceptionEvent) {
assertEquals(bus, exceptionEvent.getEventBus());
assertEquals(event, exceptionEvent.getEvent());
assertEquals(exception, exceptionEvent.getCause());
exceptionEventHandled = true;
}
}
}

View File

@ -0,0 +1,33 @@
package dev.kske.eventbus.core;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
/**
* Tests the behavior of the event bus when an {@link ExceptionWrapper} is thrown.
*
* @author Kai S. K. Engelbart
* @since 1.2.1
*/
class ExceptionWrapperTest {
EventBus bus = new EventBus();
String event = "This event will cause an exception";
/**
* Tests transparent rethrowing of an exception wrapper by {@link EventBus#dispatch(Object)}.
*
* @since 1.2.1
*/
@Test
void testExceptionWrapper() {
bus.registerListener(this);
assertThrows(ExceptionWrapper.class, () -> bus.dispatch(event));
}
@Event(String.class)
void onString() {
throw new ExceptionWrapper(new RuntimeException("I failed!"));
}
}

View File

@ -0,0 +1,43 @@
package dev.kske.eventbus.core;
import static org.junit.jupiter.api.Assertions.assertSame;
import org.junit.jupiter.api.Test;
/**
* Tests whether event handlers correctly work in the context of an inheritance hierarchy. The
* effect of handler priorities is also accounted for.
*
* @author Kai S. K. Engelbart
* @since 1.3.0
*/
class InheritanceTest extends SimpleEventListenerBase implements SimpleEventListenerInterface {
EventBus bus = new EventBus();
@Test
void test() {
bus.registerListener(this);
var event = new SimpleEvent();
bus.dispatch(event);
assertSame(3, event.getCounter());
}
@Override
void onSimpleEventAbstractHandler(SimpleEvent event) {
assertSame(1, event.getCounter());
}
@Override
public void onSimpleEventInterfaceHandler(SimpleEvent event) {
event.increment();
}
@Event
@Priority(250)
private void onSimpleEventPrivate(SimpleEvent event) {
assertSame(0, event.getCounter());
event.increment();
}
}

View File

@ -0,0 +1,73 @@
package dev.kske.eventbus.core;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.*;
/**
* Tests nested event dispatches.
*
* @author Kai S. K. Engelbart
* @since 1.2.0
*/
class NestedTest {
EventBus bus;
boolean nestedHit;
/**
* Constructs an event bus and registers this test instance as an event listener.
*
* @since 1.2.0
*/
@BeforeEach
void registerListener() {
bus = new EventBus();
bus.registerListener(this);
}
/**
* Dispatches a simple event, which should in turn cause a string to be dispatched as a nested
* event. If the corresponding handler sets {@link #nestedHit} to {@code true}, the test is
* successful.
*
* @since 1.2.0
*/
@Test
void testNestedDispatch() {
bus.dispatch(new SimpleEvent());
assertTrue(nestedHit);
}
/**
* Dispatches a string as a nested event and cancels the current dispatch afterwards.
*
* @since 1.2.0
*/
@Event(SimpleEvent.class)
void onSimpleEvent() {
bus.dispatch("Nested event");
bus.cancel();
}
/**
* Sets {@link #nestedHit} to {@code true} indicating that nested dispatches work.
*
* @since 1.2.0
*/
@Event(String.class)
void onString() {
nestedHit = true;
}
/**
* Fails the test if an exception is caused during the dispatch.
*
* @param e the event containing the exception
* @since 1.2.0
*/
@Event
void onException(ExceptionEvent e) {
fail("Exception during dispatch", e.getCause());
}
}

View File

@ -0,0 +1,31 @@
package dev.kske.eventbus.core;
/**
* A simple event for testing purposes. The event contains a counter that is supposed to be
* incremented when the event is processed by a handler. That way it is possible to test whether all
* handlers that were supposed to be invoked were in fact invoked.
*
* @author Kai S. K. Engelbart
* @since 0.0.1
*/
class SimpleEvent {
private int counter;
@Override
public String toString() {
return String.format("%s[%d]", getClass().getSimpleName(), counter);
}
void increment() {
++counter;
}
int getCounter() {
return counter;
}
void reset() {
counter = 0;
}
}

View File

@ -0,0 +1,25 @@
package dev.kske.eventbus.core;
import static org.junit.jupiter.api.Assertions.*;
/**
* An abstract class defining a package-private and a private handler for {@link SimpleEvent}.
*
* @author Kai S. K. Engelbart
* @since 1.3.0
*/
@Priority(200)
abstract class SimpleEventListenerBase {
@Event
void onSimpleEventAbstractHandler(SimpleEvent event) {
fail("This handler should not be invoked");
}
@Event
@Priority(150)
private void onSimpleEventPrivate(SimpleEvent event) {
assertSame(1, event.getCounter());
event.increment();
}
}

View File

@ -0,0 +1,14 @@
package dev.kske.eventbus.core;
/**
* An interface defining a single handler for {@link SimpleEvent}.
*
* @author Kai S. K. Engelbart
* @since 1.3.0
*/
interface SimpleEventListenerInterface {
@Priority(120)
@Event
void onSimpleEventInterfaceHandler(SimpleEvent event);
}

View File

@ -0,0 +1,9 @@
package dev.kske.eventbus.core;
/**
* Subclass of {@link SimpleEvent} for testing purposes.
*
* @author Kai S. K. Engelbart
* @since 0.0.4
*/
class SimpleEventSub extends SimpleEvent {}

115
pom.xml
View File

@ -5,16 +5,24 @@
<groupId>dev.kske</groupId>
<artifactId>event-bus</artifactId>
<version>0.0.2</version>
<version>1.2.0</version>
<packaging>pom</packaging>
<name>Event Bus</name>
<description>An event handling framework for Java utilizing annotations.</description>
<url>https://git.kske.dev/zdm/event-bus</url>
<description>An event handling library for Java utilizing annotations.</description>
<url>https://git.kske.dev/kske/event-bus</url>
<modules>
<module>core</module>
<module>proc</module>
</modules>
<licenses>
<license>
<name>MIT License</name>
<url>http://www.opensource.org/licenses/mit-license.php</url>
<name>Apache License, Version 2.0</name>
<url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
<distribution>repo</distribution>
<comments>A business-friendly OSS license</comments>
</license>
</licenses>
@ -32,9 +40,23 @@
</developer>
</developers>
<contributors>
<contributor>
<name>Leon Hofmeister</name>
<email>leon@kske.dev</email>
<url>https://git.kske.dev/delvh</url>
<roles>
<role>qa</role>
<role>tester</role>
</roles>
<timezone>Europe/Berlin</timezone>
</contributor>
</contributors>
<scm>
<connection>scm:git:https://git.kske.dev/zdm/event-bus.git</connection>
<developerConnection>scm:git:ssh:git@git.kske.dev:zdm/event-bus.git</developerConnection>
<connection>scm:git:https://git.kske.dev/kske/event-bus.git</connection>
<developerConnection>scm:git:ssh://git@git.kske.dev:420/kske/event-bus.git</developerConnection>
<url>https://git.kske.dev/kske/event-bus</url>
</scm>
<properties>
@ -44,13 +66,37 @@
<maven.compiler.target>11</maven.compiler.target>
</properties>
<!-- Configure deployment to OSSRH -->
<distributionManagement>
<snapshotRepository>
<id>ossrh</id>
<url>https://oss.sonatype.org/content/repositories/snapshots</url>
</snapshotRepository>
<repository>
<id>ossrh</id>
<url>https://oss.sonatype.org/service/local/staging/deploy/maven2/</url>
</repository>
</distributionManagement>
<build>
<resources />
<!-- Disable test resource folder -->
<testResources />
<plugins>
<!-- Support Java 9 modules -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
</plugin>
<!-- Attach sources to JAR -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-source-plugin</artifactId>
<version>3.2.1</version>
<executions>
<execution>
<id>attach-sources</id>
@ -60,9 +106,12 @@
</execution>
</executions>
</plugin>
<!-- Attach Javadoc to JAR -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-javadoc-plugin</artifactId>
<version>3.2.0</version>
<executions>
<execution>
<id>attach-javadocs</id>
@ -71,16 +120,46 @@
</goals>
</execution>
</executions>
<!-- Support JDK-style Javadoc tags -->
<configuration>
<tags>
<tag>
<name>apiNote</name>
<placement>a</placement>
<head>API Note:</head>
</tag>
<tag>
<name>implSpec</name>
<placement>a</placement>
<head>Implementation Requirements:</head>
</tag>
<tag>
<name>implNote</name>
<placement>a</placement>
<head>Implementation Note:</head>
</tag>
</tags>
</configuration>
</plugin>
<!-- GPG sign JAR -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-gpg-plugin</artifactId>
<version>1.6</version>
<executions>
<execution>
<id>sign-artifacts</id>
<phase>verify</phase>
<goals>
<goal>sign</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>5.6.2</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
</project>

32
proc/.classpath 100644
View File

@ -0,0 +1,32 @@
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" output="target/classes" path="src/main/java">
<attributes>
<attribute name="optional" value="true"/>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11">
<attributes>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
<attributes>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
<attributes>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="src" output="target/test-classes" path="src/test/java">
<attributes>
<attribute name="optional" value="true"/>
<attribute name="maven.pomderived" value="true"/>
<attribute name="test" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="output" path="target/classes"/>
</classpath>

23
proc/.project 100644
View File

@ -0,0 +1,23 @@
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>event-bus-proc</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.jdt.core.javabuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.m2e.core.maven2Builder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.eclipse.jdt.core.javanature</nature>
<nature>org.eclipse.m2e.core.maven2Nature</nature>
</natures>
</projectDescription>

72
proc/pom.xml 100644
View File

@ -0,0 +1,72 @@
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<artifactId>event-bus-proc</artifactId>
<name>Event Bus Annotation Processor</name>
<description>Annotation processor checking for errors related to the @Event annotation from Event Bus.</description>
<parent>
<groupId>dev.kske</groupId>
<artifactId>event-bus</artifactId>
<version>1.2.0</version>
</parent>
<dependencies>
<dependency>
<groupId>dev.kske</groupId>
<artifactId>event-bus-core</artifactId>
<version>${project.version}</version>
</dependency>
</dependencies>
<build>
<plugins>
<!-- Prevent annotation processing error during compilation -->
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<compilerArgument>-proc:none</compilerArgument>
</configuration>
</plugin>
<!-- Include event-bus-core classes into JAR -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.2.4</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<minimizeJar>true</minimizeJar>
<filters>
<filter>
<artifact>dev.kske:event-bus-core</artifact>
<excludes>
<exclude>META-INF/MANIFEST.MF</exclude>
</excludes>
</filter>
<filter>
<artifact>*:*</artifact>
<excludes>
<exclude>module-info.class</exclude>
<exclude>META-INF/maven/**</exclude>
</excludes>
</filter>
</filters>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

View File

@ -0,0 +1,147 @@
package dev.kske.eventbus.proc;
import java.util.Set;
import javax.annotation.processing.*;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.*;
import javax.lang.model.type.*;
import javax.tools.Diagnostic.Kind;
import dev.kske.eventbus.core.*;
/**
* This annotation processor checks event handlers for common mistakes which can only be detected
* during runtime otherwise.
*
* @author Kai S. K. Engelbart
* @since 1.0.0
*/
@SupportedAnnotationTypes("dev.kske.eventbus.core.Event")
@SupportedSourceVersion(SourceVersion.RELEASE_11)
public class EventProcessor extends AbstractProcessor {
@SuppressWarnings("unchecked")
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
if (!roundEnv.errorRaised() && !roundEnv.processingOver())
processRound(
(Set<ExecutableElement>) roundEnv.getElementsAnnotatedWith(Event.class));
// Do not claim the processed annotations
return false;
}
private void processRound(Set<ExecutableElement> eventHandlers) {
for (ExecutableElement eventHandler : eventHandlers) {
Event eventAnnotation = eventHandler.getAnnotation(Event.class);
TypeMirror eventType;
// Determine the event type and how it is defined
boolean useParameter;
try {
eventAnnotation.value();
throw new EventBusException(
"Could not determine event type of handler " + eventHandler);
} catch (MirroredTypeException e) {
// Task failed successfully
eventType = e.getTypeMirror();
useParameter = eventType.getKind() == TypeKind.VOID;
}
// Check handler signature
boolean pass = false;
if (useParameter && eventHandler.getParameters().isEmpty())
error(eventHandler, "The method or the annotation must define the event type");
else if (!useParameter && eventHandler.getParameters().size() == 1)
error(eventHandler,
"Either the method or the annotation must define the event type");
else if (eventHandler.getParameters().size() > 1)
error(eventHandler, "Method must not have more than one parameter");
else
pass = true;
// Warn the user about unused return values
if (useParameter && eventHandler.getReturnType().getKind() != TypeKind.VOID)
warning(eventHandler, "Unused return value");
// Abort checking if the handler signature is incorrect
if (!pass)
continue;
// Additional checks if parameter is used
if (useParameter) {
VariableElement paramElement = eventHandler.getParameters().get(0);
eventType = paramElement.asType();
// Check if parameter is object
// Abort checking otherwise
if (eventType.getKind() != TypeKind.DECLARED) {
error(paramElement, "Event must be an object");
continue;
}
}
// Get the listener containing this handler
TypeElement listener = (TypeElement) eventHandler.getEnclosingElement();
// Default properties
boolean defPolymorphic = false;
int defPriority = 100;
// Listener-level polymorphism
Polymorphic listenerPolymorphic = listener.getAnnotation(Polymorphic.class);
boolean hasListenerPolymorphic = listenerPolymorphic != null;
// Listener-level priority
Priority listenerPriority = listener.getAnnotation(Priority.class);
boolean hasListenerPriority = listenerPriority != null;
// Effective polymorphism
boolean polymorphic =
hasListenerPolymorphic ? listenerPolymorphic.value() : defPolymorphic;
boolean hasHandlerPolymorphic = eventHandler.getAnnotation(Polymorphic.class) != null;
if (hasHandlerPolymorphic)
polymorphic = eventHandler.getAnnotation(Polymorphic.class).value();
// Effective priority
int priority =
hasListenerPriority ? listenerPriority.value() : defPriority;
boolean hasHandlerPriority = eventHandler.getAnnotation(Priority.class) != null;
if (hasHandlerPriority)
priority = eventHandler.getAnnotation(Priority.class).value();
// Detect useless polymorphism redefinition
if (hasListenerPolymorphic && hasHandlerPolymorphic
&& listenerPolymorphic.value() == polymorphic)
warning(eventHandler, "@Polymorphism is already defined at listener level");
// Detect useless priority redefinition
if (hasListenerPriority && hasHandlerPriority && listenerPriority.value() == priority)
warning(eventHandler, "@Priority is already defined at the listener level");
// Detect missing or useless @Polymorphic
Element eventElement = ((DeclaredType) eventType).asElement();
// Check for handlers for abstract types that aren't polymorphic
if (!polymorphic && (eventElement.getKind() == ElementKind.INTERFACE
|| eventElement.getModifiers().contains(Modifier.ABSTRACT)))
warning(eventHandler,
"Parameter should be instantiable or handler should use @Polymorphic");
// Check for handlers for final types that are polymorphic
else if (polymorphic && eventElement.getModifiers().contains(Modifier.FINAL))
warning(eventHandler,
"@Polymorphic should be removed as parameter cannot be subclassed");
}
}
private void warning(Element e, String msg, Object... args) {
processingEnv.getMessager().printMessage(Kind.WARNING, String.format(msg, args), e);
}
private void error(Element e, String msg, Object... args) {
processingEnv.getMessager().printMessage(Kind.ERROR, String.format(msg, args), e);
}
}

View File

@ -0,0 +1,7 @@
/**
* Contains the Event Bus annotation processor.
*
* @author Kai S. K. Engelbart
* @since 1.0.0
*/
package dev.kske.eventbus.proc;

View File

@ -0,0 +1,12 @@
/**
* Contains an annotation processor for checking for errors related to the
* {@link dev.kske.eventbus.core.Event} annotation from Event Bus.
*
* @author Kai S. K. Engelbart
* @since 1.0.0
*/
module dev.kske.eventbus.proc {
requires java.compiler;
requires dev.kske.eventbus.core;
}

View File

@ -0,0 +1 @@
dev.kske.eventbus.proc.EventProcessor

View File

@ -1,34 +0,0 @@
package dev.kske.eventbus;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.*;
/**
* Indicates that a method is an event handler. To be successfully used as such, the method has to
* comply with the following specifications:
* <ul>
* <li>Declared inside a class that implements {@link EventListener}</li>
* <li>One parameter of a type that implements {@link IEvent}</li>
* <li>Return type of {@code void}</li>
* </ul>
*
* @author Kai S. K. Engelbart
* @since 0.0.1
*/
@Documented
@Retention(RUNTIME)
@Target(METHOD)
public @interface Event {
/**
* Defines the priority of the event handler. Handlers are executed in descending order of their
* priority.
* <p>
* The execution order of handlers with the same priority is undefined.
*
* @since 0.0.1
*/
int priority() default 100;
}

View File

@ -1,137 +0,0 @@
package dev.kske.eventbus;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
/**
* Event listeners can be registered at an event bus to be notified when an event is dispatched.
* <p>
* A singleton instance of this class can be lazily created and acquired using the
* {@link EventBus#getInstance()} method.
* <p>
* This is a thread-safe implementation.
*
* @author Kai S. K. Engelbart
* @since 0.0.1
* @see Event
*/
public final class EventBus {
private static EventBus singletonInstance;
/**
* Produces a singleton instance of the event bus. It is lazily initialized on the first call.
*
* @return a singleton instance of the event bus.
* @since 0.0.2
*/
public static EventBus getInstance() {
if (singletonInstance == null)
singletonInstance = new EventBus();
return singletonInstance;
}
private final Map<Class<? extends IEvent>, Collection<EventHandler>> bindings
= new ConcurrentHashMap<>();
private final Set<EventListener> registeredListeners = ConcurrentHashMap.newKeySet();
/**
* Dispatches an event to all event handlers registered for it in descending order of their
* priority.
*
* @param event the event to dispatch
* @since 0.0.1
*/
public void dispatch(IEvent event) {
getHandlersFor(event.getClass()).forEach(handler -> handler.execute(event));
}
/**
* Searches for the event handlers bound to an event class.
*
* @param eventClass the event class to use for the search
* @return all event handlers registered for the event class
* @since 0.0.1
*/
private List<EventHandler> getHandlersFor(Class<? extends IEvent> eventClass) {
return bindings.containsKey(eventClass) ? new ArrayList<>(bindings.get(eventClass))
: new ArrayList<>();
}
/**
* Registers an event listener at this event bus.
*
* @param listener the listener to register
* @throws EventBusException if the listener is already registered or a declared event handler
* does not comply to the specification
* @since 0.0.1
* @see Event
*/
public void registerListener(EventListener listener) throws EventBusException {
if (registeredListeners.contains(listener))
throw new EventBusException(listener + " already registered!");
registeredListeners.add(listener);
for (var method : listener.getClass().getDeclaredMethods()) {
Event annotation = method.getAnnotation(Event.class);
// Skip methods without annotations
if (annotation == null)
continue;
// Check for correct method signature and return type
if (method.getParameterCount() != 1)
throw new EventBusException(method + " does not have an argument count of 1!");
if (!method.getReturnType().equals(void.class))
throw new EventBusException(method + " does not have a return type of void!");
var param = method.getParameterTypes()[0];
if (!IEvent.class.isAssignableFrom(param))
throw new EventBusException(param + " is not of type IEvent!");
@SuppressWarnings("unchecked")
var realParam = (Class<? extends IEvent>) param;
if (!bindings.containsKey(realParam))
bindings.put(realParam, new TreeSet<>());
bindings.get(realParam).add(new EventHandler(listener, method, annotation));
}
}
/**
* Removes a specific listener from this event bus.
*
* @param listener the listener to remove
* @since 0.0.1
*/
public void removeListener(EventListener listener) {
for (var binding : bindings.values()) {
var it = binding.iterator();
while (it.hasNext())
if (it.next().getListener() == listener)
it.remove();
}
registeredListeners.remove(listener);
}
/**
* Removes all event listeners from this event bus.
*
* @since 0.0.1
*/
public void clearListeners() {
bindings.clear();
registeredListeners.clear();
}
/**
* Provides an unmodifiable view of the event listeners registered at this event bus.
*
* @return all registered event listeners
* @since 0.0.1
*/
public Set<EventListener> getRegisteredListeners() {
return Collections.unmodifiableSet(registeredListeners);
}
}

View File

@ -1,21 +0,0 @@
package dev.kske.eventbus;
/**
* This runtime exception is thrown when an event bus error occurs. This can either occur while
* registering event listeners with invalid handlers, or when an event handler throws an exception.
*
* @author Kai S. K. Engelbart
* @since 0.0.1
*/
public class EventBusException extends RuntimeException {
private static final long serialVersionUID = 1L;
public EventBusException(String message, Throwable cause) {
super(message, cause);
}
public EventBusException(String message) {
super(message);
}
}

View File

@ -1,85 +0,0 @@
package dev.kske.eventbus;
import java.lang.reflect.*;
/**
* Internal representation of an event handling method.
*
* @author Kai S. K. Engelbart
* @since 0.0.1
* @see EventBus
*/
final class EventHandler implements Comparable<EventHandler> {
private final EventListener listener;
private final Method method;
private final Event annotation;
/**
* Constructs an event handler.
*
* @param listener the listener containing the handler
* @param method the handler method
* @param annotation the event annotation
* @since 0.0.1
*/
EventHandler(EventListener listener, Method method, Event annotation) {
this.listener = listener;
this.method = method;
this.annotation = annotation;
method.setAccessible(true);
}
/**
* Compares this to another event handler based on {@link Event#priority()}. In case of equal
* priority a non-zero value based on hash codes is returned.
* <p>
* This is used to retrieve event handlers in the correct order from a tree set.
*
* @since 0.0.1
*/
@Override
public int compareTo(EventHandler other) {
int priority = other.annotation.priority() - annotation.priority();
if (priority == 0)
priority = listener.hashCode() - other.listener.hashCode();
return priority == 0 ? hashCode() - other.hashCode() : priority;
}
/**
* Executes the event handler.
*
* @param event the event used as the method parameter
* @throws EventBusException if the handler throws an exception
* @since 0.0.1
*/
void execute(IEvent event) throws EventBusException {
try {
method.invoke(listener, event);
} catch (
IllegalAccessException
| IllegalArgumentException
| InvocationTargetException e
) {
throw new EventBusException("Failed to invoke event handler!", e);
}
}
/**
* @return the listener containing this handler
* @since 0.0.1
*/
EventListener getListener() { return listener; }
/**
* @return the event annotation
* @since 0.0.1
*/
Event getAnnotation() { return annotation; }
/**
* @return the priority of the event annotation
* @since 0.0.1
*/
int getPriority() { return annotation.priority(); }
}

View File

@ -1,12 +0,0 @@
package dev.kske.eventbus;
/**
* Marker interface for event listeners. Event listeners can contain event handling methods to which
* events can be dispatched.
*
* @author Kai S. K. Engelbart
* @since 0.0.1
* @see Event
* @see EventBus
*/
public interface EventListener {}

View File

@ -1,12 +0,0 @@
package dev.kske.eventbus;
/**
* Marker interface for event objects. Event objects can be used as event handler parameters and
* thus can be dispatched to the event bus.
*
* @author Kai S. K. Engelbart
* @since 0.0.1
* @see Event
* @see EventBus
*/
public interface IEvent {}

View File

@ -1,9 +0,0 @@
/**
* Contains the public API and implementation of the event bus library.
*
* @author Kai S. K. Engelbart
* @since 0.0.1
* @see dev.kske.eventbus.Event
* @see dev.kske.eventbus.EventBus
*/
package dev.kske.eventbus;

View File

@ -1,38 +0,0 @@
package dev.kske.eventbus;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.*;
/**
* Tests the of the event bus library.
*
* @author Kai S. K. Engelbart
* @since 0.0.1
*/
class EventBusTest implements EventListener {
int hits;
@BeforeEach
public void registerListener() {
EventBus.getInstance().registerListener(this);
}
@Test
void testDispatch() {
EventBus.getInstance().dispatch(new SimpleEvent());
}
@Event(priority = 50)
private void onSimpleEventSecond(SimpleEvent event) {
++hits;
assertEquals(2, hits);
}
@Event(priority = 150)
private void onSimpleEventFirst(SimpleEvent event) {
++hits;
assertEquals(1, hits);
}
}

View File

@ -1,9 +0,0 @@
package dev.kske.eventbus;
/**
* A simple event for testing purposes.
*
* @author Kai S. K. Engelbart
* @since 0.0.1
*/
public class SimpleEvent implements IEvent {}