Java Code Examples for org.springframework.web.client.resttemplate#getForObject()

@Override
public ProductInformation byId(String id) {
    Map<String, String> uriParameters = new HashMap<>();
    uriParameters.put("id", id);
    RestTemplate rest = new RestTemplate();
    InventoryItemAmount amount =
            rest.getForObject(piSUBuilder.url("inventory"),
                    InventoryItemAmount.class,
                    uriParameters);
    log.info("amount {}.",amount);
    if ( amount.getAmount() > 0) {
        log.info("There items from {}. We are offering",id);
        return rest.getForObject(piSUBuilder.url("pi"),
                ProductInformation.class,
                uriParameters);
    } else {
        log.info("There are no items from {}. Amount is {}",id,amount);
        return ProductInformation.emptyProductInformation;
    }
}
 

public Double CalculateAUC( String actual, String vactual, String vpredict  )  {

        //http://localhost:54321/2/AUC.json?actual=prostate_csv.hex&vactual=CAPSULE&predict=predict_1&vpredict=1&thresholds=&threshold_criterion=maximum_F1
        Double AUC;
        String prediction_name = "Predict_GBM";
        String h2oUrlCalculateAUCEndPoint = H2O_HOST_URL + H2O_GBM_MODEL_AUC_URL + "actual=" + actual + "&vactual=" + vactual + "&predict=" + prediction_name + "&vpredict=" + vpredict +"&threshold_criterion=maximum_F1";
        System.out.println(h2oUrlCalculateAUCEndPoint);
        log.debug("@@@ Calling endpoint {}", h2oUrlCalculateAUCEndPoint);
        try {
            RestTemplate restTemplate = new RestTemplate();
            String responseBody = restTemplate.getForObject(h2oUrlCalculateAUCEndPoint, String.class);
            JSONObject jsonobject = new JSONObject(responseBody);
            JSONObject aucdata = (JSONObject)jsonobject.get("aucdata");
            AUC = (Double)aucdata.get("AUC");
            //status = (String).get("status");
            System.out.println("AUC: " + AUC);


        }catch(Exception ex){
            log.debug("!!!!!! Error Occurred while getting job status  {}", ex);
            ex.printStackTrace();
            return null;
        }
        return AUC;
    }
 

@RequestMapping(value = "/re/{id}", method = RequestMethod.GET)
public Article findArticled(@PathVariable("id") Integer id) throws IOException {
    RestTemplate client= restTemplateBuilder.build();
    String uri = "http://localhost:8080/article/"+id;
    System.out.println(uri);
    Article article = client.getForObject (uri,Article.class,id) ;

    return article;
}
 

@Test
public void test1() throws Exception {
    RestTemplate restTemplate = new RestTemplate();
    String forObject = restTemplate.getForObject(webServer.getCallHttpUrl(), String.class);

    PluginTestVerifier verifier = PluginTestVerifierHolder.getInstance();
    verifier.printCache();

    verifier.verifyTrace(event("REST_TEMPLATE", RestTemplate.class.getConstructor()));
    verifier.verifyTrace(event("REST_TEMPLATE", AbstractClientHttpRequest.class.getMethod("execute"), annotation("http.status.code", 200)));
}
 

public void getOneGreeting(RestTemplate restTemplate) {
   // We want Greeting at index=0
   Greeting aGreeting = restTemplate
         .getForObject("http://localhost:8080/greeting/0", Greeting.class);
   System.out.println("Get=0 -> " + aGreeting);

}
 

public void activateProcess(ProcessMetric processMetric) {
    log.info("Call activateProcess {}", processMetric);
    RestTemplate restTemplate = new RestTemplate();
    try {
        restTemplate.getForObject(generatorConfiguration.getBackend() + "/metric/activate?idProcess=" + processMetric.getIdProcess(), String.class);
    } catch (Exception e) {
        log.error("status {}", e);
    }
}
 

@Test
public void servletPathMapping() throws Exception {
	AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
	context.register(WebAppConfig.class);
	context.refresh();

	File base = new File(System.getProperty("java.io.tmpdir"));
	TomcatHttpServer server = new TomcatHttpServer(base.getAbsolutePath());
	server.setContextPath("/app");
	server.setServletMapping("/api/*");

	HttpHandler httpHandler = WebHttpHandlerBuilder.applicationContext(context).build();
	server.setHandler(httpHandler);

	server.afterPropertiesSet();
	server.start();

	try {
		RestTemplate restTemplate = new RestTemplate();
		String actual;

		String url = "http://localhost:" + server.getPort() + "/app/api/test";
		actual = restTemplate.getForObject(url, String.class);
		assertEquals("Tested in /app/api", actual);
	}
	finally {
		server.stop();
	}
}
 

