All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.springframework.boot.util.LambdaSafe Maven / Gradle / Ivy

Go to download

Spring Boot

There is a newer version: 3.3.3
Show newest version
/*
 * Copyright 2012-2018 the original author or authors.
 *
 * 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
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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.
 */

package org.springframework.boot.util;

import java.lang.reflect.Method;
import java.util.Collection;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Stream;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.core.ResolvableType;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.ReflectionUtils;

/**
 * Utility that can be used to invoke lambdas in a safe way. Primarily designed to help
 * support generically typed callbacks where {@link ClassCastException class cast
 * exceptions} need to be dealt with due to class erasure.
 *
 * @author Phillip Webb
 * @since 2.0.0
 */
public final class LambdaSafe {

	private static final Method CLASS_GET_MODULE;

	private static final Method MODULE_GET_NAME;

	static {
		CLASS_GET_MODULE = ReflectionUtils.findMethod(Class.class, "getModule");
		MODULE_GET_NAME = (CLASS_GET_MODULE != null)
				? ReflectionUtils.findMethod(CLASS_GET_MODULE.getReturnType(), "getName")
				: null;
	}

	private LambdaSafe() {
	}

	/**
	 * Start a call to a single callback instance, dealing with common generic type
	 * concerns and exceptions.
	 * @param callbackType the callback type (a {@link FunctionalInterface functional
	 * interface})
	 * @param callbackInstance the callback instance (may be a lambda)
	 * @param argument the primary argument passed to the callback
	 * @param additionalArguments any additional arguments passed to the callback
	 * @param  the callback type
	 * @param  the primary argument type
	 * @return a {@link Callback} instance that can be invoked.
	 */
	public static  Callback callback(Class callbackType,
			C callbackInstance, A argument, Object... additionalArguments) {
		Assert.notNull(callbackType, "CallbackType must not be null");
		Assert.notNull(callbackInstance, "CallbackInstance must not be null");
		return new Callback<>(callbackType, callbackInstance, argument,
				additionalArguments);
	}

	/**
	 * Start a call to callback instances, dealing with common generic type concerns and
	 * exceptions.
	 * @param callbackType the callback type (a {@link FunctionalInterface functional
	 * interface})
	 * @param callbackInstances the callback instances (elements may be lambdas)
	 * @param argument the primary argument passed to the callbacks
	 * @param additionalArguments any additional arguments passed to the callbacks
	 * @param  the callback type
	 * @param  the primary argument type
	 * @return a {@link Callbacks} instance that can be invoked.
	 */
	public static  Callbacks callbacks(Class callbackType,
			Collection callbackInstances, A argument,
			Object... additionalArguments) {
		Assert.notNull(callbackType, "CallbackType must not be null");
		Assert.notNull(callbackInstances, "CallbackInstances must not be null");
		return new Callbacks<>(callbackType, callbackInstances, argument,
				additionalArguments);
	}

	/**
	 * Abstract base class for lambda safe callbacks.
	 */
	private abstract static class LambdaSafeCallback> {

		private final Class callbackType;

		private final A argument;

		private final Object[] additionalArguments;

		private Log logger;

		private Filter filter = new GenericTypeFilter<>();

		protected LambdaSafeCallback(Class callbackType, A argument,
				Object[] additionalArguments) {
			this.callbackType = callbackType;
			this.argument = argument;
			this.additionalArguments = additionalArguments;
			this.logger = LogFactory.getLog(callbackType);
		}

		/**
		 * Use the specified logger source to report any lambda failures.
		 * @param loggerSource the logger source to use
		 * @return this instance
		 */
		public SELF withLogger(Class loggerSource) {
			return withLogger(LogFactory.getLog(loggerSource));
		}

		/**
		 * Use the specified logger to report any lambda failures.
		 * @param logger the logger to use
		 * @return this instance
		 */
		public SELF withLogger(Log logger) {
			Assert.notNull(logger, "Logger must not be null");
			this.logger = logger;
			return self();
		}

