markdown-it demo

clear permalink

### GET 
```java
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.util.UriComponentsBuilder;

public class Example {
    public static void main(String[] args) {
        // 建立 RestTemplate 物件
        RestTemplate restTemplate = new RestTemplate();

// 設定 API 網址和參數
        String url = "https://api.example.com/data";
        String parameter1 = "value1";
        String parameter2 = "value2";

// 使用 UriComponentsBuilder 建立包含參數的 URL
        UriComponentsBuilder builder = UriComponentsBuilder.fromUriString(url)
                .queryParam("param1", parameter1)
                .queryParam("param2", parameter2);

// 執行 GET 請求
        ResponseEntity<String> response = restTemplate.exchange(builder.toUriString(), HttpMethod.GET, null, String.class);

// 取得回應的結果
        String responseBody = response.getBody();
        System.out.println(responseBody);
    }
}
```

### POST Json
```java
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;

public class Example {
    public static void main(String[] args) {
        // 建立 RestTemplate 物件
        RestTemplate restTemplate = new RestTemplate();

// 設定 API 網址
        String url = "https://api.example.com/data";

// 建立請求頭
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);

// 建立請求體，即要傳遞的 JSON 資料
        String requestBody = "{\"key\": \"value\"}";
        HttpEntity<String> requestEntity = new HttpEntity<>(requestBody, headers);

// 執行 POST 請求
        ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.POST, requestEntity, String.class);

// 取得回應的結果
        String responseBody = response.getBody();
        System.out.println(responseBody);
    }
}
```
### POST application/x-www-form-urlencoded
```java
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

public class Example {
    public static void main(String[] args) {
        // 建立 RestTemplate 物件
        RestTemplate restTemplate = new RestTemplate();

// 設定 API 網址
        String url = "https://api.example.com/data";

// 建立請求頭
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);

// 建立請求體，即要傳遞的資料
        MultiValueMap<String, String> requestBody = new LinkedMultiValueMap<>();
        requestBody.add("param1", "value1");
        requestBody.add("param2", "value2");
        HttpEntity<MultiValueMap<String, String>> requestEntity = new HttpEntity<>(requestBody, headers);

// 執行 POST 請求
        ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.POST, requestEntity, String.class);

// 取得回應的結果
        String responseBody = response.getBody();
        System.out.println(responseBody);
    }
}
```

### 執行 POST 請求並將 Java Object 轉換為 JSON 格式的範例
```java
RestTemplate restTemplate = new RestTemplate();
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);

MyObject myObject = new MyObject();
myObject.setName("John");
myObject.setAge(30);

HttpEntity<MyObject> request = new HttpEntity<>(myObject, headers);
ResponseEntity<String> response = restTemplate.postForEntity(url, request, String.class);

```
### 根據不同 HTTP status code 執行不同的動作
```java
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.DefaultResponseErrorHandler;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.HttpServerErrorException;
import org.springframework.web.client.RestTemplate;

public class RestClient {
    public static void main(String[] args) {
        RestTemplate restTemplate = new RestTemplate();

// 設置自定義的 ResponseErrorHandler
        restTemplate.setErrorHandler(new DefaultResponseErrorHandler() {
            @Override
            public boolean hasError(HttpStatus statusCode) {
                return false; // 不要抛出任何異常
            }
        });

// 發送 GET 請求，並根據不同的狀態碼執行不同的操作
        String url = "https://example.com/api/users";
        ResponseEntity<String> responseEntity = restTemplate.getForEntity(url, String.class);
        HttpStatus statusCode = responseEntity.getStatusCode();

if (statusCode.is2xxSuccessful()) {
            // 2xx 狀態碼表示成功，處理正常的響應
            String response = responseEntity.getBody();
            System.out.println(response);
        } else if (statusCode.is4xxClientError()) {
            // 4xx 狀態碼表示客戶端錯誤，處理錯誤的響應
            throw new HttpClientErrorException(statusCode);
        } else if (statusCode.is5xxServerError()) {
            // 5xx 狀態碼表示服務器錯誤，處理錯誤的響應
            throw new HttpServerErrorException(statusCode);
        } else {
            // 其他狀態碼，可以進行重試或重定向等操作
            System.out.println("Received status code: " + statusCode);
        }
    }
}
```
上面的代碼首先創建了一個 RestTemplate 對象，然後設置了一個自定義的 ResponseErrorHandler，該處理程序將不會抛出任何異常，因為我們將在代碼中處理所有的 HTTP 狀態碼。

