사용자 의 Http 요청 을 전달 하 는 데 사용 되 는 중간 api

가끔 은 제한 이나 다른 이유 로 외부 인터페이스 에 직접 접근 할 수 없 기 때문에 우 리 는 중간 역 이 필요 합 니 다. 중간 사용자 의 요청 에 사용 하고 사용자 의 요청 을 목적 주소 로 보 낸 다음 에 사용자 가 필요 로 하 는 결 과 를 되 돌려 야 합 니 다.
알다 시 피 Http 요청 은 요청 헤더 와 요청 체 로 나 뉘 고 응답 도 응답 헤더 와 응답 체 로 나 뉜 다.그래서 우리 가 중간 에 돌 때 보통 요청 헤드, 요청 체 를 설정 해 야 하지만 응답 은 응답 체 로 돌아 가면 됩 니 다.우 리 는 json 을 사용 하여 우리 의 매개 변수 와 응답 을 설명 할 수 있다.
 

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import javax.ws.rs.Consumes;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.params.AllClientPNames;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.util.EntityUtils;
import org.json.JSONArray;
import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 *    { "requestUrl": "http://10.95.253.74:17001/bp220.go?method=init",
 * "requestData": "{}", "requestMode": "POST", "contentType":
 * "application/json;charset=UTF-8", "inputCharset": "UTF-8", "outputCharset":
 * "UTF-8", "clientOutputCharset": "UTF-8",
 * headers:[{"headerName":"Content-Type","headerValue":"application/json"},{
 * "headerName":"Accept","headerValue":"gzip"}] }
 * 
 * 
 *     { "ResultCode":200, "ResultMsg":"SUCCESS", "Data":"{"key","value"}"
 * 
 * }
 */

@Path("/rest/transfer")
public class TransferApiResource{
    private static final Logger logger              = LoggerFactory.getLogger(TransferApiResource.class);
    private static final String requestData         = "";
    private static final String requestMode         = "POST";
    private static final String contentType         = "application/json";
    private static final String xinputCharset       = "UTF-8";
    private static final String xoutputCharset      = "UTF-8";
    private static final String clientOutputCharset = "UTF-8";

    @POST
    @Path("/send")
    @Consumes({ MediaType.APPLICATION_JSON })
    @Produces(MediaType.APPLICATION_JSON)
    public String send(String body){
        JSONObject bodyAsJson = new JSONObject(body);
        //      
        String url = bodyAsJson.getString("requestUrl");
        String data = (bodyAsJson.has("requestData")) ? bodyAsJson.getString("requestData") : requestData;
        String inputCharset = (bodyAsJson.has("inputCharset")) ? bodyAsJson.getString("inputCharset") : xinputCharset;
        String outputCharset = (bodyAsJson.has("outputCharset")) ? bodyAsJson.getString("outputCharset")
                : xoutputCharset;
        String clientOutput = (bodyAsJson.has("clientOutputCharset")) ? bodyAsJson.getString("clientOutputCharset")
                : clientOutputCharset;
        String mode = (bodyAsJson.has("requestMode")) ? bodyAsJson.getString("requestMode") : requestMode;
        String type = (bodyAsJson.has("contentType")) ? bodyAsJson.getString("contentType") : contentType;

        JSONArray headArray = new JSONArray();
        if(bodyAsJson.has("headers")){
            headArray = bodyAsJson.getJSONArray("headers");
        }
        Map headers = jsonArray2Map(headArray);

        String result = getReturn(url, data, inputCharset, outputCharset, clientOutput, mode, type, headers);
        return result;
    }

    /**
     * @Title: jsonArray2Map
     * @Description:jsonarray   map
     * @param headArray
     * @return Map
     */

    private Map jsonArray2Map(JSONArray headArray){
        Map map = new HashMap();
        int len = headArray.length();
        for(int i = 0; i < len; i++){
            JSONObject object = headArray.getJSONObject(i);
            map.put(object.getString("headerName"), object.getString("headerValue"));
        }
        return map;
    }

    @SuppressWarnings({ "deprecation", "resource" })
    public static String getReturn(String restUrl, String requestData, String inputCharset, String outputCharset,
            String clientOutputCharset, String requestMode, String contentType, Map headers){
        HttpClient httpClient = new DefaultHttpClient();
        httpClient.getParams().setParameter(AllClientPNames.CONNECTION_TIMEOUT, 30000);
        httpClient.getParams().setParameter(AllClientPNames.SO_TIMEOUT, 30000);
        // httpClient.getParams().setParameter("http.protocol.version",
        // HttpVersion.HTTP_1_1);
        httpClient.getParams().setParameter("http.protocol.content-charset", inputCharset);
        HttpGet httpGet = null;
        HttpPost httpPost = null;
        JSONObject result = new JSONObject();
        HttpEntity entity = null;
        HttpResponse response = null;
        try{
            if(TransferApiResource.requestMode.equalsIgnoreCase(requestMode)){
                // POST  
                httpPost = new HttpPost(restUrl);
                StringEntity reqEntity = new StringEntity(requestData, inputCharset);
                reqEntity.setContentType(contentType);
                reqEntity.setContentEncoding(inputCharset);
                httpPost.setEntity(reqEntity);
                // httpPost.setHeader("Accept", MediaType.APPLICATION_JSON);

                //   header
                for(Map.Entry entry : headers.entrySet()){
                    httpPost.addHeader(entry.getKey(), entry.getValue());
                }

                response = httpClient.execute(httpPost);

            } else{
                httpGet = new HttpGet(restUrl);
                // httpGet.setHeader("Accept", MediaType.APPLICATION_JSON);

                //   header
                for(Map.Entry entry : headers.entrySet()){
                    httpGet.addHeader(entry.getKey(), entry.getValue());
                }

                response = httpClient.execute(httpGet);
            }

            int status = response.getStatusLine().getStatusCode();
            logger.info("    :status=" + status);
            if(HttpStatus.SC_OK == status){
                entity = response.getEntity();
                String ret = "";
                if(entity != null){
                    ret = new String(EntityUtils.toString(entity).getBytes(outputCharset), clientOutputCharset);
                }

                result.put("ResultCode", HttpStatus.SC_OK);
                result.put("ResultMsg", "SUCCESS");
                result.put("Data", ret);

            } else{
                entity = response.getEntity();
                String error = new String(EntityUtils.toString(entity).getBytes(outputCharset), clientOutputCharset);
                String ret = "    :    " + status + "," + error;

                result.put("ResultCode", status);
                result.put("ResultMsg", "FAIL");
                result.put("Data", ret);
            }
            return result.toString();
        }
        catch(Exception e){
            e.printStackTrace();
            result.put("ResultCode", 500);
            result.put("ResultMsg", "EXCEPTION");
            return result.toString();
        }
        finally{
            if(null != entity){
                try{
                    EntityUtils.consume(entity);
                }
                catch(IOException e){
                    e.printStackTrace();
                }
            }
            if(null != httpGet && httpGet.isAborted()){
                httpGet.abort();
            }
            if(null != httpPost && httpPost.isAborted()){
                httpPost.abort();
            }
            if(null != httpClient){
                httpClient.getConnectionManager().shutdown();
            }
        }

    }
}