@ApiOperation(value = "订单核销")
@PutMapping(value = "/yxStoreOrder/check")
@PreAuthorize("@el.check('admin','YXSTOREORDER_ALL','YXSTOREORDER_EDIT')")
public ResponseEntity check(@Validated @RequestBody YxStoreOrder resources) {
    if (StrUtil.isBlank(resources.getVerifyCode())) throw new BadRequestException("核销码不能为空");
    YxStoreOrderDto storeOrderDTO = generator.convert(yxStoreOrderService.getById(resources.getId()),YxStoreOrderDto.class);
    if(!resources.getVerifyCode().equals(storeOrderDTO.getVerifyCode())){
        throw new BadRequestException("核销码不对");
    }
    if(OrderInfoEnum.PAY_STATUS_0.getValue().equals(storeOrderDTO.getPaid())){
        throw new BadRequestException("订单未支付");
    }

    /**
    if(storeOrderDTO.getStatus() > 0) throw new BadRequestException("订单已核销");

    if(storeOrderDTO.getCombinationId() > 0 && storeOrderDTO.getPinkId() > 0){
        YxStorePinkDTO storePinkDTO = storePinkService.findById(storeOrderDTO.getPinkId());
        if(!OrderInfoEnum.PINK_STATUS_2.getValue().equals(storePinkDTO.getStatus())){
            throw new BadRequestException("拼团订单暂未成功无法核销");
        }
    }
     **/

    //远程调用API
    RestTemplate rest = new RestTemplate();
    String url = StrUtil.format(apiUrl+"/order/admin/order_verific/{}", resources.getVerifyCode());
    String text = rest.getForObject(url, String.class);


    JSONObject jsonObject = JSON.parseObject(text);

    Integer status = jsonObject.getInteger("status");
    String msg = jsonObject.getString("msg");

    if(status != 200) throw new BadRequestException(msg);


    return new ResponseEntity(HttpStatus.NO_CONTENT);
}
 

private void testFallback(RestTemplate template, String cseUrlPrefix) {
  long start = System.currentTimeMillis();
  String result = template.getForObject(cseUrlPrefix + "/fallback/returnnull/hello", String.class);
  TestMgr.check(result, "hello");
  result = template.getForObject(cseUrlPrefix + "/fallback/returnnull/throwexception", String.class);
  TestMgr.check(result, null);

  result = template.getForObject(cseUrlPrefix + "/fallback/throwexception/hello", String.class);
  TestMgr.check(result, "hello");
  try {
    result = template.getForObject(cseUrlPrefix + "/fallback/throwexception/throwexception", String.class);
    TestMgr.check(false, true);
  } catch (Exception e) {
    TestMgr.check(e.getCause().getMessage(),
        BizkeeperExceptionUtils.createBizkeeperException(BizkeeperExceptionUtils.SERVICECOMB_BIZKEEPER_FALLBACK,
            null,
            "springmvc.codeFirst.fallbackThrowException").getMessage());
  }

  result = template.getForObject(cseUrlPrefix + "/fallback/fromcache/hello", String.class);
  TestMgr.check(result, "hello");
  result = template.getForObject(cseUrlPrefix + "/fallback/fromcache/hello", String.class);
  TestMgr.check(result, "hello");
  result = template.getForObject(cseUrlPrefix + "/fallback/fromcache/throwexception", String.class);
  TestMgr.check(result, "hello");

  result = template.getForObject(cseUrlPrefix + "/fallback/force/hello", String.class);
  TestMgr.check(result, "mockedreslut");

  // This test case is fallback testing and will return null if failed.
  // In order to check if failed due to some unexpected timeout exception, check the time.
  TestMgr.check(System.currentTimeMillis() - start < 10000, true);
}
 

