org.springframework.context.PayloadApplicationEvent Java Examples

/**
 * Resolve the method arguments to use for the specified {@link ApplicationEvent}.
 * <p>These arguments will be used to invoke the method handled by this instance.
 * Can return {@code null} to indicate that no suitable arguments could be resolved
 * and therefore the method should not be invoked at all for the specified event.
 */
@Nullable
protected Object[] resolveArguments(ApplicationEvent event) {
	ResolvableType declaredEventType = getResolvableType(event);
	if (declaredEventType == null) {
		return null;
	}
	if (this.method.getParameterCount() == 0) {
		return new Object[0];
	}
	Class<?> declaredEventClass = declaredEventType.toClass();
	if (!ApplicationEvent.class.isAssignableFrom(declaredEventClass) &&
			event instanceof PayloadApplicationEvent) {
		Object payload = ((PayloadApplicationEvent<?>) event).getPayload();
		if (declaredEventClass.isInstance(payload)) {
			return new Object[] {payload};
		}
	}
	return new Object[] {event};
}
 

/**
 * Resolve the method arguments to use for the specified {@link ApplicationEvent}.
 * <p>These arguments will be used to invoke the method handled by this instance. Can
 * return {@code null} to indicate that no suitable arguments could be resolved and
 * therefore the method should not be invoked at all for the specified event.
 */
protected Object[] resolveArguments(ApplicationEvent event) {
	ResolvableType declaredEventType = getResolvableType(event);
	if (declaredEventType == null) {
		return null;
	}
	if (this.method.getParameterTypes().length == 0) {
		return new Object[0];
	}
	if (!ApplicationEvent.class.isAssignableFrom(declaredEventType.getRawClass())
			&& event instanceof PayloadApplicationEvent) {
		return new Object[] {((PayloadApplicationEvent) event).getPayload()};
	}
	else {
		return new Object[] {event};
	}
}
 

private ResolvableType getResolvableType(ApplicationEvent event) {
	ResolvableType payloadType = null;
	if (event instanceof PayloadApplicationEvent) {
		PayloadApplicationEvent<?> payloadEvent = (PayloadApplicationEvent<?>) event;
		payloadType = payloadEvent.getResolvableType().as(
				PayloadApplicationEvent.class).getGeneric(0);
	}
	for (ResolvableType declaredEventType : this.declaredEventTypes) {
		if (!ApplicationEvent.class.isAssignableFrom(declaredEventType.getRawClass())
				&& payloadType != null) {
			if (declaredEventType.isAssignableFrom(payloadType)) {
				return declaredEventType;
			}
		}
		if (declaredEventType.getRawClass().isAssignableFrom(event.getClass())) {
			return declaredEventType;
		}
	}
	return null;
}
 

/**
 * Resolve the method arguments to use for the specified {@link ApplicationEvent}.
 * <p>These arguments will be used to invoke the method handled by this instance. Can
 * return {@code null} to indicate that no suitable arguments could be resolved and
 * therefore the method should not be invoked at all for the specified event.
 */
@Nullable
protected Object[] resolveArguments(ApplicationEvent event) {
	ResolvableType declaredEventType = getResolvableType(event);
	if (declaredEventType == null) {
		return null;
	}
	if (this.method.getParameterCount() == 0) {
		return new Object[0];
	}
	if (!ApplicationEvent.class.isAssignableFrom(declaredEventType.toClass()) &&
			event instanceof PayloadApplicationEvent) {
		return new Object[] {((PayloadApplicationEvent) event).getPayload()};
	}
	else {
		return new Object[] {event};
	}
}
 

@Nullable
private ResolvableType getResolvableType(ApplicationEvent event) {
	ResolvableType payloadType = null;
	if (event instanceof PayloadApplicationEvent) {
		PayloadApplicationEvent<?> payloadEvent = (PayloadApplicationEvent<?>) event;
		ResolvableType eventType = payloadEvent.getResolvableType();
		if (eventType != null) {
			payloadType = eventType.as(PayloadApplicationEvent.class).getGeneric();
		}
	}
	for (ResolvableType declaredEventType : this.declaredEventTypes) {
		Class<?> eventClass = declaredEventType.toClass();
		if (!ApplicationEvent.class.isAssignableFrom(eventClass) &&
				payloadType != null && declaredEventType.isAssignableFrom(payloadType)) {
			return declaredEventType;
		}
		if (eventClass.isInstance(event)) {
			return declaredEventType;
		}
	}
	return null;
}
 

