package com.inspur.ws;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.Reader;

import java.io.StringReader;

import java.net.HttpURLConnection;

import java.net.URL;

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.Future;

import org.apache.http.HttpEntity;

import org.apache.http.HttpResponse;

import org.apache.http.client.methods.CloseableHttpResponse;

import org.apache.http.client.methods.HttpPost;

import org.apache.http.entity.InputStreamEntity;

import org.apache.http.impl.client.CloseableHttpClient;

import org.apache.http.impl.client.HttpClients;

import org.apache.http.impl.nio.client.CloseableHttpAsyncClient;

import org.apache.http.impl.nio.client.HttpAsyncClients;

import org.apache.http.util.EntityUtils;

import org.dom4j.Document;

import org.dom4j.io.SAXReader;

import org.springframework.http.HttpHeaders;

import org.springframework.http.ResponseEntity;

import org.springframework.web.client.RestTemplate;

import org.springframework.web.reactive.function.client.WebClient;

import org.springframework.web.reactive.function.client.WebClient.ResponseSpec;

import reactor.core.publisher.Mono;

/**

 * Http方式调用WebService

 *

 */

public class Http {

    private static String urlWsdl = "http://www.webxml.com.cn/WebServices/TraditionalSimplifiedWebService.asmx?wsdl";

    private static String targetNamespace = "http://webxml.com.cn/";

    /**

     * HttpURLConnection方式

     * @param soap

     */

    public static void httpURLConnection(String soap) {

        HttpURLConnection connection = null;

        try {

            URL url = new URL(urlWsdl);

            connection = (HttpURLConnection)url.openConnection();

            connection.setDoOutput(true);

            connection.setDoInput(true);

            connection.setRequestProperty("Content-Type", "text/xml;charset=UTF-8");

            connection.setRequestProperty("SOAPAction", targetNamespace + "toTraditionalChinese");

            connection.connect();

            setBytesToOutputStream(connection.getOutputStream(), soap.getBytes());

            if (connection.getResponseCode() == HttpURLConnection.HTTP_OK) {

                byte[] b = getBytesFromInputStream(connection.getInputStream());

                String back = new String(b);

                System.out.println("httpURLConnection返回soap：" + back);

                System.out.println("httpURLConnection结果：" + parseResult(back));

            } else {

                System.out.println("httpURLConnection返回状态码：" + connection.getResponseCode());

            }

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            connection.disconnect();

        }

    }

    /**

     * Commons-HttpClinet方式

     * @param soap

     */

