MeasTempo Spring RestTemplate Tempo di richiesta HTTP

Question

Desidero misurare l'ora della richiesta HTTP GET di una chiamata RestTemplate.getForObject senza il tempo necessario per analizzare la risposta. Quindi solo il tempo necessario per la chiamata HTTP remota. Ho già provato a installare un ClientHttpRequestInterceptor ma non penso che questo sia il modo giusto per farlo come il tempo sembra essere sbagliato:

public class PerfRequestSyncInterceptor implements ClientHttpRequestInterceptor { 
private Logger log = Logger.getLogger(this.getClass()); 

@Override 
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, 
     ClientHttpRequestExecution execution) throws IOException { 

    long start = System.nanoTime(); 
    ClientHttpResponse resp = execution.execute(request, body); 

    log.debug("remote request time: " 
      + ((System.nanoTime() - start) * Math.pow(10, -9))); 
    return resp; 
    } 
} 

chiamata:

RestTemplate rest = new RestTemplate(); 
List<ClientHttpRequestInterceptor> interceptors = new ArrayList<ClientHttpRequestInterceptor>(); 
interceptors.add(new PerfRequestSyncInterceptor()); 
rest.setInterceptors(interceptors); 

Response inob = rest.getForObject(xmlURL, Response.class); 

Come posso misurare il tempo di una richiesta HTTP RestTemplate?

Answer 1

È possibile utilizzare AOP e l'integrato PerformanceMonitorInterceptor di Spring. È necessario definire correttamente i metodi di cui si desidera intercettare il calss che è possibile misurare. È possibile configurarlo in questo modo:

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
     xmlns:aop="http://www.springframework.org/schema/aop" 
     xsi:schemaLocation="http://www.springframework.org/schema/beans  
     http://www.springframework.org/schema/beans/spring-beans-2.0.xsd 
     http://www.springframework.org/schema/aop 
     http://www.springframework.org/schema/aop/spring-aop-2.0.xsd"> 
    <bean id="springMonitoredService" 
     class="com.myorg.service.springmon.MyServiceSpringImpl"/> 


    <bean id="springMonitoringAspectInterceptor"   
class="org.springframework.aop.interceptor.PerformanceMonitorInterceptor"> 
     <property name="loggerName"  
       value="com.myorg.SPRING_MONITOR"/>  
    </bean> 


    <aop:config> 
      <aop:pointcut id="springMonitoringPointcut" 
        expression="execution(* java.net.HttpURLConnection.connect(..))"/> 




       <aop:advisor pointcut-ref="springMonitoringPointcut" 
      advice-ref="springMonitoringAspectInterceptor"/>  
    </aop:config> 

</beans> 

Answer 2

È possibile utilizzare StopWatch per farlo.

public class PerfRequestSyncInterceptor implements ClientHttpRequestInterceptor { 

    private final static Logger LOG = LoggerFactory.getLogger(PerfRequestSyncInterceptor.class); 

    @Override 
    public ClientHttpResponse intercept(HttpRequest hr, byte[] bytes, ClientHttpRequestExecution chre) throws IOException { 
     Stopwatch stopwatch = Stopwatch.createStarted(); 
     ClientHttpResponse response = chre.execute(hr, bytes); 
     stopwatch.stop(); 

     LOG.info("method=" + hr.getMethod() + ", uri="+hr.getURI() + ", response_time=" + stopwatch.elapsed(TimeUnit.MILLISECONDS) + ", response_code=" + response.getStatusCode().value()); 

     return response; 
    } 
} 

E nella classe in cui restTemplate viene istanziato

private final List<ClientHttpRequestInterceptor> requestInterceptors = new ArrayList<>(); 
requestInterceptors.add(new PerfRequestSyncInterceptor()); 
this.restTemplate.setInterceptors(requestInterceptors); 

Answer 3

voglio misurare il tempo della richiesta HTTP GET di una chiamata RestTemplate.getForObject senza il tempo necessario per l'analisi di la risposta

Ho avuto gli stessi requisiti. Voglio sapere il tempo di risposta del server per valutare quanto tempo impiega il server a rispondere senza alcuna elaborazione di risposta RestTemplate. Ho aggiunto due intercettori allo HttpClientBuilder con una mappa in modo da poter misurare il tempo tra la richiesta e la risposta di basso livello.

HttpClientBuilder httpClientBuilder = HttpClientBuilder.create(); 

// Attach interceptors 
ResponseTimeInterceptor interceptor = new ResponseTimeInterceptor(); 
httpClientBuilder.addInterceptorFirst((HttpRequestInterceptor) interceptor); 
httpClientBuilder.addInterceptorFirst((HttpResponseInterceptor) interceptor); 

// Use client with RestTemplate or on its own 
HttpClient client = httpClientBuilder.build(); 

Ecco il minimo intercettore dual-dovere:

public class ResponseTimeInterceptor implements HttpRequestInterceptor, HttpResponseInterceptor { 
    private final Map<HttpContext, Long> requestMap = new MaxSizeHashMap<>(50); 

    @Override 
    public void process(HttpRequest httpRequest, HttpContext httpContext) throws HttpException, IOException { 
     requestMap.put(httpContext, System.currentTimeMillis()); 
    } 

    @Override 
    public void process(HttpResponse httpResponse, HttpContext httpContext) throws HttpException, IOException { 
     long startTime = requestMap.getOrDefault(httpContext, 0L); 
     long diff = System.currentTimeMillis() - startTime; 
     System.out.println("Response time: " + diff + "ms"); 
    } 
} 

Dopo il ritorno di risposta intercettori, i dati di risposta continua nel gestore di risposta RestTemplate.

Nota: lo MaxSizeHashMap viene preso da https://stackoverflow.com/a/5601377.