io.bitsensor.plugins.shaded.org.springframework.retry.annotation.AnnotationAwareRetryOperationsInterceptor Maven / Gradle / Ivy
The newest version!
/*
* Copyright 2014-2016 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 io.bitsensor.plugins.shaded.org.springframework.retry.annotation;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import io.bitsensor.plugins.shaded.org.springframework.aop.IntroductionInterceptor;
import io.bitsensor.plugins.shaded.org.springframework.beans.BeansException;
import io.bitsensor.plugins.shaded.org.springframework.beans.factory.BeanFactory;
import io.bitsensor.plugins.shaded.org.springframework.beans.factory.BeanFactoryAware;
import io.bitsensor.plugins.shaded.org.springframework.beans.factory.config.ConfigurableBeanFactory;
import io.bitsensor.plugins.shaded.org.springframework.context.expression.BeanFactoryResolver;
import io.bitsensor.plugins.shaded.org.springframework.core.annotation.AnnotationAwareOrderComparator;
import io.bitsensor.plugins.shaded.org.springframework.core.annotation.AnnotationUtils;
import io.bitsensor.plugins.shaded.org.springframework.expression.common.TemplateParserContext;
import io.bitsensor.plugins.shaded.org.springframework.expression.spel.standard.SpelExpressionParser;
import io.bitsensor.plugins.shaded.org.springframework.expression.spel.support.StandardEvaluationContext;
import io.bitsensor.plugins.shaded.org.springframework.retry.RetryListener;
import io.bitsensor.plugins.shaded.org.springframework.retry.RetryPolicy;
import io.bitsensor.plugins.shaded.org.springframework.retry.backoff.BackOffPolicy;
import io.bitsensor.plugins.shaded.org.springframework.retry.backoff.ExponentialBackOffPolicy;
import io.bitsensor.plugins.shaded.org.springframework.retry.backoff.ExponentialRandomBackOffPolicy;
import io.bitsensor.plugins.shaded.org.springframework.retry.backoff.FixedBackOffPolicy;
import io.bitsensor.plugins.shaded.org.springframework.retry.backoff.NoBackOffPolicy;
import io.bitsensor.plugins.shaded.org.springframework.retry.backoff.Sleeper;
import io.bitsensor.plugins.shaded.org.springframework.retry.backoff.UniformRandomBackOffPolicy;
import io.bitsensor.plugins.shaded.org.springframework.retry.interceptor.FixedKeyGenerator;
import io.bitsensor.plugins.shaded.org.springframework.retry.interceptor.MethodArgumentsKeyGenerator;
import io.bitsensor.plugins.shaded.org.springframework.retry.interceptor.MethodInvocationRecoverer;
import io.bitsensor.plugins.shaded.org.springframework.retry.interceptor.NewMethodArgumentsIdentifier;
import io.bitsensor.plugins.shaded.org.springframework.retry.interceptor.RetryInterceptorBuilder;
import io.bitsensor.plugins.shaded.org.springframework.retry.policy.CircuitBreakerRetryPolicy;
import io.bitsensor.plugins.shaded.org.springframework.retry.policy.ExpressionRetryPolicy;
import io.bitsensor.plugins.shaded.org.springframework.retry.policy.MapRetryContextCache;
import io.bitsensor.plugins.shaded.org.springframework.retry.policy.RetryContextCache;
import io.bitsensor.plugins.shaded.org.springframework.retry.policy.SimpleRetryPolicy;
import io.bitsensor.plugins.shaded.org.springframework.retry.support.RetryTemplate;
import io.bitsensor.plugins.shaded.org.springframework.util.ReflectionUtils;
import io.bitsensor.plugins.shaded.org.springframework.util.ReflectionUtils.MethodCallback;
import io.bitsensor.plugins.shaded.org.springframework.util.StringUtils;
/**
* Interceptor that parses the retry metadata on the method it is invoking and
* delegates to an appropriate RetryOperationsInterceptor.
*
* @author Dave Syer
* @author Artem Bilan
* @author Gary Russell
* @since 1.1
*
*/
public class AnnotationAwareRetryOperationsInterceptor implements IntroductionInterceptor, BeanFactoryAware {
private static final TemplateParserContext PARSER_CONTEXT = new TemplateParserContext();
private static final SpelExpressionParser PARSER = new SpelExpressionParser();
private final StandardEvaluationContext evaluationContext = new StandardEvaluationContext();
private final Map delegates = new HashMap();
private RetryContextCache retryContextCache = new MapRetryContextCache();
private MethodArgumentsKeyGenerator methodArgumentsKeyGenerator;
private NewMethodArgumentsIdentifier newMethodArgumentsIdentifier;
private Sleeper sleeper;
private BeanFactory beanFactory;
private RetryListener[] listeners;
/**
* @param sleeper the sleeper to set
*/
public void setSleeper(Sleeper sleeper) {
this.sleeper = sleeper;
}
/**
* Public setter for the {@link RetryContextCache}.
*
* @param retryContextCache the {@link RetryContextCache} to set.
*/
public void setRetryContextCache(RetryContextCache retryContextCache) {
this.retryContextCache = retryContextCache;
}
/**
* @param methodArgumentsKeyGenerator the {@link MethodArgumentsKeyGenerator}
*/
public void setKeyGenerator(MethodArgumentsKeyGenerator methodArgumentsKeyGenerator) {
this.methodArgumentsKeyGenerator = methodArgumentsKeyGenerator;
}
/**
* @param newMethodArgumentsIdentifier the {@link NewMethodArgumentsIdentifier}
*/
public void setNewItemIdentifier(NewMethodArgumentsIdentifier newMethodArgumentsIdentifier) {
this.newMethodArgumentsIdentifier = newMethodArgumentsIdentifier;
}
/**
* Retry listeners to apply to all operations.
* @param listeners the listeners
*/
public void setListeners(Collection listeners) {
ArrayList retryListeners = new ArrayList(listeners);
AnnotationAwareOrderComparator.sort(retryListeners);
this.listeners = retryListeners.toArray(new RetryListener[0]);
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.beanFactory = beanFactory;
this.evaluationContext.setBeanResolver(new BeanFactoryResolver(beanFactory));
}
@Override
public boolean implementsInterface(Class intf) {
return io.bitsensor.plugins.shaded.org.springframework.retry.interceptor.Retryable.class.isAssignableFrom(intf);
}
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
MethodInterceptor delegate = getDelegate(invocation.getThis(), invocation.getMethod());
if (delegate != null) {
return delegate.invoke(invocation);
}
else {
return invocation.proceed();
}
}
private MethodInterceptor getDelegate(Object target, Method method) {
if (!this.delegates.containsKey(method)) {
synchronized (this.delegates) {
if (!this.delegates.containsKey(method)) {
Retryable retryable = AnnotationUtils.findAnnotation(method, Retryable.class);
if (retryable == null) {
retryable = AnnotationUtils.findAnnotation(method.getDeclaringClass(), Retryable.class);
}
if (retryable == null) {
retryable = findAnnotationOnTarget(target, method);
}
if (retryable == null) {
return this.delegates.put(method, null);
}
MethodInterceptor delegate;
if (StringUtils.hasText(retryable.interceptor())) {
delegate = this.beanFactory.getBean(retryable.interceptor(), MethodInterceptor.class);
}
else if (retryable.stateful()) {
delegate = getStatefulInterceptor(target, method, retryable);
}
else {
delegate = getStatelessInterceptor(target, method, retryable);
}
this.delegates.put(method, delegate);
}
}
}
return this.delegates.get(method);
}
private Retryable findAnnotationOnTarget(Object target, Method method) {
try {
Method targetMethod = target.getClass().getMethod(method.getName(), method.getParameterTypes());
return AnnotationUtils.findAnnotation(targetMethod, Retryable.class);
}
catch (Exception e) {
return null;
}
}
private MethodInterceptor getStatelessInterceptor(Object target, Method method, Retryable retryable) {
RetryTemplate template = createTemplate();
template.setRetryPolicy(getRetryPolicy(retryable));
template.setBackOffPolicy(getBackoffPolicy(retryable.backoff()));
return RetryInterceptorBuilder.stateless()
.retryOperations(template)
.label(retryable.label())
.recoverer(getRecoverer(target, method))
.build();
}
private MethodInterceptor getStatefulInterceptor(Object target, Method method, Retryable retryable) {
RetryTemplate template = createTemplate();
template.setRetryContextCache(this.retryContextCache);
CircuitBreaker circuit = AnnotationUtils.findAnnotation(method, CircuitBreaker.class);
if (circuit!=null) {
RetryPolicy policy = getRetryPolicy(circuit);
CircuitBreakerRetryPolicy breaker = new CircuitBreakerRetryPolicy(policy);
breaker.setOpenTimeout(circuit.openTimeout());
breaker.setResetTimeout(circuit.resetTimeout());
template.setRetryPolicy(breaker);
template.setBackOffPolicy(new NoBackOffPolicy());
String label = circuit.label();
if (!StringUtils.hasText(label)) {
label = method.toGenericString();
}
return RetryInterceptorBuilder.circuitBreaker()
.keyGenerator(new FixedKeyGenerator("circuit"))
.retryOperations(template)
.recoverer(getRecoverer(target, method))
.label(label)
.build();
}
RetryPolicy policy = getRetryPolicy(retryable);
template.setRetryPolicy(policy);
template.setBackOffPolicy(getBackoffPolicy(retryable.backoff()));
String label = retryable.label();
return RetryInterceptorBuilder.stateful()
.keyGenerator(this.methodArgumentsKeyGenerator)
.newMethodArgumentsIdentifier(this.newMethodArgumentsIdentifier)
.retryOperations(template)
.label(label)
.recoverer(getRecoverer(target, method))
.build();
}
private RetryTemplate createTemplate() {
RetryTemplate template = new RetryTemplate();
if (listeners!=null) {
template.setListeners(listeners);
}
return template;
}
private MethodInvocationRecoverer getRecoverer(Object target, Method method) {
if (target instanceof MethodInvocationRecoverer) {
return (MethodInvocationRecoverer) target;
}
final AtomicBoolean foundRecoverable = new AtomicBoolean(false);
ReflectionUtils.doWithMethods(target.getClass(), new MethodCallback() {
@Override
public void doWith(Method method) throws IllegalArgumentException,
IllegalAccessException {
if (AnnotationUtils.findAnnotation(method, Recover.class) != null) {
foundRecoverable.set(true);
}
}
});
if (!foundRecoverable.get()) {
return null;
}
return new RecoverAnnotationRecoveryHandler