private ResolvableType getResolvableType(ApplicationEvent event) {
	ResolvableType payloadType = null;
	if (event instanceof PayloadApplicationEvent) {
		PayloadApplicationEvent<?> payloadEvent = (PayloadApplicationEvent<?>) event;
		payloadType = payloadEvent.getResolvableType().as(PayloadApplicationEvent.class).getGeneric();
	}
	for (ResolvableType declaredEventType : this.declaredEventTypes) {
		if (!ApplicationEvent.class.isAssignableFrom(declaredEventType.getRawClass()) && payloadType != null) {
			if (declaredEventType.isAssignableFrom(payloadType)) {
				return declaredEventType;
			}
		}
		if (declaredEventType.getRawClass().isInstance(event)) {
			return declaredEventType;
		}
	}
	return null;
}
 

/**
 * Resolve the method arguments to use for the specified {@link ApplicationEvent}.
 * <p>These arguments will be used to invoke the method handled by this instance. Can
 * return {@code null} to indicate that no suitable arguments could be resolved and
 * therefore the method should not be invoked at all for the specified event.
 */
protected Object[] resolveArguments(ApplicationEvent event) {
	ResolvableType declaredEventType = getResolvableType(event);
	if (declaredEventType == null) {
		return null;
	}
	if (this.method.getParameterTypes().length == 0) {
		return new Object[0];
	}
	if (!ApplicationEvent.class.isAssignableFrom(declaredEventType.getRawClass()) &&
			event instanceof PayloadApplicationEvent) {
		return new Object[] {((PayloadApplicationEvent) event).getPayload()};
	}
	else {
		return new Object[] {event};
	}
}
 

/**
 * Resolve the method arguments to use for the specified {@link ApplicationEvent}.
 * <p>These arguments will be used to invoke the method handled by this instance. Can
 * return {@code null} to indicate that no suitable arguments could be resolved and
 * therefore the method should not be invoked at all for the specified event.
 */
@Nullable
protected Object[] resolveArguments(ApplicationEvent event) {
    ResolvableType declaredEventType = getResolvableType(event);
    if (declaredEventType == null || declaredEventType.getRawClass() == null) {
        return null;
    }
    if (this.method.getParameterTypes().length == 0) {
        return new Object[0];
    }
    if (!ApplicationEvent.class.isAssignableFrom(declaredEventType.getRawClass()) &&
            event instanceof PayloadApplicationEvent) {
        return new Object[]{((PayloadApplicationEvent) event).getPayload()};
    } else {
        return new Object[]{event};
    }
}
 

@Nullable
private ResolvableType getResolvableType(ApplicationEvent event) {
	ResolvableType payloadType = null;
	if (event instanceof PayloadApplicationEvent) {
		PayloadApplicationEvent<?> payloadEvent = (PayloadApplicationEvent<?>) event;
		ResolvableType eventType = payloadEvent.getResolvableType();
		if (eventType != null) {
			payloadType = eventType.as(PayloadApplicationEvent.class).getGeneric();
		}
	}
	for (ResolvableType declaredEventType : this.declaredEventTypes) {
		Class<?> eventClass = declaredEventType.toClass();
		if (!ApplicationEvent.class.isAssignableFrom(eventClass) &&
				payloadType != null && declaredEventType.isAssignableFrom(payloadType)) {
			return declaredEventType;
		}
		if (eventClass.isInstance(event)) {
			return declaredEventType;
		}
	}
	return null;
}
 

@Override
public void onApplicationEvent(PayloadApplicationEvent<TooManyFailureSmsVerificationAttemptsEvent> event) {
    // FIXME, introduce a command handler
    log.debug("Receiving {}", event.getPayload());
    TooManyFailureSmsVerificationAttemptsEvent eventPayload = event.getPayload();
    SmsVerification smsVerification = target.shouldFindBy(eventPayload.getMobile(), eventPayload.getScope());
    target.remove(smsVerification);
    log.info("The [{}] code for [{}] is removed due to too many failure verification attempts",
            smsVerification.getScope(), smsVerification.getMobile());
}
 

@Override
public void onApplicationEvent(PayloadApplicationEvent<SmsVerificationCodeVerifiedEvent> event) {
    log.debug("Receiving {}", event.getPayload().toString());
    target.on(event.getPayload());
    log.debug("Failure verification attempt count for [{}][{}] is reset", event.getPayload().getMobile(),
            event.getPayload().getScope());
}
 

@Override
public boolean supportsEventType(ResolvableType eventType) {
	for (ResolvableType declaredEventType : this.declaredEventTypes) {
		if (declaredEventType.isAssignableFrom(eventType)) {
			return true;
		}
		else if (PayloadApplicationEvent.class.isAssignableFrom(eventType.getRawClass())) {
			ResolvableType payloadType = eventType.as(PayloadApplicationEvent.class).getGeneric();
			if (declaredEventType.isAssignableFrom(payloadType)) {
				return true;
			}
		}
	}
	return eventType.hasUnresolvableGenerics();
}
 