		/**
		 * Use a specific filter to determine when a callback should apply. If no explicit
		 * filter is set filter will be attempted using the generic type on the callback
		 * type.
		 * @param filter the filter to use
		 * @return this instance
		 */
		public SELF withFilter(Filter filter) {
			Assert.notNull(filter, "Filter must not be null");
			this.filter = filter;
			return self();
		}

		protected final  InvocationResult invoke(C callbackInstance,
				Supplier supplier) {
			if (this.filter.match(this.callbackType, callbackInstance, this.argument,
					this.additionalArguments)) {
				try {
					return InvocationResult.of(supplier.get());
				}
				catch (ClassCastException ex) {
					if (!isLambdaGenericProblem(ex)) {
						throw ex;
					}
					logNonMatchingType(callbackInstance, ex);
				}
			}
			return InvocationResult.noResult();
		}

		private boolean isLambdaGenericProblem(ClassCastException ex) {
			return (ex.getMessage() == null
					|| startsWithArgumentClassName(ex.getMessage()));
		}

		private boolean startsWithArgumentClassName(String message) {
			Predicate startsWith = (argument) -> startsWithArgumentClassName(
					message, argument);
			return startsWith.test(this.argument)
					|| Stream.of(this.additionalArguments).anyMatch(startsWith);
		}

		private boolean startsWithArgumentClassName(String message, Object argument) {
			if (argument == null) {
				return false;
			}
			Class argumentType = argument.getClass();
			if (message.startsWith(argumentType.getName())) {
				return true;
			}
			if (CLASS_GET_MODULE != null) {
				Object module = ReflectionUtils.invokeMethod(CLASS_GET_MODULE,
						argumentType);
				Object moduleName = ReflectionUtils.invokeMethod(MODULE_GET_NAME, module);
				if (message.startsWith(moduleName + "/" + argumentType.getName())) {
					return true;
				}
			}
			return false;
		}

		private void logNonMatchingType(C callback, ClassCastException ex) {
			if (this.logger.isDebugEnabled()) {
				Class expectedType = ResolvableType.forClass(this.callbackType)
						.resolveGeneric();
				String expectedTypeName = (expectedType != null)
						? ClassUtils.getShortName(expectedType) + " type" : "type";
				String message = "Non-matching " + expectedTypeName + " for callback "
						+ ClassUtils.getShortName(this.callbackType) + ": " + callback;
				this.logger.debug(message, ex);
			}
		}

		@SuppressWarnings("unchecked")
		private SELF self() {
			return (SELF) this;
		}

	}

	/**
	 * Represents a single callback that can be invoked in a lambda safe way.
	 *
	 * @param  the callback type
	 * @param  the primary argument type
	 */
	public static final class Callback
			extends LambdaSafeCallback> {

		private final C callbackInstance;

		private Callback(Class callbackType, C callbackInstance, A argument,
				Object[] additionalArguments) {
			super(callbackType, argument, additionalArguments);
			this.callbackInstance = callbackInstance;
		}

		/**
		 * Invoke the callback instance where the callback method returns void.
		 * @param invoker the invoker used to invoke the callback
		 */
		public void invoke(Consumer invoker) {
			invoke(this.callbackInstance, () -> {
				invoker.accept(this.callbackInstance);
				return null;
			});
		}

		/**
		 * Invoke the callback instance where the callback method returns a result.
		 * @param invoker the invoker used to invoke the callback
		 * @param  the result type
		 * @return the result of the invocation (may be {@link InvocationResult#noResult}
		 * if the callback was not invoked)
		 */
		public  InvocationResult invokeAnd(Function invoker) {
			return invoke(this.callbackInstance,
					() -> invoker.apply(this.callbackInstance));
		}

	}