接下來，我們使用 RestTemplate 發送一個 GET 請求，獲取一個 ResponseEntity 對象，其中包含了 HTTP 響應的所有信息，包括狀態碼、響應主體等等。我們使用 getStatusCode 方法獲取狀態碼，然後根據狀態碼執行不同的操作

### Response 使用泛型 `Some<Another>` 回應
```java
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;

public class Example {
    public static void main(String[] args) {
        RestTemplate restTemplate = new RestTemplate();

String url = "http://example.com/api/some-endpoint";
        // 設置請求主體
        MultiValueMap<String, String> requestBody = new LinkedMultiValueMap<>();
        requestBody.add("name", "John");
        requestBody.add("age", "30");
        HttpEntity<MultiValueMap<String, String>> request = new HttpEntity<>(requestBody, headers);

ResponseEntity<Some<Another>> response = restTemplate.exchange(
                url,
                HttpMethod.POST,
                request,
                new ParameterizedTypeReference<Some<Another>>() {}
        );

Some<Another> result = response.getBody();
        // 使用結果進行後續處理
    }
}
```
上述範例中，我們使用 RestTemplate 的 exchange 方法來發送 HTTP POST 請求，並指定 ParameterizedTypeReference<Some<Another>> 作為結果類型。透過這樣的方式，我們可以正確地處理帶有泛型參數的類型。

請注意，為了創建 ParameterizedTypeReference，我們使用了匿名內部類的方式，因為 Java 語言的類型擦除機制限制了直接獲取帶有泛型參數的類型。

這是一個可以接收帶有泛型參數類型的 postForObject 範例，通過使用 ParameterizedTypeReference 可以確保正確處理帶有泛型的類型返回結果。

