Refine search
@Bean @LoadBalanced RestTemplate restTemplate() { return new RestTemplate(); }
private <T> T doExecute(HttpMethod method, ServiceDTO service, String path, Object request, Class<T> responseType, Object... uriVariables) { T result = null; switch (method) { case GET: result = restTemplate.getForObject(parseHost(service) + path, responseType, uriVariables); break; case POST: result = restTemplate.postForEntity(parseHost(service) + path, request, responseType, uriVariables).getBody(); break; case PUT: restTemplate.put(parseHost(service) + path, request, uriVariables); break; case DELETE: restTemplate.delete(parseHost(service) + path, uriVariables); break; default: throw new UnsupportedOperationException(String.format("unsupported http method(method=%s)", method)); } return result; }
@Test public void exchangeGet() throws Exception { HttpHeaders requestHeaders = new HttpHeaders(); requestHeaders.set("MyHeader", "MyValue"); HttpEntity<String> requestEntity = new HttpEntity<>(requestHeaders); ResponseEntity<String> response = template.exchange(baseUrl + "/{method}", HttpMethod.GET, requestEntity, String.class, "get"); assertEquals("Invalid content", helloWorld, response.getBody()); }
RestTemplate restTemplate = new RestTemplate(); String url = "endpoint url"; String requestJson = "{\"queriedQuestion\":\"Is there pain in your hand?\"}"; HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); HttpEntity<String> entity = new HttpEntity<String>(requestJson,headers); String answer = restTemplate.postForObject(url, entity, String.class); System.out.println(answer);
@org.springframework.context.annotation.Primary @org.springframework.cloud.client.loadbalancer.LoadBalanced @org.springframework.context.annotation.Bean public RestTemplate defaultRestTemplate(@Autowired CompensableRequestInterceptor compensableRequestInterceptor) { RestTemplate restTemplate = new RestTemplate(); restTemplate.getInterceptors().add(compensableRequestInterceptor); return restTemplate; }
MultiValueMap<String, String> headers = new LinkedMultiValueMap<String, String>(); headers.add("Authorization", "Basic " + base64Creds); headers.add("Content-Type", "application/json"); RestTemplate restTemplate = new RestTemplate(); restTemplate.getMessageConverters().add(new MappingJackson2HttpMessageConverter()); HttpEntity<ObjectToPass> request = new HttpEntity<ObjectToPass>(ObjectToPass, headers); restTemplate.postForObject(urlPost, request, Boolean.class);
@Bean public RestTemplate restTemplate(){ return new RestTemplate(); } }
@LoadBalanced @Bean public RestTemplate restTemplate() { final RestTemplate template = new RestTemplate(); template.setErrorHandler(new TccResponseErrorHandler()); return template; }
@org.springframework.context.annotation.Bean("compensableRestTemplate") @org.springframework.cloud.client.loadbalancer.LoadBalanced public RestTemplate transactionTemplate(@Autowired ClientHttpRequestFactory requestFactory) { RestTemplate restTemplate = new RestTemplate(); restTemplate.setRequestFactory(requestFactory); SpringCloudBeanRegistry registry = SpringCloudBeanRegistry.getInstance(); registry.setRestTemplate(restTemplate); return restTemplate; }
public static String createInvitation(String baseUrl, String uaaUrl, String username, String userEmail, String origin, String redirectUri, String loginToken, String scimToken) { HttpHeaders headers = new HttpHeaders(); headers.add("Authorization", "Bearer " + scimToken); RestTemplate uaaTemplate = new RestTemplate(); ScimUser scimUser = new ScimUser(); scimUser.setPassword("password"); ResponseEntity<ScimUser> response = uaaTemplate.exchange(uaaUrl + "/Users", POST, request, ScimUser.class); if (response.getStatusCode().value()!= HttpStatus.CREATED.value()) { throw new IllegalStateException("Unable to create test user:"+scimUser); userId = response.getBody().getId(); } else { scimUser.setVerified(false); HttpHeaders invitationHeaders = new HttpHeaders(); invitationHeaders.add("Authorization", "Bearer " + loginToken); ExpiringCode expiringCode = new ExpiringCode(null, expiry, "{\"origin\":\"" + origin + "\", \"client_id\":\"app\", \"redirect_uri\":\"" + redirectUri + "\", \"user_id\":\"" + userId + "\", \"email\":\"" + userEmail + "\"}", null); HttpEntity<ExpiringCode> expiringCodeRequest = new HttpEntity<>(expiringCode, invitationHeaders); ResponseEntity<ExpiringCode> expiringCodeResponse = uaaTemplate.exchange(uaaUrl + "/Codes", POST, expiringCodeRequest, ExpiringCode.class); expiringCode = expiringCodeResponse.getBody(); return expiringCode.getCode();
@Test public void testRequestToFooHandler() throws Exception { URI url = new URI("http://localhost:" + this.port + "/foo"); RequestEntity<Void> request = RequestEntity.get(url).build(); ResponseEntity<byte[]> response = new RestTemplate().exchange(request, byte[].class); assertEquals(HttpStatus.OK, response.getStatusCode()); assertArrayEquals("foo".getBytes("UTF-8"), response.getBody()); }
@Override public RegisteredClient load(ServerConfiguration serverConfig) throws Exception { RestTemplate restTemplate = new RestTemplate(httpFactory); String serializedClient = gson.toJson(jsonRequest); HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); headers.setAccept(Lists.newArrayList(MediaType.APPLICATION_JSON)); String registered = restTemplate.postForObject(serverConfig.getRegistrationEndpointUri(), entity, String.class); String registered = restTemplate.exchange(knownClient.getRegistrationClientUri(), HttpMethod.GET, entity, String.class).getBody();
@Test public void testGetEmployeeAsJson() throws Exception{ Map<String, Object> employeeSearchMap = getEmployeeSearchMap("0"); final String fullUrl = "http://localhost:8080/rest-http/services/employee/{id}/search?format=json"; HttpHeaders headers = getHttpHeadersWithUserCredentials(new HttpHeaders()); headers.add("Accept", "application/json"); HttpEntity<Object> request = new HttpEntity<Object>(headers); ResponseEntity<?> httpResponse = restTemplate.exchange(fullUrl, HttpMethod.GET, request, EmployeeList.class, employeeSearchMap); logger.info("Return Status :"+httpResponse.getHeaders().get("X-Return-Status")); logger.info("Return Status Message :"+httpResponse.getHeaders().get("X-Return-Status-Msg")); assertTrue(httpResponse.getStatusCode().equals(HttpStatus.OK)); ByteArrayOutputStream out = new ByteArrayOutputStream(); jaxbJacksonObjectMapper.writeValue(out, httpResponse.getBody()); logger.info(new String(out.toByteArray())); }
@Test public void testRequestToHeaderSettingHandler() throws Exception { URI url = new URI("http://localhost:" + this.port + "/header"); RequestEntity<Void> request = RequestEntity.get(url).build(); ResponseEntity<byte[]> response = new RestTemplate().exchange(request, byte[].class); assertEquals(HttpStatus.OK, response.getStatusCode()); assertEquals("bar", response.getHeaders().getFirst("foo")); }
@Test public void exchange() throws Exception { mockTextPlainHttpMessageConverter(); HttpHeaders requestHeaders = new HttpHeaders(); mockSentRequest(POST, "http://example.com", requestHeaders); mockResponseStatus(HttpStatus.OK); String expected = "42"; mockResponseBody(expected, MediaType.TEXT_PLAIN); HttpHeaders entityHeaders = new HttpHeaders(); entityHeaders.set("MyHeader", "MyValue"); HttpEntity<String> entity = new HttpEntity<>("Hello World", entityHeaders); ResponseEntity<String> result = template.exchange("http://example.com", POST, entity, String.class); assertEquals("Invalid POST result", expected, result.getBody()); assertEquals("Invalid Content-Type", MediaType.TEXT_PLAIN, result.getHeaders().getContentType()); assertEquals("Invalid Accept header", MediaType.TEXT_PLAIN_VALUE, requestHeaders.getFirst("Accept")); assertEquals("Invalid custom header", "MyValue", requestHeaders.getFirst("MyHeader")); assertEquals("Invalid status code", HttpStatus.OK, result.getStatusCode()); verify(response).close(); }
public static void main(String[] args) throws Exception{ RestTemplate template = new RestTemplate(); Resource s2logo = new ClassPathResource(resourcePath); MultiValueMap<String, Object> multipartMap = new LinkedMultiValueMap<String, Object>(); multipartMap.add("company", "SpringSource"); multipartMap.add("company-logo", s2logo); logger.info("Created multipart request: " + multipartMap); HttpHeaders headers = new HttpHeaders(); headers.setContentType(new MediaType("multipart", "form-data")); HttpEntity<Object> request = new HttpEntity<Object>(multipartMap, headers); logger.info("Posting request to: " + uri); ResponseEntity<?> httpResponse = template.exchange(uri, HttpMethod.POST, request, Object.class); if (!httpResponse.getStatusCode().equals(HttpStatus.OK)){ logger.error("Problems with the request. Http status: " + httpResponse.getStatusCode()); } } }
@Test public void writeOnly() throws Exception { RestTemplate restTemplate = new RestTemplate(); this.body = randomBytes(); RequestEntity<byte[]> request = RequestEntity.post( new URI("http://localhost:" + port)).body( "".getBytes(StandardCharsets.UTF_8)); ResponseEntity<byte[]> response = restTemplate.exchange(request, byte[].class); assertArrayEquals(body, response.getBody()); }
HttpHeaders headers = new HttpHeaders(); if (StringUtils.hasText(token)) { headers.add(CONSUL_TOKEN, token); ResponseEntity<List<String>> response = this.restTemplate.exchange(WATCH_URL, HttpMethod.GET, request, RESPONSE_TYPE, params.toArray()); if (response.getStatusCode().is2xxSuccessful()) { String consulIndex = response.getHeaders().getFirst(CONSUL_INDEX); return consulIndex; if (!e.getStatusCode().equals(HttpStatus.NOT_FOUND)) { LOG.error("Unable to watch consul path " + this.path, e); return null;
@Test public void bar() { ResponseEntity<String> result = restTemplate.getForEntity("http://localhost:" + port + "/foo/bar", String.class); assertEquals(HttpStatus.OK, result.getStatusCode()); assertEquals("/foo/bar", result.getBody()); }
@Test public void getForEntity() throws Exception { HttpHeaders requestHeaders = new HttpHeaders(); mockSentRequest(GET, "http://example.com", requestHeaders); mockTextPlainHttpMessageConverter(); mockResponseStatus(HttpStatus.OK); String expected = "Hello World"; mockTextResponseBody(expected); ResponseEntity<String> result = template.getForEntity("http://example.com", String.class); assertEquals("Invalid GET result", expected, result.getBody()); assertEquals("Invalid Accept header", MediaType.TEXT_PLAIN_VALUE, requestHeaders.getFirst("Accept")); assertEquals("Invalid Content-Type header", MediaType.TEXT_PLAIN, result.getHeaders().getContentType()); assertEquals("Invalid status code", HttpStatus.OK, result.getStatusCode()); verify(response).close(); }