	/**
	 * Represents a collection of callbacks that can be invoked in a lambda safe way.
	 *
	 * @param  the callback type
	 * @param  the primary argument type
	 */
	public static final class Callbacks
			extends LambdaSafeCallback> {

		private final Collection callbackInstances;

		private Callbacks(Class callbackType,
				Collection callbackInstances, A argument,
				Object[] additionalArguments) {
			super(callbackType, argument, additionalArguments);
			this.callbackInstances = callbackInstances;
		}

		/**
		 * Invoke the callback instances where the callback method returns void.
		 * @param invoker the invoker used to invoke the callback
		 */
		public void invoke(Consumer invoker) {
			this.callbackInstances.forEach((callbackInstance) -> {
				invoke(callbackInstance, () -> {
					invoker.accept(callbackInstance);
					return null;
				});
			});
		}

		/**
		 * Invoke the callback instances where the callback method returns a result.
		 * @param invoker the invoker used to invoke the callback
		 * @param  the result type
		 * @return the results of the invocation (may be an empty stream if no callbacks
		 * could be called)
		 */
		public  Stream invokeAnd(Function invoker) {
			Function> mapper = (callbackInstance) -> invoke(
					callbackInstance, () -> invoker.apply(callbackInstance));
			return this.callbackInstances.stream().map(mapper)
					.filter(InvocationResult::hasResult).map(InvocationResult::get);
		}

	}

	/**
	 * A filter that can be used to restrict when a callback is used.
	 *
	 * @param  the callback type
	 * @param  the primary argument type
	 */
	@FunctionalInterface
	interface Filter {

		/**
		 * Determine if the given callback matches and should be invoked.
		 * @param callbackType the callback type (the functional interface)
		 * @param callbackInstance the callback instance (the implementation)
		 * @param argument the primary argument
		 * @param additionalArguments any additional arguments
		 * @return if the callback matches and should be invoked
		 */
		boolean match(Class callbackType, C callbackInstance, A argument,
				Object[] additionalArguments);

		/**
		 * Return a {@link Filter} that allows all callbacks to be invoked.
		 * @param  the callback type
		 * @param  the primary argument type
		 * @return an "allow all" filter
		 */
		static  Filter allowAll() {
			return (callbackType, callbackInstance, argument,
					additionalArguments) -> true;
		}

	}

	/**
	 * {@link Filter} that matches when the callback has a single generic and primary
	 * argument is an instance of it.
	 */
	private static class GenericTypeFilter implements Filter {

		@Override
		public boolean match(Class callbackType, C callbackInstance, A argument,
				Object[] additionalArguments) {
			ResolvableType type = ResolvableType.forClass(callbackType,
					callbackInstance.getClass());
			if (type.getGenerics().length == 1 && type.resolveGeneric() != null) {
				return type.resolveGeneric().isInstance(argument);
			}

			return true;
		}

	}

	/**
	 * The result of a callback which may be a value, {@code null} or absent entirely if
	 * the callback wasn't suitable. Similar in design to {@link Optional} but allows for
	 * {@code null} as a valid value.
	 *
	 * @param  the result type
	 */
	public static final class InvocationResult {

		private static final InvocationResult NONE = new InvocationResult<>(null);

		private final R value;

		private InvocationResult(R value) {
			this.value = value;
		}

		/**
		 * Return true if a result in present.
		 * @return if a result is present
		 */
		public boolean hasResult() {
			return this != NONE;
		}

		/**
		 * Return the result of the invocation or {@code null} if the callback wasn't
		 * suitable.
		 * @return the result of the invocation or {@code null}
		 */
		public R get() {
			return this.value;
		}

		/**
		 * Return the result of the invocation or the given fallback if the callback
		 * wasn't suitable.
		 * @param fallback the fallback to use when there is no result
		 * @return the result of the invocation or the fallback
		 */
		public R get(R fallback) {
			return (this != NONE) ? this.value : fallback;
		}

		/**
		 * Create a new {@link InvocationResult} instance with the specified value.
		 * @param value the value (may be {@code null})
		 * @param  the result type
		 * @return an {@link InvocationResult}
		 */
		public static  InvocationResult of(R value) {
			return new InvocationResult<>(value);
		}

		/**
		 * Return an {@link InvocationResult} instance representing no result.
		 * @param  the result type
		 * @return an {@link InvocationResult}
		 */
		@SuppressWarnings("unchecked")
		public static  InvocationResult noResult() {
			return (InvocationResult) NONE;
		}

	}

}
    

    

    
            
    
            







    
© 2015 - 2024 Weber Informatics LLC | Privacy Policy