@Test
public void invokeListenerWithSeveralTypes() {
	Method method = ReflectionUtils.findMethod(SampleEvents.class, "handleStringOrInteger");
	PayloadApplicationEvent<String> event = new PayloadApplicationEvent<>(this, "test");
	invokeListener(method, event);
	verify(this.sampleEvents, times(1)).handleStringOrInteger();
	PayloadApplicationEvent<Integer> event2 = new PayloadApplicationEvent<>(this, 123);
	invokeListener(method, event2);
	verify(this.sampleEvents, times(2)).handleStringOrInteger();
	PayloadApplicationEvent<Double> event3 = new PayloadApplicationEvent<>(this, 23.2);
	invokeListener(method, event3);
	verify(this.sampleEvents, times(2)).handleStringOrInteger();
}
 

/**
 * Returns the event as Spring {@link ApplicationEvent}, effectively wrapping it into a
 * {@link PayloadApplicationEvent} in case it's not one already.
 *
 * @return
 */
default ApplicationEvent getApplicationEvent() {

	Object event = getEvent();

	return PayloadApplicationEvent.class.isInstance(event) //
			? PayloadApplicationEvent.class.cast(event)
			: new PayloadApplicationEvent<>(this, event);
}
 

@Test
public void invokeListenerWithAnnotationValueAndParameter() {
	Method method = ReflectionUtils.findMethod(
			SampleEvents.class, "handleStringAnnotationValueAndParameter", String.class);
	PayloadApplicationEvent<String> event = new PayloadApplicationEvent<>(this, "test");
	invokeListener(method, event);
	verify(this.sampleEvents, times(1)).handleStringAnnotationValueAndParameter("test");
}
 

@EventListener
public static void addLoadInstant(final PayloadApplicationEvent<SystemInfo.LoadInstant> event) {
    synchronized (MONITOR) {
        initSystemInfo();
        SYSTEM_INFO.getLoad().add(event.getPayload());
    }
}
 

@Override
public boolean supportsEventType(ResolvableType eventType) {
	for (ResolvableType declaredEventType : this.declaredEventTypes) {
		if (declaredEventType.isAssignableFrom(eventType)) {
			return true;
		}
		else if (PayloadApplicationEvent.class.isAssignableFrom(eventType.getRawClass())) {
			ResolvableType payloadType = eventType.as(PayloadApplicationEvent.class).getGeneric();
			if (declaredEventType.isAssignableFrom(payloadType)) {
				return true;
			}
		}
	}
	return eventType.hasUnresolvableGenerics();
}
 

@Test
public void invokeListenerWithAnyGenericPayload() {
	Method method = ReflectionUtils.findMethod(
			SampleEvents.class, "handleGenericAnyPayload", EntityWrapper.class);
	EntityWrapper<String> payload = new EntityWrapper<>("test");
	invokeListener(method, new PayloadApplicationEvent<>(this, payload));
	verify(this.sampleEvents, times(1)).handleGenericAnyPayload(payload);
}
 

@Test
public void invokeListenerWithGenericPayload() {
	Method method = ReflectionUtils.findMethod(SampleEvents.class,
			"handleGenericStringPayload", EntityWrapper.class);
	EntityWrapper<String> payload = new EntityWrapper<>("test");
	invokeListener(method, new PayloadApplicationEvent<>(this, payload));
	verify(this.sampleEvents, times(1)).handleGenericStringPayload(payload);
}
 

@Test
public void invokeListenerWithWrongGenericPayload() {
	Method method = ReflectionUtils.findMethod(SampleEvents.class,
			"handleGenericStringPayload", EntityWrapper.class);
	EntityWrapper<Integer> payload = new EntityWrapper<>(123);
	invokeListener(method, new PayloadApplicationEvent<>(this, payload));
	verify(this.sampleEvents, times(0)).handleGenericStringPayload(any());
}
 

@Test
public void invokeListenerWithAnyGenericPayload() {
	Method method = ReflectionUtils.findMethod(SampleEvents.class,
			"handleGenericAnyPayload", EntityWrapper.class);
	EntityWrapper<String> payload = new EntityWrapper<>("test");
	invokeListener(method, new PayloadApplicationEvent<>(this, payload));
	verify(this.sampleEvents, times(1)).handleGenericAnyPayload(payload);
}
 

