}
}
1. stay controller Medium injection RetryTemplate It can also be used in service in
@RestController
public class SpringRetryController {
@Resource
private RetryTemplate retryTemplate;
private static int count = 0;
@RequestMapping("/retry")
public Object retry() {
try {
count = 0;
retryTemplate.execute((RetryCallback<Void, RuntimeException>) context -> {
// Business code
// ....
// Simulate throwing an exception
++count;
throw new RuntimeException("Throw exception");
});
} catch (RuntimeException e) {
System.out.println("Exception");
}
return "retry = " + count;
}
}
1. visit retry Interface, and then observe the log output
18:27:20.648 - http-nio-8888-exec-1 - open
18:27:20.649 - http-nio-8888-exec-1 - retryTemplate.execute execute
18:27:20.649 - http-nio-8888-exec-1 - onError
18:27:21.658 - http-nio-8888-exec-1 - retryTemplate.execute execute
18:27:21.658 - http-nio-8888-exec-1 - onError
18:27:23.670 - http-nio-8888-exec-1 - retryTemplate.execute execute
18:27:23.670 - http-nio-8888-exec-1 - onError
18:27:27.679 - http-nio-8888-exec-1 - retryTemplate.execute execute
18:27:27.679 - http-nio-8888-exec-1 - onError
18:27:35.681 - http-nio-8888-exec-1 - retryTemplate.execute execute
18:27:35.681 - http-nio-8888-exec-1 - onError
18:27:35.681 - http-nio-8888-exec-1 - close
[](https://gitee.com/vip204888/java-p7) III. EnableRetry ================================================================================ 1. @EnableRetry Enable retry. When specified on the class, the method will execute by default and retry three times 2. definition service，open@EnableRetry Annotations and assignments@Retryable，Retry can refer to the following section
import org.springframework.retry.annotation.Retryable;
public interface RetryService {
/** * Retry method call */ @Retryable void retryServiceCall();
}
import org.springframework.retry.annotation.EnableRetry;
import org.springframework.stereotype.Service;
@EnableRetry
@Service
public class RetryServiceImpl implements RetryService {
@Override
public void retryServiceCall() {
PrintUtil.print("Method call..");
throw new RuntimeException("Manual exception");
}
}
```
1. controller Medium injection service
```
@RequestMapping("/retryAnnotation")
public Object retryAnnotation() {
retryService.retryServiceCall();
return "retryAnnotation";
}
```
1. Will retry by default
```
18:46:48.721 - http-nio-8888-exec-1 - Method call..
18:46:49.724 - http-nio-8888-exec-1 - Method call..
18:46:50.730 - http-nio-8888-exec-1 - Method call..
java.lang.RuntimeException: Manual exception
```
[](https://gitee.com/vip204888/java-p7) IV. Retryable
==============================================================================
1. Annotation on the method that needs to be retried
2. There are several properties
* Retryable Annotation parameters
* value: Specify the exception that occurred and try again
* include: and value Same, the default is null, when exclude When it is also empty, all exceptions are retried
* exclude: Specifies that the exception will not be retried. It is empty by default. When include When it is also empty, all exceptions are retried
* maxAttemps: Number of retries, 3 by default
* backoff: Retry compensation mechanism, not available by default
* @Backoff Annotation retry compensation strategy
* When no parameters are set, the default value is used FixedBackOffPolicy(Specify wait time), retry wait 1000 ms
* set up delay，use FixedBackOffPolicy(Specify wait settings delay and maxDealy Retry wait (evenly distributed between these two values)
* set up delay,maxDealy,multiplier，use ExponentialBackOffPolicy(Implementation of exponential retry interval), multiplier That is, specify the delay multiple, such as delay=5000L，multiplier=2,The first retry takes 5 seconds, the second 10 seconds, and the third 20 seconds
```
@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Retryable {
/**
* Retry interceptor bean name to be applied for retryable method. Is mutually
* exclusive with other attributes.
* @return the retry interceptor bean name
*/
String interceptor() default "";
/**
* Exception types that are retryable. Synonym for includes(). Defaults to empty (and
* if excludes is also empty all exceptions are retried).
* @return exception types to retry
*/
Class<? extends Throwable>[] value() default {};
/**
* Exception types that are retryable. Defaults to empty (and if excludes is also
* empty all exceptions are retried).
* @return exception types to retry
*/
Class<? extends Throwable>[] include() default {};
/**
* Exception types that are not retryable. Defaults to empty (and if includes is also
* empty all exceptions are retried).
* If includes is empty but excludes is not, all not excluded exceptions are retried
* @return exception types not to retry
*/
Class<? extends Throwable>[] exclude() default {};
/**
* A unique label for statistics reporting. If not provided the caller may choose to
* ignore it, or provide a default.
*
* @return the label for the statistics
*/
String label() default "";
/**
* Flag to say that the retry is stateful: i.e. exceptions are re-thrown, but the
* retry policy is applied with the same policy to subsequent invocations with the
* same arguments. If false then retryable exceptions are not re-thrown.
* @return true if retry is stateful, default false
*/
boolean stateful() default false;
/**
* @return the maximum number of attempts (including the first failure), defaults to 3
*/
int maxAttempts() default 3;
/**
* @return an expression evaluated to the maximum number of attempts (including the first failure), defaults to 3
* Overrides {@link #maxAttempts()}.
* @date 1.2
*/
String maxAttemptsExpression() default "";
/**
* Specify the backoff properties for retrying this operation. The default is a
* simple {@link Backoff} specification with no properties - see it's documentation
* for defaults.
* @return a backoff specification
*/
Backoff backoff() default @Backoff();
/**
* Specify an expression to be evaluated after the {@code SimpleRetryPolicy.canRetry()}
* returns true - can be used to conditionally suppress the retry. Only invoked after
* an exception is thrown. The root object for the evaluation is the last {@code Throwable}.
* Other beans in the context can be referenced.
* For example:
* <pre class=code>
* {@code "message.contains('you can retry this')"}.
* </pre>
* and
* <pre class=code>
* {@code "@someBean.shouldRetry(#root)"}.
* </pre>
* @return the expression.
* @date 1.2
*/
String exceptionExpression() default "";
/**
* Bean names of retry listeners to use instead of default ones defined in Spring context
* @return retry listeners bean names
*/
String[] listeners() default {};
}
```
1. On the method to be retried, configure the corresponding retry times, the exception type of the retry exception, set the fallback delay time, the retry policy, and the method listening name
```
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Backoff {
/**
* Synonym for {@link #delay()}.
*
* @return the delay in milliseconds (default 1000)
*/
long value() default 1000;
/**
* A canonical backoff period. Used as an initial value in the exponential case, and
* as a minimum value in the uniform case.
* @return the initial or canonical backoff period in milliseconds (default 1000)
*/
long delay() default 0;
/**
* The maximimum wait (in milliseconds) between retries. If less than the
* {@link #delay()} then the default of
* {@value org.springframework.retry.backoff.ExponentialBackOffPolicy#DEFAULT_MAX_INTERVAL}
* is applied.
*
* @return the maximum delay between retries (default 0 = ignored)
*/
long maxDelay() default 0;
/**
* If positive, then used as a multiplier for generating the next delay for backoff.
*
* @return a multiplier to use to calculate the next backoff delay (default 0 =
* ignored)
*/
double multiplier() default 0;
/**
* An expression evaluating to the canonical backoff period. Used as an initial value
* in the exponential case, and as a minimum value in the uniform case. Overrides
* {@link #delay()}.
* @return the initial or canonical backoff period in milliseconds.
* @date 1.2
*/
String delayExpression() default "";
/**
* An expression evaluating to the maximimum wait (in milliseconds) between retries.
* If less than the {@link #delay()} then the default of
* {@value org.springframework.retry.backoff.ExponentialBackOffPolicy#DEFAULT_MAX_INTERVAL}
* is applied. Overrides {@link #maxDelay()}
*
* @return the maximum delay between retries (default 0 = ignored)
* @date 1.2
*/
String maxDelayExpression() default "";
/**
* Evaluates to a vaule used as a multiplier for generating the next delay for
* backoff. Overrides {@link #multiplier()}.
*
* @return a multiplier expression to use to calculate the next backoff delay (default
* 0 = ignored)
* @date 1.2
*/
String multiplierExpression() default "";
/**
* In the exponential case ({@link #multiplier()} > 0) set this to true to have the
* backoff delays randomized, so that the maximum delay is multiplier times the
* previous delay and the distribution is uniform between the two values.
*
* @return the flag to signal randomization is required (default false)
*/
boolean random() default false;
}
@Component
public class PlatformClassService {
@Retryable(
// Retry the exception type of the exception
value = {Exception.class},
// max retries
maxAttempts = 5,
// Set fallback delay time
backoff = @Backoff(delay = 500),
// Configure callback method name
listeners = "retryListener"
)
public void call() {
System.out.println("call...");
throw new RuntimeException("Manual exception");
}
}
//The initial delay is 2 seconds, and then the acceptance is 1.5 times delayed for retry. The total number of retries is 4
@Retryable(value = {Exception.class}, maxAttempts = 4, backoff = @Backoff(delay = 2000L, multiplier = 1.5))
1. The listening method is configured in the configuration class
/**
- Annotation call
*/
@Bean
public RetryListener retryListener() {
return new RetryListener() {
@Override
public <T, E extends Throwable> boolean open(RetryContext context, RetryCallback<T, E> callback) {
Write at the end
Someone may ask me why I am willing to take the time to help you realize your dream of job hunting, because I always believe that time can be copied. I sacrificed about ten hours to write this article in exchange for thousands of job seekers to save days or even weeks on useless resources.
I have publicly shared the above learning resources (algorithms and data structures) + (Java multithreading learning manual) + (top-level computer network tutorial) here
I hope the above experience can help you. Friends who need these materials can Poke here , you can get it for free
(delay = 2000L, multiplier = 1.5))
1. The listening method is configured in the configuration class
/**
- Annotation call
*/
@Bean
public RetryListener retryListener() {
return new RetryListener() {
@Override
public <T, E extends Throwable> boolean open(RetryContext context, RetryCallback<T, E> callback) {
Write at the end
Someone may ask me why I am willing to take the time to help you realize your dream of job hunting, because I always believe that time can be copied. I sacrificed about ten hours to write this article in exchange for thousands of job seekers to save days or even weeks on useless resources.
[external chain picture transferring... (img-A2VI3rd4-1628419227218)]
[external chain picture transferring... (img-gijxIysa-1628419227220)]
I have publicly shared the above learning resources (algorithms and data structures) + (Java multithreading learning manual) + (top-level computer network tutorial) here
I hope the above experience can help you. Friends who need these materials can Poke here , you can get it for free