@SuppressWarnings("Convert2Lambda")
private void extractListenerForRegularObject(
final Object listener,
final MethodAccess methodAccess,
final String channel,
final boolean consume) {
logger.info(
"EventManager {}:: {} is listening with method {} on channel {} and is consuming? {}",
name,
listener.getClass().getSimpleName(),
methodAccess.name(),
channel,
consume);
if (consume) {
/* Do not use Lambda, this has to be a consume! */
this.register(
channel,
new EventConsumer<Object>() {
@Override
public void listen(Event<Object> event) {
invokeEventMethod(event, methodAccess, listener);
}
});
} else {
/* Do not use Lambda, this has to be a subscriber! */
this.register(
channel,
new EventSubscriber<Object>() {
@Override
public void listen(Event<Object> event) {
invokeEventMethod(event, methodAccess, listener);
}
});
}
}
private void extractEventListenerFromMethod(
final Object listener,
final MethodAccess methodAccess,
final AnnotationData listen,
final ServiceQueue serviceQueue) {
logger.info(
"EventManager {} ::extractEventListenerFromMethod :: "
+ "{} is listening with method {} using annotation data {} ",
name,
serviceQueue,
methodAccess.name(),
listen.getValues());
final String channel = listen.getValues().get("value").toString();
final boolean consume = (boolean) listen.getValues().get("consume");
if (serviceQueue == null) {
extractListenerForRegularObject(listener, methodAccess, channel, consume);
} else {
extractListenerForService(serviceQueue, channel, consume);
}
}
private void doListen(final Object listener, final ServiceQueue serviceQueue) {
if (debug) {
logger.debug(
"EventManager {} registering listener {} with serviceQueue {}",
name,
listener,
serviceQueue);
}
final ClassMeta<?> listenerClassMeta = ClassMeta.classMeta(listener.getClass());
final Iterable<MethodAccess> listenerMethods = listenerClassMeta.methods();
/* Add methods as listeners if they have a listen annotation. */
for (final MethodAccess methodAccess : listenerMethods) {
AnnotationData listenAnnotationData = getListenAnnotation(methodAccess);
if (listenAnnotationData == null) continue;
extractEventListenerFromMethod(listener, methodAccess, listenAnnotationData, serviceQueue);
}
/* Look for listener channel implementations. */
final Class<?>[] interfacesFromListener = listenerClassMeta.cls().getInterfaces();
/* Iterate through interfaces and see if any are marked with the event channel annotation. */
for (Class<?> interfaceClass : interfacesFromListener) {
final ClassMeta<?> metaFromListenerInterface = classMeta(interfaceClass);
final AnnotationData eventChannelAnnotation =
metaFromListenerInterface.annotation(AnnotationUtils.EVENT_CHANNEL_ANNOTATION_NAME);
if (eventChannelAnnotation == null) {
continue;
}
/* If we got this far, then we are dealing with an event channel interface
so register the methods from this interface as channel listeners.
*/
final Iterable<MethodAccess> interfaceMethods = metaFromListenerInterface.methods();
final String classEventBusName =
getClassEventChannelName(metaFromListenerInterface, eventChannelAnnotation);
for (MethodAccess methodAccess : interfaceMethods) {
/* By default the method name forms part of the event bus name,
but this can be overridden by the EVENT_CHANNEL_ANNOTATION_NAME annotation on the method.
*/
final AnnotationData methodAnnotation =
methodAccess.annotation(AnnotationUtils.EVENT_CHANNEL_ANNOTATION_NAME);
String methodEventBusName =
methodAnnotation != null && methodAnnotation.getValues().get("value") != null
? methodAnnotation.getValues().get("value").toString()
: null;
if (Str.isEmpty(methodEventBusName)) {
methodEventBusName = methodAccess.name();
}
final String channelName = createChannelName(null, classEventBusName, methodEventBusName);
if (serviceQueue == null) {
extractListenerForRegularObject(listener, methodAccess, channelName, false);
} else {
extractListenerForService(serviceQueue, channelName, false);
}
}
}
}