web-dev-qa-db-fra.com

Spring Boot @retryable ne pas réessayer

Le code suivant ne réessaye pas. Qu'est-ce que je rate?

@EnableRetry
@SpringBootApplication
public class App implements CommandLineRunner
{
    .........
    .........


    @Retryable()
    ResponseEntity<String> authenticate(RestTemplate restTemplate, HttpEntity<MultiValueMap<String, String>> entity) throws Exception
    {
        System.out.println("try!");
        throw new Exception();
        //return restTemplate.exchange(auth_endpoint, HttpMethod.POST, entity, String.class);
    }

J'ai ajouté ce qui suit au fichier pom.xml.

    <dependency>
        <groupId>org.springframework.retry</groupId>
        <artifactId>spring-retry</artifactId>
        <version>1.1.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>

J'ai également essayé de fournir différentes combinaisons d'arguments à @Retryable.

@Retryable(maxAttempts=10,value=Exception.class,backoff=@Backoff(delay = 2000,multiplier=2))

Merci.

javaspringmavenspring-bootspring-retry
6
engg

Pour que l'annotation @Retryable de la méthode soit découverte, elle doit être appelée correctement à partir d'un contexte initialisé. La méthode est-elle invoquée à partir d'un haricot du contexte de printemps ou par d'autres moyens?

Si vous testez ceci, votre coureur utilise le SpringJunit4ClassRunner?

7
UserF40

Dans Spring Boot 2.0.2 Release, j’ai observé que le @Retryable ne fonctionnait pas si vous utilisiez la méthode retryable et appelée dans la même classe. Lors du débogage, on s’aperçoit que le pointcut n’est pas construit correctement. Pour le moment, la solution à ce problème consiste à écrire la méthode dans une classe différente et à l'appeler. 

Vous pouvez trouver un exemple de travail ici .

5
nkharche

Je l'ai résolu. J'ai compris que si retourner quelque chose de la méthode que vous essayez de réessayer, alors @Retryable () ne fonctionne pas.

dépendance maven dans pom.xml

    <dependency>
        <groupId>org.springframework.retry</groupId>
        <artifactId>spring-retry</artifactId>
        <version>1.1.5.RELEASE</version>
    </dependency>

Application de démarrage à ressort.Java

@SpringBootApplication
@EnableTransactionManagement
@EnableRetry
public class Application {

     public static void main(String[] args) throws Exception {
       SpringApplication.run(Application.class, args);
     }

}

dans controller.Java

@RestController
public class JavaAllDataTypeController {

@Autowired
JavaAllDataTypeService JavaAllDataTypeService;


@RequestMapping(
        value = "/springReTryTest",
        method = RequestMethod.GET
)
public ResponseEntity<String> springReTryTest() {

    System.out.println("springReTryTest controller");

    try {
         JavaAllDataTypeService.springReTryTest();
    } catch (Exception e) {
        e.printStackTrace();
    }

    return new  ResponseEntity<String>("abcd", HttpStatus.OK);
  }

}

en service.Java

@Service
@Transactional
public class JavaAllDataTypeService {

 // try the method 9 times with 2 seconds delay.
 @Retryable(maxAttempts=9,value=Exception.class,backoff=@Backoff(delay = 2000))
 public void springReTryTest() throws Exception {

    System.out.println("try!");
    throw new Exception();
  }

}

sortie: Il essaie 9 fois puis jette exception.

 enter image description here

3
wahid_cse

Cela fonctionne aussi pour le type de retour

@Service
public class RetryService {

private int count = 0;

// try the method 9 times with 2 seconds delay.
@Retryable(maxAttempts = 9, value = Exception.class, backoff = @Backoff(delay = 2000))
public String springReTryTest() throws Exception {
    count++;
    System.out.println("try!");

    if (count < 4)
        throw new Exception();
    else
        return "bla";
  }

}
2
Chinmay Samant

Une alternative pourrait être RetryTemplate 

@Bean
    public RetryTemplate retryTemplate() {
        RetryTemplate retryTemplate = new RetryTemplate();

        FixedBackOffPolicy fixedBackOffPolicy = new FixedBackOffPolicy();
        fixedBackOffPolicy.setBackOffPeriod(2000l);
        retryTemplate.setBackOffPolicy(fixedBackOffPolicy);

        SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
        retryPolicy.setMaxAttempts(2);
        retryTemplate.setRetryPolicy(retryPolicy);

        return retryTemplate;
    }

et

retryTemplate.execute(new RetryCallback<Void, RuntimeException>() {
    @Override
    public Void doWithRetry(RetryContext arg0) {
        myService.templateRetryService();
        ...
    }
});

travaillé pour moi

la source

0
BiScOtTiNo