import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ApplicationContextBean {

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

@Autowired
private RestTemplate restTemplate;

import org.apache.http.Header;
import org.apache.http.client.HttpClient;
import org.apache.http.conn.HttpClientConnectionManager;
import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicHeader;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

import java.util.ArrayList;
import java.util.List;

@Configuration
public class RestTemplateConfig {

    /**
     * http連接管理器
     *
     * @return
     */
    @Bean
    public HttpClientConnectionManager poolingHttpClientConnectionManager() {
        /* 注冊(cè)http和https請(qǐng)求
        Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", PlainConnectionSocketFactory.getSocketFactory())
                .register("https", SSLConnectionSocketFactory.getSocketFactory())
                .build();
        PoolingHttpClientConnectionManager poolingHttpClientConnectionManager = new PoolingHttpClientConnectionManager(registry);*/

        PoolingHttpClientConnectionManager poolingHttpClientConnectionManager = new PoolingHttpClientConnectionManager();
        // 最大連接數(shù)
        poolingHttpClientConnectionManager.setMaxTotal(500);
        // 同路由并發(fā)數(shù)（每個(gè)主機(jī)的并發(fā)）
        poolingHttpClientConnectionManager.setDefaultMaxPerRoute(100);
        return poolingHttpClientConnectionManager;
    }

    /**
     * HttpClient
     *
     * @param poolingHttpClientConnectionManager
     * @return
     */
    @Bean
    public HttpClient httpClient(HttpClientConnectionManager poolingHttpClientConnectionManager) {
        HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
        // 設(shè)置http連接管理器
        httpClientBuilder.setConnectionManager(poolingHttpClientConnectionManager);

        // 設(shè)置重試次數(shù)
        httpClientBuilder.setRetryHandler(new DefaultHttpRequestRetryHandler(3, true));

        // 設(shè)置默認(rèn)請(qǐng)求頭(具體可根據(jù)自己業(yè)務(wù)場(chǎng)景進(jìn)行設(shè)置)
        List<Header> headers = new ArrayList<>();
        headers.add(new BasicHeader("atoken", "WAKJDWAJLDKWAKDLKWALKDALKW"));
        httpClientBuilder.setDefaultHeaders(headers);

        return httpClientBuilder.build();
    }

    /**
     * 請(qǐng)求連接池配置
     *
     * @param httpClient
     * @return
     */
    @Bean
    public ClientHttpRequestFactory clientHttpRequestFactory(HttpClient httpClient) {
        HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = new HttpComponentsClientHttpRequestFactory();
        // httpClient創(chuàng)建器
        clientHttpRequestFactory.setHttpClient(httpClient);
        // 連接超時(shí)時(shí)間/毫秒（連接上服務(wù)器(握手成功)的時(shí)間，超出拋出connect timeout）
        clientHttpRequestFactory.setConnectTimeout(5 * 1000);
        // 數(shù)據(jù)讀取超時(shí)時(shí)間(socketTimeout)/毫秒（務(wù)器返回?cái)?shù)據(jù)(response)的時(shí)間，超過(guò)拋出read timeout）
        clientHttpRequestFactory.setReadTimeout(10 * 1000);
        // 連接池獲取請(qǐng)求連接的超時(shí)時(shí)間，不宜過(guò)長(zhǎng)，必須設(shè)置/毫秒（超時(shí)間未拿到可用連接，會(huì)拋出org.apache.http.conn.ConnectionPoolTimeoutException: Timeout waiting for connection from pool）
        clientHttpRequestFactory.setConnectionRequestTimeout(10 * 1000);
        return clientHttpRequestFactory;
    }

    /**
     * rest模板
     *
     * @return
     */
    @Bean
    public RestTemplate restTemplate(ClientHttpRequestFactory clientHttpRequestFactory) {
        // boot中可使用RestTemplateBuilder.build創(chuàng)建
        RestTemplate restTemplate = new RestTemplate();
        // 配置請(qǐng)求工廠
        restTemplate.setRequestFactory(clientHttpRequestFactory);
        
        // 添加攔截器(這塊可以通過(guò)攔截器來(lái)實(shí)現(xiàn)日志打印，既然是攔截器，那肯定會(huì)丟失一定的性能，所以可根據(jù)情況使用,如果計(jì)劃在攔截器當(dāng)中打印request當(dāng)中的日志，一定要注意request是流，不能讀兩次，這塊要做的話，需要想辦法將流取出然后再替換一個(gè)新的流)
//        List<ClientHttpRequestInterceptor> interceptors = new ArrayList<>();
//        interceptors.add(restTemplateLog);
//        restTemplate.setInterceptors(interceptors);
        return restTemplate;
    }

}

@GetMapping("/getTest2")
public String getTest2(String name) {
    return "hello " + name + " !";
}

@GetMapping("/test")
public void test() throws UnsupportedEncodingException {
    // 第一種方案（這種方案有點(diǎn)類似hibernate占位符取值，getForEntity第三個(gè)參數(shù)就是一個(gè)可變長(zhǎng)參數(shù)，當(dāng)get請(qǐng)求有多個(gè)參數(shù)的時(shí)候也是可以用這種方式的）
    String url1 = "http://127.0.0.1:8006/getTest2?name={1}";
    // 這塊的String.class就是ResponseEntity當(dāng)中的body要序列化成的java對(duì)象類型
    ResponseEntity<String> responseEntity1 = restTemplate.getForEntity(url1, String.class, "aaa");
    System.out.println(responseEntity1.getStatusCode());
    System.out.println(responseEntity1.getBody());
    System.out.println(responseEntity1.getHeaders());

    // 第二種方案,將參數(shù)放入到一個(gè) map 中。map 中的 key 和占位符的 key 相對(duì)應(yīng)，map 中的 value 就是參數(shù)的具體值
    Map<String, Object> map = new HashMap<>();
    String url2 = "http://127.0.0.1:8006/getTest2?name={name}";
    map.put("name", "bbb");
    ResponseEntity<String> responseEntity2 = restTemplate.getForEntity(url2, String.class, map);
    System.out.println(responseEntity2.getStatusCode());
    System.out.println(responseEntity2.getBody());
    System.out.println(responseEntity2.getHeaders());

    // 第三種方案,使用 Uri 對(duì)象時(shí)，參數(shù)可以直接拼接在地址中
    String url = "http://127.0.0.1:8006/getTest2?name=" + URLEncoder.encode("ccc", "UTF-8");
    URI uri = URI.create(url);
    ResponseEntity<String> responseEntity3 = restTemplate.getForEntity(uri, String.class);
    System.out.println(responseEntity3.getStatusCode());
    System.out.println(responseEntity3.getBody());
    System.out.println(responseEntity3.getHeaders());
}

// 沒(méi)有參數(shù)的時(shí)候調(diào)用
@GetMapping("/getTest1")
public String getTest1() {
    return "getTest1";
}

// ?拼接的參數(shù)
@GetMapping("/getTest2")
public String getTest2(String name) {
    return "hello " + name + " !";
}

// 斜杠地址欄/ 拼接的參數(shù)
@GetMapping("/getTest3/{name}")
public String getTest3(@PathVariable(value = "name") String name) {
    return "hello " + name + " !";
}

@GetMapping("/test1")
public void test1() throws UnsupportedEncodingException {
    // 無(wú)參調(diào)用
    String result = restTemplate.getForObject("http://127.0.0.1:8006/getTest1", String.class);
    System.out.println(result);

    String url2 = "http://127.0.0.1:8006/getTest2?name={1}";
    String result1 = restTemplate.getForObject(url2, String.class, "aaa");
    System.out.println(result1);

    // 第一種方案 調(diào)用地址欄/拼接
    String url3 = "http://127.0.0.1:8006/getTest3/{1}";
    String result2 = restTemplate.getForObject(url3, String.class, "bbb");
    System.out.println(result2);

    // 第二種方案 調(diào)用地址欄/拼接
    String url4 = "http://127.0.0.1:8006/getTest3/" + URLEncoder.encode("ccc", "UTF-8");
    URI uri = URI.create(url4);
    String result3 = restTemplate.getForObject(uri, String.class);
    System.out.println(result3);

    // 第三種方案 調(diào)用地址欄/拼接
    Map<String, Object> map = new HashMap<>();
    String url5 = "http://127.0.0.1:8006/getTest3/{name}";
    map.put("name", "ddd");
    String result4 = restTemplate.getForObject(url5, String.class, map);
    System.out.println(result4);
}

@PostMapping("/postTest2")
public User test2(HttpServletRequest request, @RequestBody User user1) {
    System.out.println("接受的參數(shù)：" + user1);
    // 正常情況我們是需要通過(guò)攔截器來(lái)攔截request獲取請(qǐng)求頭當(dāng)中的token來(lái)進(jìn)行認(rèn)證，這塊只是演示
    System.out.println("接受的請(qǐng)求頭：" + request.getHeader("token"));
    User user = new User();
    user.setId(1);
    user.setName("張三");
    user.setSex("男性");
    return user;
}

@GetMapping("/hello2")
public User hello5() {
    String url = "http://127.0.0.1:8006/postTest2";

    // 請(qǐng)求示例一：攜帶token請(qǐng)求頭
    // 請(qǐng)求體
    User user = new User();
    user.setId(1);
    user.setName("李四");
    user.setSex("女性");
    // 請(qǐng)求頭（這里有一點(diǎn)需要注意，HttpHeaders和HttpEntity都是引入的spring的包）
    HttpHeaders headers = new HttpHeaders();
    headers.add("token", "WDWADAWDWADAWSAXZCXZCXZEDF");
    // 請(qǐng)求
    HttpEntity<User> requst = new HttpEntity<>(user, headers);

    ResponseEntity<User> responseEntity = restTemplate.postForEntity(url, requst, User.class);
    System.out.println("響應(yīng)的結(jié)果:" + responseEntity.getBody());

    // 請(qǐng)求示例二：不攜帶請(qǐng)求頭，直接傳普通對(duì)象，這里直接傳的user，map也是可以的，他都可以轉(zhuǎn)換成json，切記不能使用LinkedMultiValueMap，使用他不會(huì)轉(zhuǎn)換成json
    ResponseEntity<User> responseEntity1 = restTemplate.postForEntity(url, user, User.class);
    System.out.println("響應(yīng)的結(jié)果:" + responseEntity1.getBody());

    return responseEntity1.getBody();
}

@PostMapping("/postTest1")
public String test1(HttpServletRequest request, String name) {
    System.out.println("接受的參數(shù)：" + name);
    System.out.println("接受的請(qǐng)求頭：" + request.getHeader("token"));
    return "Hello " + name + " !";
}

@GetMapping("/hello1")
public void hello1() throws UnsupportedEncodingException {

    // 請(qǐng)求頭（這里有一點(diǎn)需要注意，HttpHeaders和HttpEntity都是引入的spring的包）
    HttpHeaders headers = new HttpHeaders();
    headers.add("token", "WDWADAWDWADAWSAXZCXZCXZEDF");
    HttpEntity<Map> requst = new HttpEntity<>(null, headers);

    // 調(diào)用方式一，通過(guò)map傳參
    String url1 = "http://127.0.0.1:8006/postTest1?name={name}";
    Map<String, String> param = new HashMap<>(16);
    param.put("name", "李四");
    ResponseEntity<String> responseEntity1 = restTemplate.postForEntity(url1, requst, String.class, param);
    System.out.println(responseEntity1.getBody());

    // 調(diào)用方式二，通過(guò)占位符和可變長(zhǎng)參數(shù)傳參
    String url2 = "http://127.0.0.1:8006/postTest1?name={1}";
    ResponseEntity<String> responseEntity2 = restTemplate.postForEntity(url2, requst, String.class, "牛牛");
    System.out.println(responseEntity2.getBody());

    // 調(diào)用方式三，正常這塊其實(shí)都不需要URI對(duì)象了，根據(jù)地址直接訪問(wèn)就可以。
    String url3 = "http://127.0.0.1:8006/postTest1?name=" + URLEncoder.encode("ccc", "UTF-8");
    URI uri = URI.create(url3);
    ResponseEntity<String> responseEntity3 = restTemplate.postForEntity(uri, requst, String.class);
    System.out.println(responseEntity3.getBody());

	// 調(diào)用方式四:這種方式是沒(méi)有使用請(qǐng)求頭的，使用LinkedMultiValueMap，切記不能使用hashmap和java實(shí)體類，不然就轉(zhuǎn)換成json了，將LinkedMultiValueMap放到HttpEntity的body當(dāng)中其實(shí)也是可以的，然后就可以攜帶token了。
    String url4 = "http://127.0.0.1:8006/postTest1";
    MultiValueMap map = new LinkedMultiValueMap();
    map.add("name", "薩瓦迪卡");
    ResponseEntity<String> responseEntity4 = restTemplate.postForEntity(url4, map, String.class);
    System.out.println(responseEntity4.getBody());
}

@RequestMapping("/register")
public String register(User user) throws UnsupportedEncodingException {
    return "redirect:/loginPage?username=" + URLEncoder.encode(user.getUsername(),"UTF-8") + "&address=" + URLEncoder.encode(user.getAddress(),"UTF-8");
}
@GetMapping("/loginPage")
@ResponseBody
public String loginPage(User user) {
    return "loginPage:" + user.getUsername() + ":" + user.getAddress();
}

@GetMapping("/hello8")
public String hello8() {
    List<ServiceInstance> list = discoveryClient.getInstances("provider");
    ServiceInstance instance = list.get(0);
    String host = instance.getHost();
    int port = instance.getPort();
    String url = "http://" + host + ":" + port + "/register";
    MultiValueMap map = new LinkedMultiValueMap();
    map.add("username", "牧碼小子");
    map.add("address", "深圳");
    URI uri = restTemplate.postForLocation(url, map);
    String s = restTemplate.getForObject(uri, String.class);
    return s;
}

public static void main(String[] args) {
    MultiValueMap params = new LinkedMultiValueMap();

    params.add("username", "張三");
    params.add("username", "李四");
    System.out.println(params);

    params.put("password", Arrays.asList("1234"));
    System.out.println(params);

    params.set("username", "王五");
    System.out.println(params);
}

@PostMapping("/exchangeTest1")
public String test1(HttpServletRequest request, String name) {
    System.out.println("接受的參數(shù)：" + name);
    System.out.println("接受的請(qǐng)求頭：" + request.getHeader("token"));
    return "Hello " + name + " !";
}

@GetMapping("/exchange1")
public void hello1() {
    String url = "http://127.0.0.1:8006/exchangeTest1";

    // 請(qǐng)求體,一定要用LinkedMultiValueMap，用hashmap或者javabean會(huì)直接轉(zhuǎn)換成json的
    MultiValueMap map = new LinkedMultiValueMap();
    map.add("name", "薩瓦迪卡");
    // 請(qǐng)求頭（這里有一點(diǎn)需要注意，HttpHeaders和HttpEntity都是引入的spring的包）
    HttpHeaders headers = new HttpHeaders();
    headers.add("token", "WDWADAWDWADAWSAXZCXZCXZEDF");
    // 請(qǐng)求
    HttpEntity<Map> requst = new HttpEntity<>(map, headers);
    ResponseEntity<String> exchange = restTemplate.exchange(url, HttpMethod.POST, requst, String.class);
    System.out.println("響應(yīng)的結(jié)果:" + exchange.getBody());
}

@PostMapping("/postTest2")
public User test2(HttpServletRequest request, @RequestBody User user1) {
    System.out.println("接受的參數(shù)：" + user1);
    System.out.println("接受的請(qǐng)求頭：" + request.getHeader("token"));
    User user = new User();
    user.setId(1);
    user.setName("張三");
    user.setSex("男性");
    return user;
}

@GetMapping("/exchange2")
public void hello2() {
    String url = "http://127.0.0.1:8006/postTest2";

    // 請(qǐng)求體,不要用LinkedMultiValueMap，否則會(huì)變成key/value傳參
    User user = new User();
    user.setId(1);
    user.setName("李四");
    user.setSex("女性");
    // 請(qǐng)求頭（這里有一點(diǎn)需要注意，HttpHeaders和HttpEntity都是引入的spring的包）
    HttpHeaders headers = new HttpHeaders();
    headers.add("token", "WDWADAWDWADAWSAXZCXZCXZEDF");
    // 請(qǐng)求
    HttpEntity<User> requst = new HttpEntity<>(user, headers);
    ResponseEntity<User> exchange = restTemplate.exchange(url, HttpMethod.POST, requst, User.class);
    System.out.println("響應(yīng)的結(jié)果:" + exchange.getBody());
}

@Component
public class HttpUtil {

    private static Logger logger = LoggerFactory.getLogger(HttpUtil.class);

    @Resource
    private RestTemplate restTemplate;

    private static HttpUtil httpUtil;

    @PostConstruct
    public void init(){
        httpUtil = this;
        httpUtil.restTemplate = this.restTemplate;
    }

    public static <T> String httpRequest(String url, HttpMethod method, HttpEntity<T> entity,Class<T> responseType){
        try {
            //發(fā)起一個(gè)POST請(qǐng)求
            ResponseEntity<String> result = httpUtil.restTemplate.exchange(url, method, entity, responseType);
           return result.getBody();
        } catch (Exception e) {
            logger.error("請(qǐng)求失?。?" + e.getMessage());
        }
        return null;
    }

}