web-dev-qa-db-fra.com

Comment résoudre "atteint le nombre maximum de balises URI pour http.client.Requests" AVERTISSEMENT?

Je reçois cet avertissement sur mon application. Je lis des rfidtags d'environ 30 lecteurs en même temps. Chaque fois qu'une balise vient dans, je frappe la base de données pour voir si elle est là. J'ai une API de repos que j'utilise. J'utilise donc un modèle de repos pour frapper l'API de repos. Des idées sur la façon de résoudre ce problème? Merci!

Voici une partie de mon code:

private void vehicleRequests(List<Maybevehicle> vehicles){
    //process list of unique tags to see if they are in the database and linked to a vehicle
    List<Maybevehicle> foundMaybeVehs= new ArrayList<>();
    List<Maybevehicle> notFound=new ArrayList<>();
     if(!vehicles.isEmpty()){
             for (Maybevehicle v: vehicles){
                Future<Maybevehicle> r=aService.batchVehTags(v);

                try{
                    Maybevehicle m=r.get(2000, TimeUnit.SECONDS);
                    if(r.isDone()){
                        if (!(m.getB().getVin().equals("notindb"))){
                            foundMaybeVehs.add(m);
                        }
                        }
                    }
                }catch(InterruptedException | ExecutionException | TimeoutException e){

                }
             }

              if(!foundMaybeVehs.isEmpty()){
                 addLocation(foundMaybeVehs);
             }
     }else{
         log.info("no vehicles to check.");
     }

}       


@Override
public Future<Maybevehicle> batchVehTags(Maybevehicle v) {
    Future<Maybevehicle> future=null;
         try{
                 SimpleTaskMaybeveh task=new SimpleTaskMaybeveh(v, appRestTemplate);
                  future=dbService.submit(task);

             }catch(Exception e){
                    e.printStackTrace();
                 }

            return future;
        }




}

public class SimpleTaskMaybeveh implements Callable<Maybevehicle>{

private RestTemplate appRestTemplate;
private Maybevehicle veh;

public SimpleTaskMaybeveh(Maybevehicle veh, RestTemplate appRestTemplate){
    this.veh=veh;
    this.appRestTemplate=appRestTemplate;
}

@Override
public Maybevehicle call(){
  String url="http://url/"+veh.getB().getRfidtag();
    String authString= "";
    byte[] encodedAuth= Base64.encodeBase64(authString.getBytes(Charset.forName("US-ASCII")));
    String authHeader="Basic "+new String(encodedAuth);
    HttpHeaders headers = new HttpHeaders();
    headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
    headers.set("Authorization", authHeader);
    HttpEntity<Bmwvehiclemain> requestEntity=new HttpEntity <Bmwvehiclemain>(headers);
    ResponseEntity<Bmwvehiclemain> results=appRestTemplate.exchange(url, HttpMethod.GET, requestEntity, Bmwvehiclemain.class);
    try{
        Bmwvehiclemain n=results.getBody();
        Maybevehicle d=new Maybevehicle(n,veh.getNewtaglocation());
        return d;
    }catch(Exception e){
        Maybevehicle notveh=new Maybevehicle("notindb");
        return notveh;
    }
}

}
javaspring-bootresttemplate
9
Roro

Ainsi, l'application de printemps collecte des métriques sur tous les appels d'API entrants et sortants. Ces métriques peuvent être interrogées pour voir combien de fois une certaine URL a été appelée.

Dans votre méthode public Maybevehicle call(), vous construisez l'URL en ajoutant à une chaîne. Cela mettra chaque URL avec une RFIDTAG unique dans son propre seau d'étiquette URI.

Afin d'éviter ce problème, vous pouvez utiliser une carte d'urivariables:

String url = “http://url/{rfidtag}”;
Map<String, ?> uriVariables = new HashMap<>();
uriVariables.put(“rfidtag”, veh.getB().getRfidtag();
…
ResponseEntity<Bmwvehiclemain> results = appRestTemplate
        .exchange(url, HttpMethod.GET, requestEntity, Bmwvehiclemain.class, uriVariables);

Cela permet de collecter des métriques de printemps sur http://url/{rfidtag} Au lieu d'avoir une étiquette URI pour http://url/rfidtag1, http://url/rfidtag2, http://url/rfidtag3, et ainsi de suite.

Cela devrait réduire le nombre de balises URI que votre application crée.

La valeur par défaut du nombre maximal de balises URI est 100. Si vous voulez des mesures sur plus de cela, vous pouvez le personnaliser en définissant sa valeur de propriété à autre chose. Par exemple, mon application de printemps est configurée avec mon projectname-ws/src/main/resources/config/application.yml déposer. Dans ce fichier, je pourrais mettre quelque chose comme

management:
  metrics:
    web:
      client:
        max-uri-tags: 200
      server:
        max-uri-tags: 200

pour augmenter le nombre maximum de balises URI utilisées pour les métriques.

Si vous ne voulez tout simplement pas le Reached the maximum number of URI tags for http.client.requests AVERTISSEMENT, vous pouvez mettre

@SpringBootApplication(exclude = HttpClientMetricsAutoConfiguration.class)

en haut de la classe, vous exécutez votre candidature à partir de laquelle vous vous débarrasserez du message d'avertissement, mais vous ne résolvez probablement pas la question sous-jacente.

3
Paul