### Configuration Timeout
```java
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RestTemplateConfig {

@Bean
    public RestTemplate restTemplate(RestTemplateBuilder restTemplateBuilder) {
        int connectTimeout = 5000; // 連接超時時間，單位：毫秒
        int readTimeout = 5000; // 讀取超時時間，單位：毫秒

HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
        factory.setConnectTimeout(connectTimeout);
        factory.setReadTimeout(readTimeout);

return restTemplateBuilder
                .requestFactory(() -> factory)
                .build();
    }
}
```
### RestTemplateService
```java
import java.net.URI;
import java.util.Map;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

/**
 * @author Adam Huang
 * @since 2023-03-08
 */
@Slf4j
@Service
public class RestTemplateService {
	@Autowired private RestTemplate restTemplate;

/**
	 * 利用 RestTemplate 執行 POST
	 * Request: T body → Json
	 * Response: S
	 * @param url 目標 url
	 * @param headers 標頭
	 * @param body Request 內容
	 * @param responseType Response 物件類別
	 */
	public <T, S> S post(String url, HttpHeaders headers, T body, ParameterizedTypeReference<S> responseType) {
		HttpEntity<T> entity = new HttpEntity<>(body, headers);
		ResponseEntity<S> response = restTemplate.exchange(url, HttpMethod.POST, entity, responseType);
		return response.getBody();
	}

/**
	 * 利用 RestTemplate 執行 POST
	 * Request: T body → Json
	 * Response: S
	 * @param url 目標 url
	 * @param body Request 內容
	 * @param responseType Response 物件類別
	 */
	public <T, S> S post(String url, T body, ParameterizedTypeReference<S> responseType) {
		HttpHeaders headers = new HttpHeaders();
		headers.setContentType(MediaType.APPLICATION_JSON);
		HttpEntity<T> entity = new HttpEntity<>(body, headers);
		ResponseEntity<S> response = restTemplate.exchange(url, HttpMethod.POST, entity, responseType);
		return response.getBody();
	}

/**
	 * 利用 RestTemplate 執行 POST
	 * @param url 目標 url
	 * @param headers 標頭
	 * @param body Request 內容
	 * @param clz Response 物件類別
         * @param params url 中的變數對應值
	 * @since 2024-07-09
	 */
	public <T, S> S post(String url, HttpHeaders headers, T body, Class<S> clz, Map<String, String> params) {
		HttpEntity<T> entity = new HttpEntity<>(body, headers);
		ResponseEntity<S> response = restTemplate.exchange(url, HttpMethod.POST, entity, clz, params);
		return response.getBody();
	}

/**
	 * 利用 RestTemplate 執行 POST
	 * Request: T body → Json
	 * Response: S
	 * @param url 目標 url
	 * @param headers 標頭
	 * @param body Request 內容
	 * @param clz Response 物件類別
	 */
	public <T, S> S post(String url, HttpHeaders headers, T body, Class<S> clz) {
		HttpEntity<T> entity = new HttpEntity<>(body, headers);
		ResponseEntity<S> response = restTemplate.exchange(url, HttpMethod.POST, entity, clz);
		return response.getBody();
	}

/**
	 * 利用 RestTemplate 執行 POST
	 * Request: MultiValueMap(String, String) body
	 * Response: String
	 */
	public String post(String url, MultiValueMap<String, String> body) {
		HttpHeaders headers = new HttpHeaders();
		headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
		return post(url, headers, body, String.class);
	}

/**
	 * 利用 RestTemplate 執行 POST
	 * Request: T body → Json
	 * Response: S
	 */
	public <T, S> S post(String url, T body, Class<S> clz) {
		HttpHeaders headers = new HttpHeaders();
		headers.setContentType(MediaType.APPLICATION_JSON);
		return post(url, headers, body, clz);
	}

/**
	 * 利用 RestTemplate 執行 POST
	 * 並將物件 T 轉成 Json 格式後帶入 Body 中，並轉換成 clz 物件傳回
	 * @since 2024-07-09
	 */
	public <T, S> S post(String url, T body, Class<S> clz, Map<String, String> params) {
		HttpHeaders headers = new HttpHeaders();
		headers.setContentType(MediaType.APPLICATION_JSON);
		return post(url, headers, body, clz, params);
	}

/**
	 * 利用 RestTemplate 執行 POST
	 * Request: T body → Json
	 * Response: String
	 */
	public <T> String post(String url, T body) {
		return post(url, body, String.class);
	}

/**
	 * 利用 RestTemplate 執行 POST
	 * Request: String message
	 * Response: String
	 */
	public String post(String url, String message) {
		HttpHeaders headers = new HttpHeaders();
		headers.setContentType(MediaType.TEXT_PLAIN);
		return post(url, headers, message, String.class);
	}

/**
	 * 利用 RestTemplate 執行 POST，無 Body 的情況
	 * Response: String
	 */
	public String post(String url) {
		HttpHeaders headers = new HttpHeaders();
		HttpEntity<String> entity = new HttpEntity<>(headers);
		ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.POST, entity, String.class);
		return response.getBody();
	}

/**
	 * 利用 RestTemplate 執行 GET
	 * @param url 目標 url
	 * @param headers 標頭
	 * @param params url 的變數
	 * @param responseType Response 物件類別
	 */
	public <S> S get(String url, HttpHeaders headers, Map<String, String> params, ParameterizedTypeReference<S> responseType) {
		HttpEntity entity = new HttpEntity<>(headers);
		ResponseEntity<S> response = restTemplate.exchange(url, HttpMethod.GET, entity, responseType, params);
		return response.getBody();
	}

/**
	 * 利用 RestTemplate 執行 GET
	 * @param url 目標 url
	 * @param headers 標頭
	 * @param params url 的變數
	 * @param clz Response 物件類別
	 */
	public <S> S get(String url, HttpHeaders headers, Map<String, String> params, Class<S> clz) {
		HttpEntity entity = new HttpEntity<>(headers);
		ResponseEntity<S> response = restTemplate.exchange(url, HttpMethod.GET, entity, clz, params);
		return response.getBody();
	}

/**
	 * 利用 RestTemplate 執行 GET
	 * @param url 目標 url
	 * @param headers 標頭
	 * @param responseType Response 物件類別
	 */
	public <S> S get(String url, HttpHeaders headers, ParameterizedTypeReference<S> responseType) {
		HttpEntity entity = new HttpEntity<>(headers);
		ResponseEntity<S> response = restTemplate.exchange(url, HttpMethod.GET, entity, responseType);
		return response.getBody();
	}

/**
	 * 利用 RestTemplate 執行 GET
	 * @param url 目標 url
	 * @param headers 標頭
	 * @param clz Response 物件類別
	 */
	public <S> S get(String url, HttpHeaders headers, Class<S> clz) {
		HttpEntity entity = new HttpEntity<>(headers);
		ResponseEntity<S> response = restTemplate.exchange(url, HttpMethod.GET, entity, clz);
		return response.getBody();
	}

/**
	 * 利用 RestTemplate 執行 GET
	 * e.g. get("https://is.gd/create.php?format={format}&url={url}", params, String.class);
	 * @param url 目標 url
	 * @param params url 的變數
	 * @param clz Response 物件類別
	 */
	public <S> S get(String url, Map<String, String> params, Class<S> clz) {
		HttpEntity entity = new HttpEntity<>(new HttpHeaders());
		ResponseEntity<S> response = restTemplate.exchange(url, HttpMethod.GET, entity, clz, params);
		return response.getBody();
	}

/**
	 * 利用 RestTemplate 執行 GET
	 * @param url 目標 url
	 * @param responseType Response 物件類別
	 */
	public <S> S get(String url, ParameterizedTypeReference<S> responseType) {
		return get(url, new HttpHeaders(), responseType);
	}

/**
	 * 利用 RestTemplate 執行 GET
	 * @param url 目標 url
	 * @param clz Response 物件類別
	 */
	public <S> S get(String url, Class<S> clz) {
		return get(url, new HttpHeaders(), clz);
	}

/**
	 * 利用 RestTemplate 執行 GET，直接回傳 String
	 * @param url 目標 url
	 */
	public String get(String url) {
		return get(url, String.class);
	}

}
```