@Override
public BaremetalRctResponse addRct(AddBaremetalRctCmd cmd) {
    try {
        List<BaremetalRctVO> existings = rctDao.listAll();
        if (!existings.isEmpty()) {
            throw new CloudRuntimeException(String.format("there is some RCT existing. A CloudStack deployment accepts only one RCT"));
        }
        URL url = new URL(cmd.getRctUrl());
        RestTemplate rest = new RestTemplate();
        String rctStr = rest.getForObject(url.toString(), String.class);

        // validate it's right format
        BaremetalRct rct = gson.fromJson(rctStr, BaremetalRct.class);
        QueryBuilder<BaremetalRctVO> sc = QueryBuilder.create(BaremetalRctVO.class);
        sc.and(sc.entity().getUrl(), SearchCriteria.Op.EQ, cmd.getRctUrl());
        BaremetalRctVO vo =  sc.find();
        if (vo == null) {
            vo = new BaremetalRctVO();
            vo.setRct(gson.toJson(rct));
            vo.setUrl(cmd.getRctUrl());
            vo = rctDao.persist(vo);
        } else {
            vo.setRct(gson.toJson(rct));
            rctDao.update(vo.getId(), vo);
        }

        BaremetalRctResponse rsp = new BaremetalRctResponse();
        rsp.setUrl(vo.getUrl());
        rsp.setId(vo.getUuid());
        rsp.setObjectName("baremetalrct");
        return rsp;
    } catch (MalformedURLException e) {
        throw new IllegalArgumentException(String.format("%s is not a legal http url", cmd.getRctUrl()));
    }
}
 

/**
 * Download Transactions from other Node and them to the pool
 * @param node Node to query
 * @param restTemplate RestTemplate to use
 */
public void retrieveTransactions(Node node, RestTemplate restTemplate) {
    Transaction[] transactions = restTemplate.getForObject(node.getAddress() + "/transaction", Transaction[].class);
    Collections.addAll(transactionPool, transactions);
    LOG.info("Retrieved " + transactions.length + " transactions from node " + node.getAddress());
}
 

/**
 * Download Blocks from other Node and them to the blockchain
 * @param node Node to query
 * @param restTemplate RestTemplate to use
 */
public void retrieveBlockchain(Node node, RestTemplate restTemplate) {
    Block[] blocks = restTemplate.getForObject(node.getAddress() + "/block", Block[].class);
    Collections.addAll(blockchain, blocks);
    LOG.info("Retrieved " + blocks.length + " blocks from node " + node.getAddress());
}
 

private void testCodeFirstIsTrue(RestTemplate template, String cseUrlPrefix) {
  boolean result = template.getForObject(cseUrlPrefix + "istrue", boolean.class);
  TestMgr.check(true, result);
}
 

private static void testGetEmployee() {
	RestTemplate restTemplate = new RestTemplate();
	Employee emp = restTemplate.getForObject(SERVER_URI+"/rest/emp/1", Employee.class);
	printEmpData(emp);
}
 

private static void testGetDummyEmployee() {
	RestTemplate restTemplate = new RestTemplate();
	Employee emp = restTemplate.getForObject(SERVER_URI+EmpRestURIConstants.DUMMY_EMP, Employee.class);
	printEmpData(emp);
}
 

@RequestMapping(value="testServiceA",method=RequestMethod.GET)
public String testServiceB(@RequestParam Integer a,@RequestParam Integer b){
	RestTemplate restTemplate=new RestTemplate();
	return restTemplate.getForObject("http://localhost:7074/add?a="+a+"&b="+b, String.class);
}
 

@Test
public void home() {
	RestTemplate restTemplate = new RestTemplate();
	String result = restTemplate.getForObject("http://localhost:" + port, String.class);
	assertTrue(result.contains("<li>author1 content1</li>"));
}
 

private void makeRequest(HttpClient httpClient, String url) {
	RestTemplate restTemplate = new RestTemplate(
			new HttpComponentsClientHttpRequestFactory(httpClient));
	restTemplate.getForObject(url, String.class);
}
 

private String retrieveSelfExternalHost(Node node, RestTemplate restTemplate) {
    return restTemplate.getForObject(node.getAddress() + "/node/ip", String.class);
}
 

@Override protected void get(ClientHttpRequestFactory client, String pathIncludingQuery) {
  RestTemplate restTemplate = new RestTemplate(client);
  restTemplate.setInterceptors(Collections.singletonList(interceptor));
  restTemplate.getForObject(url(pathIncludingQuery), String.class);
}