get请求 java后台接收参数

方法一：
来自:

package com.springboot.dlc.utils;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.ProtocolException;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
@Slf4j
public class UrlUtil {
    public String sendMessage(String strReqJsonStr, String urlValue) {
        StringBuffer result = new StringBuffer();
        try {
            URL url = new URL(urlValue);
            HttpURLConnection con = (HttpURLConnection) url.openConnection();
            con.setDoOutput(true);
            con.setRequestMethod("POST");
            con.setRequestProperty("Content-Type", "text/xml; charset=UTF-8");
            con.connect();

            OutputStream outputStream = con.getOutputStream();
            StringBuilder sb = new StringBuilder("xmldata=");
            sb.append("dom.asXML()");
            //参数
            outputStream.write(sb.toString().getBytes());
            outputStream.flush();
            log.info("HTTP状态码={}", con.getResponseCode());
            BufferedReader inn = new BufferedReader(new InputStreamReader(con.getInputStream(), "UTF-8"));
            String value = inn.readLine();
            while (value != null) {
                result.append(value);
                value = inn.readLine();
            }

            inn.close();
            outputStream.close();
        } catch (ProtocolException e) {
            e.printStackTrace();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return result.toString();
    }

    public String getMessage(String urlValue) {
        StringBuffer result = new StringBuffer();
        try {
            URL url = new URL(urlValue);
            HttpURLConnection con = (HttpURLConnection) url.openConnection();
            con.setDoOutput(true);
            con.setRequestMethod("GET");
            con.setRequestProperty("Content-Type", "text/xml; charset=UTF-8");
            con.connect();
            log.info("HTTP状态码={}", con.getResponseCode());
            BufferedReader inn = new BufferedReader(new InputStreamReader(con.getInputStream(), "UTF-8"));
            String value = inn.readLine().trim();
            while (value != null) {
                if (!"".equals(value)) {
                    result.append(value.trim() + "\n");
                }
                value = inn.readLine();
            }
            inn.close();
        } catch (ProtocolException e) {
            e.printStackTrace();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result.toString();
    }

    public void test() {
        Map<String, String> paramsMap = new HashMap<>();
        String strReqJsonStr = JSON.toJSONString(paramsMap);
        String Message = sendMessage(strReqJsonStr, "https://www.showdoc.cc/");
        log.info("Message:{}", Message);
    }
}

方法二

HttpClientUtils 工具类

package com.springboot.dlc.utils;

import java.io.File;
import java.io.FileInputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ssl.DefaultHostnameVerifier;
import org.apache.http.conn.util.PublicSuffixMatcher;
import org.apache.http.conn.util.PublicSuffixMatcherLoader;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.InputStreamEntity;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

/**
 * HTTP 请求工具类
 * @author huaieli
 *
 */
public class HttpClientUtils {
	private static RequestConfig requestConfig = RequestConfig.custom()
            .setSocketTimeout(15000)
            .setConnectTimeout(15000)
            .setConnectionRequestTimeout(15000)
            .build();

	/**
	 * 发送HTTP POST请求,支持带多个String参数
	 *
	 * @param url 链接
	 * @param paramMap 参数
	 */
	public static String sendHttpPost(String url, Map<String, String> paramMap) throws Exception {
		CloseableHttpClient httpclient = HttpClientUtils.getHttpClient();
		return sendHttpPost(url, paramMap, httpclient);
	}

	/**
	 * 发送HTTP POST请求,支持多个参数(注：多个参数需拼接)
	 *
	 * @param url 链接
	 * @param params 参数(格式:key1=value1&key2=value2)
	 */
	public static String sendHttpPost(String url, String params) throws Exception {
		CloseableHttpClient httpclient = HttpClientUtils.getHttpClient();
		return sendHttpPost(url, params, httpclient);
	}

	/**
	 * 发送HTTP POST请求,支持带一个文件参数
	 *
	 * @param url 链接
	 * @param file 文件
	 */
	public static String sendHttpPost(String url, File file) throws Exception {
		CloseableHttpClient httpclient = HttpClientUtils.getHttpClient();
        try {
            HttpPost httpPost = new HttpPost(url);

            InputStreamEntity reqEntity = new InputStreamEntity(new FileInputStream(file), -1, ContentType.APPLICATION_OCTET_STREAM);
            reqEntity.setChunked(true);

            httpPost.setEntity(reqEntity);

            return sendHttpPost(httpPost, httpclient);
        } finally {
            httpclient.close();
        }
	}

	/**
	 * 发送HTTP POST请求(客户端采用二进制流发送,服务端采用二进制流接收)
	 *
	 * @param url 链接
	 * @param binaryStreamsStr 参数
	 */
	public static String sendHttpPostByStream(String url, String binaryStreamsStr) throws Exception {
		CloseableHttpClient httpclient = HttpClientUtils.getHttpClient();
        try {
            HttpPost httpPost = new HttpPost(url);

            HttpEntity reqEntity = new ByteArrayEntity(binaryStreamsStr.getBytes(Consts.UTF_8), ContentType.APPLICATION_JSON);

            httpPost.setEntity(reqEntity);

            return sendHttpPost(httpPost, httpclient);
        } finally {
            httpclient.close();
        }
	}

	/**
	 * 发送POST请求,支持带多个String参数和多个文件参数
	 *
	 * @param url 链接
	 * @param paraMap 参数集合
	 * @param fileMap 文件集合
	 */
	public static String sendHttpPostByFile(String url, Map<String, String> paraMap, Map<String, File> fileMap) throws Exception {
		CloseableHttpClient httpclient = HttpClientUtils.getHttpClient();
		try {
			HttpPost httpPost = new HttpPost(url);

			MultipartEntityBuilder builder = MultipartEntityBuilder.create();

			for (String key : paraMap.keySet()) {
				 builder.addPart(key, new StringBody(paraMap.get(key), ContentType.TEXT_PLAIN));
			}
			for (String fileStr : fileMap.keySet()) {
				builder.addPart(fileStr, new FileBody(fileMap.get(fileStr)));
			}

			HttpEntity reqEntity = builder.build();

			httpPost.setEntity(reqEntity);

			return sendHttpPost(httpPost, httpclient);
		} finally {
			httpclient.close();
		}
	}

	/**
	 * 发送HTTP GET请求,不带参数(注：可将参数加在url后面)
	 *
	 * @param url 链接
	 */
	public static String sendHttpGet(String url) throws Exception {
		CloseableHttpClient httpclient = HttpClientUtils.getHttpClient();
		try {
			return sendHttpGet(url, httpclient);
		} finally {
			httpclient.close();
		}
	}

	/**
	 * 发送HTTP GET请求,不带参数,返回byte数组
	 *
	 * @param url 链接
	 */
	public static byte[] sendHttpGetResByte(String url) throws Exception {
		CloseableHttpClient httpclient = HttpClientUtils.getHttpClient();
		try {
			return sendHttpGetResByte(url, httpclient);
		} finally {
			httpclient.close();
		}
	}

	/**
	 * 发送HTTP GET请求,支持多个参数(注：多个参数需拼接)
	 *
	 * @param url 链接
	 * @param params 参数(格式:key1=value1&key2=value2)
	 */
	public static String sendHttpGet(String url, String params) throws Exception {
		CloseableHttpClient httpclient = HttpClientUtils.getHttpClient();
		return sendHttpGet(url, params, httpclient);
	}

	/**
	 * 发送HTTPS GET请求,支持多个参数(注：多个参数需拼接)
	 *
	 * @param url 链接
	 * @param params 参数(格式:key1=value1&key2=value2)
	 */
	public static String sendHttpsGet(String url, String params) throws Exception {
		CloseableHttpClient httpclient = HttpClientUtils.getHttpsClient(url);
		return sendHttpGet(url, params, httpclient);
	}

	/**
	 * 发送HTTPS GET请求,不带参数(注：可将参数加在url后面)
	 *
	 * @param url 链接
	 */
	public static String sendHttpsGet(String url) throws Exception {
		CloseableHttpClient httpclient = HttpClientUtils.getHttpsClient(url);
		try {
			return sendHttpGet(url, httpclient);
		} finally {
			httpclient.close();
		}
	}

	/**
	 * 发送HTTPS POST请求,支持带多个String参数
	 *
	 * @param url 链接
	 * @param paramMap 参数
	 */
	public static String sendHttpsPost(String url, Map<String, String> paramMap) throws Exception {
		CloseableHttpClient httpclient = HttpClientUtils.getHttpsClient(url);
		return sendHttpPost(url, paramMap, httpclient);
	}

	/**
	 * 发送HTTPS POST请求,支持多个参数(注：多个参数需拼接)
	 *
	 * @param url 链接
	 * @param params 参数(格式:key1=value1&key2=value2)
	 */
	public static String sendHttpsPost(String url, String params) throws Exception {
		CloseableHttpClient httpclient = HttpClientUtils.getHttpsClient(url);
		if(params!=null&&!"".equals(params)){
			return sendHttpPost(url, params, httpclient);
		}
		return sendHttpGet(url, httpclient);
	}

	/**
	 * 发送HTTP GET请求
	 */
	private static String sendHttpGet(String url, String params, CloseableHttpClient httpclient) throws Exception {
		try {
			StringBuilder sb = new StringBuilder()
					.append(url)
					.append("?")
					.append(params);

			return sendHttpGet(sb.toString(), httpclient);
		} finally {
			httpclient.close();
		}
	}

	/**
	 * 发送HTTP POST请求
	 */
	private static String sendHttpPost(String url, Map<String, String> paramMap, CloseableHttpClient httpclient) throws Exception {
	    try {
	        HttpPost httpPost = new HttpPost(url);
	        List<NameValuePair> nvps = new ArrayList<NameValuePair>();

	        for (String key : paramMap.keySet()) {
	        	nvps.add(new BasicNameValuePair(key, paramMap.get(key)));
			}
	        httpPost.setEntity(new UrlEncodedFormEntity(nvps,Consts.UTF_8));
	        return sendHttpPost(httpPost, httpclient);
	    } finally {
	        httpclient.close();
	    }
	}

	/**
	 * 发送HTTP POST请求
	 */
	private static String sendHttpPost(String url, String params, CloseableHttpClient httpclient) throws Exception {
		try {
            HttpPost httpPost = new HttpPost(url);

            httpPost.setEntity(new StringEntity(params, Consts.UTF_8));

            return sendHttpPost(httpPost, httpclient);
        } finally {
            httpclient.close();
        }
	}

	/**
	 * 获取HttpClient
	 */
	private static CloseableHttpClient getHttpClient() {
		return HttpClients.createDefault();
	}

	/**
	 * 获取HTTPS HttpClient
	 */
	private static CloseableHttpClient getHttpsClient(String url) throws Exception {
		PublicSuffixMatcher publicSuffixMatcher = PublicSuffixMatcherLoader.load(new URL(url));

        DefaultHostnameVerifier hostnameVerifier = new DefaultHostnameVerifier(publicSuffixMatcher);

        CloseableHttpClient httpclient = HttpClients.custom()
                .setSSLHostnameVerifier(hostnameVerifier)
                .build();

		return httpclient;
	}

	/**
	 * 发送HTTP POST请求
	 */
	private static String sendHttpPost(HttpPost httpPost, CloseableHttpClient httpclient) throws Exception {
		httpPost.setConfig(requestConfig);
        CloseableHttpResponse response = httpclient.execute(httpPost);

        try {
            HttpEntity entity = response.getEntity();
            int statusCode = response.getStatusLine().getStatusCode();
            System.out.println("statusCode=="+statusCode);
            if (statusCode != HttpStatus.SC_OK) {
            	return "ERROR";
            }
            return EntityUtils.toString(entity, Consts.UTF_8);
        } finally {
            response.close();
        }
	}

	/**
	 * 发送HTTP GET请求
	 */
	private static String sendHttpGet(String url, CloseableHttpClient httpclient) throws Exception{
		HttpGet httpGet = new HttpGet(url);
		httpGet.setConfig(requestConfig);
		CloseableHttpResponse response = httpclient.execute(httpGet);

		try {
			HttpEntity entity = response.getEntity();
			int statusCode = response.getStatusLine().getStatusCode();
            System.out.println("statusCode=="+statusCode);
            if (statusCode != HttpStatus.SC_OK) {
            	return "ERROR";
            }
			return EntityUtils.toString(entity, Consts.UTF_8);
		} finally {
			response.close();
		}
	}

	/**
	 * 发送HTTP GET请求
	 */
	private static byte[] sendHttpGetResByte(String url, CloseableHttpClient httpclient) throws Exception{
		HttpGet httpGet = new HttpGet(url);
		httpGet.setConfig(requestConfig);
		CloseableHttpResponse response = httpclient.execute(httpGet);

		try {
			HttpEntity entity = response.getEntity();

			return EntityUtils.toByteArray(entity);
		} finally {
			response.close();
		}
	}

}

请求方式 招商预算分布项目方式

public String xxxpost(){
		String result = ERROR;
		try {
			Map<String, String> paramMap = new HashMap<String, String>();
			String empid = SessionUtil.getUser().getEmpId();
			String data = getParameter("data")==null?"":getParameter("data");
			String permission = getParameter("permission")==null?"":getParameter("permission");
			//String url = BmUtils.buildBmUpdateDireconn(empid);
			String url = "";
			paramMap.put("data", data);
			paramMap.put("permissionData", permission);
			String responseStr = HttpClientUtils.sendHttpPost(url, paramMap);
			System.out.println("resposeStr===="+responseStr);
			if(responseStr!=null&&!"ERROR".equals(responseStr)){
                resultMap = new HashMap<String,Object>();				
                resultMap= JsonUtil.read(responseStr, Map.class);
                result = SUCCESS;
			}
		} catch (Exception e) {
			result = ERROR;
			e.printStackTrace();
		}
		return result;
	}

	public String xxxget(){
		String result = ERROR;
		try {
			String empid= SessionUtil.getUser().getEmpId();
			//String url = BmUtils.buildBmDireconnByPmkyPmcd(empid);
			String url = "?empid="+empid;
			String responseStr = HttpClientUtils.sendHttpGet(url);
			responseStr = responseStr.replaceAll("null", "\"\"");
			if(responseStr!=null&&!"ERROR".equals(responseStr)){
				resultMap= JsonUtil.read(responseStr, Map.class);
				result = SUCCESS;	
			}
		} catch (Exception e) {
			logger.error("xxxxxx", e);
			e.printStackTrace();
			result = ERROR;
		}
		return result;
	}

3、HTTP状态码

HTML接口使用的是HTTP协议，HTTP协议常用的状态码如下：

以下内容来自：https://support.google.com/webmasters/answer/40132#

如果向您的服务器发出了某项请求要求显示您网站上的某个网页（例如，当用户通过浏览器访问您的网页或在 Googlebot 抓取该网页时），那么，您的服务器会返回 HTTP 状态代码以响应该请求。

此状态代码提供该请求状态的相关信息，并向 Googlebot 提供有关您网站和请求的网页的信息。

一些常见的状态代码为：

200 - 服务器成功返回网页
404 - 请求的网页不存在
503 - 服务器暂时不可用
以下提供了 HTTP 状态代码的完整列表。您还可以访问有关 HTTP 状态代码的 W3C 网页，了解详细信息。

1xx（临时响应）
用于表示临时响应并需要请求者执行操作才能继续的状态代码。

代码	说明
100（继续）	请求者应继续进行请求。服务器返回此代码以表示，服务器已收到某项请求的第一部分，正等待接收剩余部分。
101（切换协议）	请求者已要求服务器切换协议，服务器已确认并准备进行切换。

2xx（成功）

用于表示服务器已成功处理相应请求的状态代码。

代码	说明
200（成功）	服务器成功处理了相应请求。通常，这表示服务器已提供了请求的网页。如果您的 robots.txt 文件显示为此状态，则表示 Googlebot 已成功检索到该文件。
201（已创建）	请求成功且服务器已创建了新的资源。
202（已接受）	服务器已接受相应请求，但尚未对其进行处理。
203（非授权信息）	服务器已成功处理相应请求，但返回了可能来自另一来源的信息。
204（无内容）	服务器已成功处理相应请求，但未返回任何内容。
205（重置内容）	服务器已成功处理相应请求，但未返回任何内容。与 204 响应不同，此响应要求请求者重置文档视图（例如清除表单内容以输入新内容）。
206（部分内容）	服务器成功处理了部分 GET 请求。

3xx（已重定向）
您需要进一步操作才能完成请求。此类状态代码通常可用于重定向。Google 建议您针对每一请求使用重定向的次数少于五次。您可以使用网站站长工具确定 Googlebot 是否会在抓取重定向网页时遇到问题。抓取下的抓取错误页列出了由于重定向错误而导致 Googlebot 无法抓取的网址。

代码	说明
300（多种选择）	服务器可以根据请求来执行多项操作，例如：按照请求者（用户代理）的要求来选择某项操作或者展示列表以便请求者选择其中某项操作。
301（永久移动）	请求的网页已永久移动到新位置。服务器返回此响应（作为对 GET 或 HEAD 请求的响应）时，会自动将请求者转到新位置。您应使用此代码通知 Googlebot 某个网页或网站已被永久移动到新位置。
302（临时移动）	服务器目前正从不同位置的网页响应请求，但请求者应继续使用原有位置来进行以后的请求。此代码与响应 GET 和 HEAD 请求的 301 代码类似，会自动将请求者转到不同的位置。但由于 Googlebot 会继续抓取原有位置并将其编入索引，因此您不应使用此代码来通知 Googlebot 某个页面或网站已被移动。
303（查看其他位置）	当请求者应对不同的位置进行单独的 GET 请求以检索响应时，服务器会返回此代码。对于除 HEAD 请求之外的所有请求，服务器会自动转到其他位置。
304（未修改）

请求的网页自上次请求后再也没有修改过。当服务器返回此响应时，不会返回相关网页的内容。

如果网页自请求者上次请求后再也没有更改过，您应当将服务器配置为返回此响应（称为 If-Modified-Since HTTP 标头）。服务器可以告诉 Googlebot 自从上次抓取后网页没有变更，进而节省带宽和开销。

305（使用代理） 请求者只能使用代理访问请求的网页。如果服务器返回此响应，那么，服务器还会指明请求者应当使用的代理。
307（临时重定向） 服务器目前正从不同位置的网页响应请求，但请求者应继续使用原有位置来进行以后的请求。此代码与响应 GET 和 HEAD 请求的 301 代码类似，会自动将请求者转到不同的位置。但由于 Googlebot 会继续抓取原有位置并将其编入索引，因此您不应使用此代码来通知 Googlebot 某个页面或网站已被移动。
4xx（请求错误）
此类状态代码表示，相应请求可能出错，已阻止了服务器对请求的处理。

代码	说明
400（错误请求）	服务器不理解相应请求的语法。
401（未授权）	请求要求进行身份验证。登录后，服务器可能会返回对页面的此响应。
403（已禁止）	服务器正在拒绝相应请求。如果 Googlebot 在尝试抓取网站的有效网页时收到此状态代码（您可在 Google 网站站长工具中运行状况下的抓取错误页上进行查看），则可能是因为您的服务器或主机正在阻止 Googlebot 进行访问。
404（未找到）	服务器找不到请求的网页。例如，如果相应请求是针对服务器上不存在的网页进行的，那么服务器通常会返回此代码。如果您的网站上没有 robots.txt 文件，而您在 Google 网站站长工具中的已拦截的网址页上看到此状态，那么这就是正确的状态。然而，如果您有 robots.txt 文件而又发现了此状态，那么，这说明您的 robots.txt 文件可能是命名错误或位于错误的位置。（该文件应当位于顶级域名上，且应当名为 robots.txt）。如果您在 Googlebot 尝试抓取的网址上看到此状态，那么这表示 Googlebot 追踪的可能是另一网页中的无效链接（旧链接或输入有误的链接）。
405（方法禁用）	禁用相应请求中所指定的方法。
406（不接受）	无法使用相应请求的内容特性来响应请求的网页。
407（需要代理授权）	此状态代码与 401（未授权）类似，但却指定了请求者应当使用代理进行授权。如果服务器返回此响应，那么，服务器还会指明请求者应当使用的代理。
408（请求超时）	服务器在等待请求时超时。
409（冲突）	服务器在完成请求时遇到冲突。服务器必须在响应中包含该冲突的相关信息。服务器在响应与前一个请求相冲突的 PUT 请求时可能会返回此代码，同时会提供两个请求的差异列表。
410（已删除）	如果请求的资源已被永久删除，那么服务器会返回此响应。该代码与 404（未找到）代码类似，但在资源以前有但现在已经不复存在的情况下，有时会替代 404 代码出现。如果资源已永久删除，您应使用 301 指定资源的新位置。
411（需要有效长度）	服务器不会接受包含无效内容长度标头字段的请求。
412（未满足前提条件）	服务器未满足请求者在请求中设置的其中一个前提条件。
413（请求实体过大）	服务器无法处理相应请求，因为请求实体过大，已超出服务器的处理能力。
414（请求的 URI 过长）	请求的 URI（通常为网址）过长，服务器无法进行处理。
415（不支持的媒体类型）	相应请求的格式不受请求页面的支持。
416（请求范围不符合要求）	如果相应请求是针对网页的无效范围进行的，那么服务器会返回此状态代码。
417（未满足期望值）	服务器未满足“期望”请求标头字段的要求。

5xx（服务器错误）

此类状态代码表示，服务器在尝试处理相应请求时发生内部错误。此类错误往往与服务器本身有关（与请求无关）。

代码	说明
500（服务器内部错误）	服务器遇到错误，无法完成相应请求。
501（尚未实施）	服务器不具备完成相应请求的功能。例如，当服务器无法识别请求方法时，可能便会返回此代码。
502（错误网关）	服务器作为网关或代理，从上游服务器收到了无效的响应。
503（服务不可用）	目前无法使用服务器（由于超载或进行停机维护）。通常，这只是暂时状态。
504（网关超时）	服务器作为网关或代理，未及时从上游服务器接收请求。
505（HTTP 版本不受支持）	服务器