关于控制HTTP请求

[yongao2622]

是这样的，我准备写一个项目来访问别人的接口，需要发送HTTP请求，然后需要对请求进行判断（对请求中的密码和密钥等和数据库进行对比）。框架主要是用Spring+MyBatis，已经搭好了。请问需要该怎么做，提供以下思路可以吗各位大神（最好能带点代码）。本人小白一个刚接触项目，别人就给了我个小工程。特来虚心求教 。谢谢各位大神啦

[a87985426]

这个帐号密码登录不是最基本的吗?form表单提交数据,request接受,在与数据库里的数据对比.

[潇湘如梦]

使用okhttp maven: <dependency> <groupId>com.squareup.okhttp</groupId> <artifactId>okhttp</artifactId> <version>2.7.4</version> </dependency> 代码：

import java.io.IOException;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import com.alibaba.fastjson.JSONObject;
import com.squareup.okhttp.ConnectionPool;
import com.squareup.okhttp.FormEncodingBuilder;
import com.squareup.okhttp.MediaType;
import com.squareup.okhttp.OkHttpClient;
import com.squareup.okhttp.Request;
import com.squareup.okhttp.RequestBody;
import com.squareup.okhttp.Response;
import com.squareup.okhttp.ResponseBody;
public class OKHttpUtil {
    public static final String JSON_MIME = "application/json";
    public static final String FORM_MIME = "application/x-www-form-urlencoded";
    private static final OkHttpClient httpClient = new OkHttpClient();
    static {
        httpClient.setConnectTimeout(30, TimeUnit.SECONDS);
        ConnectionPool connectionPool = new ConnectionPool(200, 5 * 60 * 1000);
        httpClient.setConnectionPool(connectionPool);
    }
    public static boolean head(String url) {
        if (StringUtils.isEmpty(url)) {
            return false;
        }
        Request.Builder requestBuilder = new Request.Builder().head().url(url);
        Response response = null;
        try {
            response = httpClient.newCall(requestBuilder.build()).execute();
            return response.isSuccessful();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (response == null) {
                return false;
            }
            ResponseBody body = response.body();
            if (body != null) {
                try {
                    body.close();
                } catch (Exception e2) {
                    e2.printStackTrace();
                }
            }
        }
        return false;
    }
    public static Response get(String url, Map<String, Object> headers) throws Exception {
        Request.Builder requestBuilder = new Request.Builder().get().url(url);
        if (!CollectionUtils.isEmpty(headers)) {
            headers.forEach((key, value) -> {
                requestBuilder.header(key, value.toString());
            });
        }
        Response response = httpClient.newCall(requestBuilder.build()).execute();
        return response;
    }
    public static String getResult(String url, Map<String, Object> headers) throws Exception {
        return getResult(url, headers, null);
    }


    public static String getResult(String url, Map<String, Object> headers, String encode) throws Exception {
        Response response = get(url, headers);
        return getResult(response, encode);
    }

    public static String postResult(String url, Map<String, Object> headers, Map<String, Object> params)
            throws Exception {
        Response response = postReponse(url, headers, params);
        return getResult(response, "UTF-8");
    }
    public static Response postReponse(String url, Map<String, Object> headers, Map<String, Object> params)
            throws Exception {
        Request.Builder requestBuilder = new Request.Builder().url(url);
        if (!CollectionUtils.isEmpty(headers)) {
            headers.forEach((key, value) -> {
                requestBuilder.header(key, value.toString());
            });
        }
        requestBuilder.header("Content-Type", FORM_MIME);
        FormEncodingBuilder builder = new FormEncodingBuilder();
        if (!CollectionUtils.isEmpty(params)) {
            params.forEach((key, value) -> {
                builder.add(key, value.toString());
            });  
        }
        requestBuilder.post(builder.build());
        Response response = httpClient.newCall(requestBuilder.build()).execute();
        return response;
    }

    public static String postResult(String url, Map<String, Object> headers, Object entity) throws Exception {
        String jsonStr = JSONObject.toJSONString(entity);
        return postResult(url, headers, jsonStr);
    }