    public static void commonsHttpClient(String soap) {

        try {

            org.apache.commons.httpclient.HttpClient httpclient = new org.apache.commons.httpclient.HttpClient();

            org.apache.commons.httpclient.methods.PostMethod post = new org.apache.commons.httpclient.methods.PostMethod(urlWsdl);

            post.addRequestHeader("Content-Type", "text/xml;charset=UTF-8");

            post.addRequestHeader("SOAPAction", targetNamespace + "toTraditionalChinese");

            org.apache.commons.httpclient.methods.RequestEntity entity = new org.apache.commons.httpclient.methods.InputStreamRequestEntity(new ByteArrayInputStream(soap.getBytes()));

            post.setRequestEntity(entity);

            int status = httpclient.executeMethod(post);

            if (status == org.apache.commons.httpclient.HttpStatus.SC_OK) {

                String back = post.getResponseBodyAsString();

                System.out.println("Commons-HttpClinet返回soap：" + back);

                System.out.println("commons-HttpClinet返回结果：" + parseResult(back));

            } else {

                System.out.println("commons-HttpClinet返回状态码：" + status);

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    /**

     * HttpClient方式

     * @param soap

     */

    public static void httpClient(String soap) {

        try {

            CloseableHttpClient httpClient = HttpClients.createDefault();

            HttpPost httpPost = new HttpPost(urlWsdl);

            httpPost.setHeader("Content-Type", "text/xml;charset=UTF-8");

            httpPost.setHeader("SOAPAction", targetNamespace + "toTraditionalChinese");

            InputStreamEntity entity = new InputStreamEntity(new ByteArrayInputStream(soap.getBytes()));

            httpPost.setEntity(entity);

            CloseableHttpResponse response = httpClient.execute(httpPost);

            if (response.getStatusLine().getStatusCode() == org.apache.http.HttpStatus.SC_OK) {

                HttpEntity responseEntity = response.getEntity();

                String back = EntityUtils.toString(responseEntity);

                System.out.println("httpClient返回soap：" + back);

                System.out.println("httpClient返回结果：" + parseResult(back));

            } else {

                System.out.println("HttpClinet返回状态码：" + response.getStatusLine().getStatusCode());

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    /**

     * HttpAsyncClient方式

     * @param soap

     */

    public static void httpAsyncClient(String soap) {

        CloseableHttpAsyncClient httpClient = HttpAsyncClients.createDefault();

        try {

            httpClient.start();

            HttpPost httpPost = new HttpPost(urlWsdl);

            httpPost.setHeader("Content-Type", "text/xml;charset=UTF-8");

            httpPost.setHeader("SOAPAction", targetNamespace + "toTraditionalChinese");

            InputStreamEntity entity = new InputStreamEntity(new ByteArrayInputStream(soap.getBytes()));

            httpPost.setEntity(entity);

            Future<HttpResponse> future = httpClient.execute(httpPost, null);

            HttpResponse response = future.get();

            if (response.getStatusLine().getStatusCode() == org.apache.http.HttpStatus.SC_OK) {

                HttpEntity responseEntity = response.getEntity();

                String back = EntityUtils.toString(responseEntity);

                System.out.println("HttpAsyncClient返回soap：" + back);

                System.out.println("HttpAsyncClient返回结果：" + parseResult(back));

            } else {

                System.out.println("HttpAsyncClient返回状态码：" + response.getStatusLine().getStatusCode());

            }

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            try {httpClient.close();} catch (IOException e) {e.printStackTrace();}

        }

    }

    /**

     * RestTemplate方式

     * @param soap

     */

    public static void restTemplate(String soap) {

        RestTemplate template = new RestTemplate();

        HttpHeaders headers = new HttpHeaders();

        headers.add("SOAPAction", targetNamespace + "toTraditionalChinese");

        headers.add("Content-Type", "text/xml;charset=UTF-8");

        org.springframework.http.HttpEntity<String> entity = new org.springframework.http.HttpEntity<String>(soap, headers);

        ResponseEntity<String> response = template.postForEntity(urlWsdl, entity, String.class);

        if (response.getStatusCode() == org.springframework.http.HttpStatus.OK) {

            String back = template.postForEntity(urlWsdl, entity, String.class).getBody();

            System.out.println("restTemplate返回soap：" + back);

            System.out.println("restTemplate返回结果：" + parseResult(back));

        } else {

            System.out.println("restTemplate返回状态码：" + response.getStatusCode());

        }

    }

    /**

     * WebClient方式

     * @param soap

     */

    public static void webClient(String soap) {

        WebClient webClient = WebClient.create();

        ResponseSpec response = webClient.post().uri(urlWsdl)

                .header("SOAPAction", targetNamespace + "toTraditionalChinese")

                .header("Content-Type", "text/xml;charset=UTF-8")

                .syncBody(soap).retrieve();

        Mono<String> mono = response.bodyToMono(String.class);

        System.out.println("webClient返回soap：" + mono.block());

        System.out.println("webClient结果：" + parseResult(mono.block()));

    }

    /**

     * 从输入流获取数据

     * @param in

     * @return

     * @throws IOException

     */

    private static byte[] getBytesFromInputStream(InputStream in) throws IOException {

        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        byte[] b = new byte[1024];

        int len;

        while ((len = in.read(b)) != -1) {

            baos.write(b, 0, len);

        }

        byte[] bytes = baos.toByteArray();

        return bytes;

    }

    /**

     * 向输入流发送数据

     * @param out

     * @param bytes

     * @throws IOException

     */

    private static void setBytesToOutputStream(OutputStream out, byte[] bytes) throws IOException {

        ByteArrayInputStream bais = new ByteArrayInputStream(bytes);

        byte[] b = new byte[1024];

        int len;

        while ((len = bais.read(b)) != -1) {

            out.write(b, 0, len);

        }

        out.flush();

    }

    /**

     * 解析结果

     * @param s

     * @return

     */

    private static String parseResult(String s) {

        String result = "";

        try {

            Reader file = new StringReader(s);

            SAXReader reader = new SAXReader();

            Map<String, String> map = new HashMap<String, String>();

            map.put("ns", "http://webxml.com.cn/");

            reader.getDocumentFactory().setXPathNamespaceURIs(map);

            Document dc = reader.read(file);

            result = dc.selectSingleNode("//ns:toTraditionalChineseResult").getText().trim();

        } catch (Exception e) {

            e.printStackTrace();

        }

        return result;

    }

    public static void main(String[] args) {

        String soap11 = "<soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:web=\"http://webxml.com.cn/\">"

                       + "<soapenv:Header/>"

                       + "<soapenv:Body>"

                       +    "<web:toTraditionalChinese>"

                       +      "<web:sText>小学</web:sText>"

                       +    "</web:toTraditionalChinese>"

                       + "</soapenv:Body>"

                       + "</soapenv:Envelope>";

        String soap12 = "<soapenv:Envelope xmlns:soapenv=\"http://www.w3.org/2003/05/soap-envelope\" xmlns:web=\"http://webxml.com.cn/\">"

                   + "<soapenv:Header/>"

                   + "<soapenv:Body>"

                   +    "<web:toTraditionalChinese>"

                   +      "<web:sText>大学</web:sText>"

                   +    "</web:toTraditionalChinese>"

                   + "</soapenv:Body>"

                   + "</soapenv:Envelope>";

        httpURLConnection(soap11);

        httpURLConnection(soap12);

        commonsHttpClient(soap11);

        commonsHttpClient(soap12);

        httpClient(soap11);

        httpClient(soap12);

        httpAsyncClient(soap11);

        httpAsyncClient(soap12);

        restTemplate(soap11);

        restTemplate(soap12);

        webClient(soap11);

        webClient(soap12);

    }

}