@Test
public void invokeListenerWithPayload() {
	Method method = ReflectionUtils.findMethod(SampleEvents.class,
			"handleString", String.class);
	PayloadApplicationEvent<String> event = new PayloadApplicationEvent<>(this, "test");
	invokeListener(method, event);
	verify(this.sampleEvents, times(1)).handleString("test");
}
 

@Test
public void invokeListenerWithPayloadWrongType() {
	Method method = ReflectionUtils.findMethod(SampleEvents.class,
			"handleString", String.class);
	PayloadApplicationEvent<Long> event = new PayloadApplicationEvent<>(this, 123L);
	invokeListener(method, event);
	verify(this.sampleEvents, never()).handleString(anyString());
}
 

@Test
public void invokeListenerWithAnnotationValue() {
	Method method = ReflectionUtils.findMethod(SampleEvents.class,
			"handleStringAnnotationClasses");
	PayloadApplicationEvent<String> event = new PayloadApplicationEvent<>(this, "test");
	invokeListener(method, event);
	verify(this.sampleEvents, times(1)).handleStringAnnotationClasses();
}
 

@Test
public void invokeListenerWithAnnotationValueAndParameter() {
	Method method = ReflectionUtils.findMethod(SampleEvents.class,
			"handleStringAnnotationValueAndParameter", String.class);
	PayloadApplicationEvent<String> event = new PayloadApplicationEvent<>(this, "test");
	invokeListener(method, event);
	verify(this.sampleEvents, times(1)).handleStringAnnotationValueAndParameter("test");
}
 

@Test
public void invokeListenerWithSeveralTypes() {
	Method method = ReflectionUtils.findMethod(SampleEvents.class,
			"handleStringOrInteger");
	PayloadApplicationEvent<String> event = new PayloadApplicationEvent<>(this, "test");
	invokeListener(method, event);
	verify(this.sampleEvents, times(1)).handleStringOrInteger();
	PayloadApplicationEvent<Integer> event2 = new PayloadApplicationEvent<>(this, 123);
	invokeListener(method, event2);
	verify(this.sampleEvents, times(2)).handleStringOrInteger();
	PayloadApplicationEvent<Double> event3 = new PayloadApplicationEvent<>(this, 23.2);
	invokeListener(method, event3);
	verify(this.sampleEvents, times(2)).handleStringOrInteger();
}
 

@Override
public boolean supportsEventType(@Nonnull ResolvableType eventType) {
    for (ResolvableType declaredEventType : this.declaredEventTypes) {
        if (declaredEventType.isAssignableFrom(eventType)) {
            return true;
        } else if (eventType.getRawClass() != null
                && PayloadApplicationEvent.class.isAssignableFrom(eventType.getRawClass())) {
            ResolvableType payloadType = eventType.as(PayloadApplicationEvent.class).getGeneric();
            if (declaredEventType.isAssignableFrom(payloadType)) {
                return true;
            }
        }
    }
    return eventType.hasUnresolvableGenerics();
}
 

protected void publishEvent(Object instance, Object event) {
    if (event != null) {
        if (event instanceof ApplicationEvent) {
            this.events.publish((ApplicationEvent) event);
        } else {
            this.events.publish(new PayloadApplicationEvent<>(instance, event));
        }
    }
}
 

@Nullable
protected ResolvableType getResolvableType(ApplicationEvent event) {
    ResolvableType payloadType = null;
    if (event instanceof PayloadApplicationEvent) {
        PayloadApplicationEvent<?> payloadEvent = (PayloadApplicationEvent<?>) event;
        ResolvableType resolvableType = payloadEvent.getResolvableType();
        if (resolvableType != null) {
            payloadType = resolvableType.as(PayloadApplicationEvent.class).getGeneric();
        }
    }

    for (ResolvableType declaredEventType : this.declaredEventTypes) {
        Class<?> rawClass = declaredEventType.getRawClass();

        if (rawClass != null) {
            if (!ApplicationEvent.class.isAssignableFrom(rawClass) && payloadType != null) {
                if (declaredEventType.isAssignableFrom(payloadType)) {
                    return declaredEventType;
                }
            }
            if (rawClass.isInstance(event)) {
                return declaredEventType;
            }
        }
    }
    return null;
}
 

@Override
public boolean supportsEventType(ResolvableType eventType) {
	for (ResolvableType declaredEventType : this.declaredEventTypes) {
		if (declaredEventType.isAssignableFrom(eventType)) {
			return true;
		}
		if (PayloadApplicationEvent.class.isAssignableFrom(eventType.toClass())) {
			ResolvableType payloadType = eventType.as(PayloadApplicationEvent.class).getGeneric();
			if (declaredEventType.isAssignableFrom(payloadType)) {
				return true;
			}
		}
	}
	return eventType.hasUnresolvableGenerics();
}