    public static String postResult(String url, Map<String, Object> headers, String content)
            throws Exception {
        Request.Builder requestBuilder = new Request.Builder().url(url);
        if (!CollectionUtils.isEmpty(headers)) {
            headers.forEach((key, value) -> {
                requestBuilder.header(key, value.toString());
            });
        }
        MediaType mediaType = MediaType.parse(JSON_MIME + "; charset=utf-8");
        requestBuilder.header("Content-Type", mediaType.toString());
        requestBuilder.post(RequestBody.create(mediaType, content));
        Response response = httpClient.newCall(requestBuilder.build()).execute();
        return getResult(response, "UTF-8");
    }
    public static String putResult(String url, Map<String, Object> headers, Map<String, Object> params)
            throws Exception {
        Response response = put(url, headers, params);
        return getResult(response, "UTF-8");
    }
    public static Response put(String url, Map<String, Object> headers, Map<String, Object> params)
            throws Exception {
        Request.Builder requestBuilder = new Request.Builder().url(url);
        requestBuilder.header("Content-Type", FORM_MIME);
        if (!CollectionUtils.isEmpty(headers)) {
            headers.forEach((key, value) -> {
                requestBuilder.header(key, value.toString());
            });
        }
        if (!CollectionUtils.isEmpty(params)) {
            FormEncodingBuilder builder = new FormEncodingBuilder();
            params.forEach((key, value) -> {
                builder.add(key, value.toString());
            });
            requestBuilder.put(builder.build());
        }
        Response response = httpClient.newCall(requestBuilder.build()).execute();
        return response;
    }
    public static String putResult(String url, Map<String, Object> headers, Object entity) throws Exception {
        Response response = put(url, headers, JSON_MIME, JSONObject.toJSONString(entity));
        return getResult(response, "UTF-8");
    }
    private static Response put(String url, Map<String, Object> headers, String mimi,String content) throws Exception {
        Request.Builder requestBuilder = new Request.Builder().url(url);
        if (!CollectionUtils.isEmpty(headers)) {
            headers.forEach((key, value) -> {
                requestBuilder.header(key, value.toString());
            });
        }
        MediaType mediaType = MediaType.parse(mimi);
        requestBuilder.header("Content-Type", mediaType.toString());
        requestBuilder.put(RequestBody.create(mediaType, content));
        Response response = httpClient.newCall(requestBuilder.build()).execute();
        return response;
    }
    public static String deleteResult(String url, Map<String, Object> headers) throws Exception {
        Response response = delete(url, headers);
        return getResult(response, "UTF-8");
    }
    public static String deleteResult(String url, Map<String, Object> headers, Map<String, Object> params) throws Exception {
        Request.Builder requestBuilder = new Request.Builder().url(url);
        requestBuilder.header("Content-Type", FORM_MIME);
        if (!CollectionUtils.isEmpty(headers)) {
            headers.forEach((key, value) -> {
                requestBuilder.header(key, value.toString());
            });
        }
        if (!CollectionUtils.isEmpty(params)) {
            FormEncodingBuilder builder = new FormEncodingBuilder();
            params.forEach((key, value) -> {
                builder.add(key, value.toString());
            });
            requestBuilder.delete(builder.build());
        }
        Response response = httpClient.newCall(requestBuilder.build()).execute();
        return getResult(response, "UTF-8");
    }
    
    public static String deleteResult(String url, Map<String, Object> headers,String content) throws Exception {
        Request.Builder requestBuilder = new Request.Builder().delete().url(url);
        if (!CollectionUtils.isEmpty(headers)) {
            headers.forEach((key, value) -> {
                requestBuilder.header(key, value.toString());
            });
        }
        MediaType mediaType = MediaType.parse(JSON_MIME + "; charset=utf-8");
        requestBuilder.delete(RequestBody.create(mediaType, content));
        Response response = httpClient.newCall(requestBuilder.build()).execute();
        return getResult(response, "UTF-8");
    }

    public static Response delete(String url, Map<String, Object> headers) throws Exception {
        Request.Builder requestBuilder = new Request.Builder().delete().url(url);
        if (!CollectionUtils.isEmpty(headers)) {
            headers.forEach((key, value) -> {
                requestBuilder.header(key, value.toString());
            });
        }
        Response response = httpClient.newCall(requestBuilder.build()).execute();
        return response;
    }

    private static String getResult(Response response, String encode) {
        if (response == null) {
            return null;
        }
        ResponseBody body = null;
        try {
            body = response.body();
            if (!response.isSuccessful()) {
                return null;
            }
            if (body == null) {
                return null;
            }
            if (StringUtils.isEmpty(encode)) {
                return new String(body.bytes());
            } else {
                return new String(body.bytes(), encode);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (body != null) {
                    body.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}