### [The Guide to RestTemplate](https://www.baeldung.com/rest-template)

```java
private RestTemplate restTemplate = new RestTemplate();
	
@Test
public void show() {
	Message message = restTemplate.getForObject("http://localhost:8080/messages/{id}", Message.class, "1");
	assertNotNull(message.getText());
}

@Test
public void create() {
	Message message = new Message("new message");
	HttpHeaders headers = new HttpHeaders();
	headers.setContentType(MediaType.APPLICATION_JSON);
	HttpEntity<Message> request = new HttpEntity<>(message, headers);
	message = restTemplate.postForObject("http://localhost:8080/messages", request, Message.class);
	assertEquals(message.getText(), "new message");
}

@Test
public void delete() {
	restTemplate.delete("http://localhost:8080/messages/{id}", "1");
	Message message = restTemplate.getForObject("http://localhost:8080/messages/{id}", Message.class, "1");
	assertEquals(message.getText(), "msg2");
}
	
@Test
public void index() {
	RequestEntity<Void> request = RequestEntity
			.get(URI.create("http://localhost:8080/messages/"))
			.accept(MediaType.APPLICATION_JSON)
			.build();
	ResponseEntity<List<Message>> response = restTemplate
			.exchange(request,new ParameterizedTypeReference<List<Message>>(){});
	List<Message> messages = response.getBody();
	assertTrue(messages.size() > 0);
}
```

html source debug