Java实现发送Http请求
java发送HTTP请求（XML格式的报文）
java发送HTTP请求（XML格式的报⽂）package mon.utils;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.io.OutputStreamWriter;import .ConnectException;import .MalformedURLException;import .URL;import .URLConnection;/*** 发送HTTP的⼀种⽅法* GaoLiang*/public class HttpSendUtil {public static String testPost(String urlStr, String xmlInfo) {try {URL url = new URL(urlStr);URLConnection con = url.openConnection();con.setDoOutput(true);// con.setRequestProperty("Pragma:", "no-cache");// con.setRequestProperty("Cache-Control", "no-cache");// ⼀定要设置报⽂格式，否则发送失败con.setRequestProperty("Content-Type", "text/xml");OutputStreamWriter out = null;try {out = new OutputStreamWriter(con.getOutputStream());} catch (ConnectException e) {// e.printStackTrace();return "Connection refused";}// System.out.println("urlStr=" + urlStr);// System.out.println("xmlInfo=" + xmlInfo);out.write(new String(xmlInfo.getBytes("ISO-8859-1")));out.flush();out.close();BufferedReader br = new BufferedReader(new InputStreamReader(con.getInputStream()));StringBuilder stringBuilder = new StringBuilder();String line = "";for (line = br.readLine(); line != null; line = br.readLine()) {// System.out.println(line);stringBuilder.append(line);}return stringBuilder.toString();} catch (MalformedURLException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}return null;}}。
java模拟http请求，通过流（stream）的方式,发送json数据和文件
java模拟http请求，通过流（stream）的⽅式,发送json数据和⽂件发送端：/*** 以流的⽅式* 发送⽂件和json对象** @return*/public static String doPostFileStreamAndJsonObj(String url, List<String> fileList, JSONObject json) {String result = "";//请求返回参数String jsonString = json.toJSONString();//获得jsonstirng,或者toString都可以，只要是json格式，给了别⼈能解析成json就⾏// System.out.println("================");// System.out.println(xml);//可以打印出来瞅瞅// System.out.println("================");try {//开始设置模拟请求的参数，额，不⼀个个介绍了，根据需要拿String boundary = "------WebKitFormBoundaryUey8ljRiiZqhZHBu";URL u = new URL(url);HttpURLConnection conn = (HttpURLConnection) u.openConnection();conn.setDoOutput(true);conn.setDoInput(true);conn.setUseCaches(false);conn.setRequestMethod("POST");conn.setRequestProperty("connection", "Keep-Alive");//这⾥模拟的是⽕狐浏览器，具体的可以f12看看请求的user-agent是什么conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");conn.setRequestProperty("Charsert", "UTF-8");//这⾥的content-type要设置成表单格式，模拟ajax的表单请求conn.setRequestProperty("Content-Type", "multipart/form-data;boundary=" + boundary);// 指定流的⼤⼩，当内容达到这个值的时候就把流输出conn.setChunkedStreamingMode(10240000);//定义输出流，有什么数据要发送的，直接后⾯append就可以，记得转成byte再appendOutputStream out = new DataOutputStream(conn.getOutputStream());byte[] end_data = ("\r\n--" + boundary + "--\r\n").getBytes();// 定义最后数据分隔线StringBuilder sb = new StringBuilder();//添加form属性sb.append("--");sb.append(boundary);sb.append("\r\n");//这⾥存放要传输的参数，name = xmlsb.append("Content-Disposition: form-data; name=\"JsonObj\"");sb.append("\r\n\r\n");//把要传的json字符串放进来sb.append(jsonString);out.write(sb.toString().getBytes("utf-8"));out.write("\r\n".getBytes("utf-8"));int leng = fileList.size();for (int i = 0; i < leng; i++) {File file = new File(fileList.get(i));if(file.exists()){sb = new StringBuilder();sb.append("--");sb.append(boundary);sb.append("\r\n");//这⾥的参数啥的是我项⽬⾥对⽅接收要⽤到的，具体的看你的项⽬怎样的格式sb.append("Content-Disposition: form-data;name=\"File"+ "\";filename=\"" + file.getName() + "\"\r\n");//这⾥拼接个fileName，⽅便后⾯⽤第⼀种⽅式接收（如果是纯⽂件，不带其他参数，就可以不⽤这个了，因为Multipart可以直接解析⽂件）sb.append("FileName:"+ file.getName() + "\r\n");//发送⽂件是以流的⽅式发送，所以这⾥的content-type是octet-stream流sb.append("Content-Type:application/octet-stream\r\n\r\n");byte[] data = sb.toString().getBytes();out.write(data);DataInputStream in = new DataInputStream(new FileInputStream(file)); int bytes = 0;byte[] bufferOut = new byte[1024];while ((bytes = in.read(bufferOut)) != -1) {out.write(bufferOut, 0, bytes);}int j = i + 1;if (leng > 1 && j != leng) {out.write("\r\n".getBytes()); // 多个⽂件时，⼆个⽂件之间加⼊这个}in.close();}else{System.out.println("没有发现⽂件");}}//发送流out.write(end_data);out.flush();out.close();// 定义BufferedReader输⼊流来读取URL的响应BufferedReader reader = new BufferedReader(new InputStreamReader( conn.getInputStream()));String line = "";while ((line = reader.readLine()) != null) {result += line;}// System.out.println("================");// System.out.println(result.toString());//可以把结果打印出来瞅瞅// System.out.println("================");//后⾯可以对结果进⾏解析（如果返回的是格式化的数据的话）} catch (Exception e) {System.out.println("发送POST请求出现异常！" + e);e.printStackTrace();}return result;}----------------------------------发送端测试类public static void main(String args[]) throws Exception {//模拟流⽂件及参数上传String url = "http://127.0.0.1:8090/kty/test/receiveStream";//⽂件列表，搞了三个本地⽂件List<String> fileList = new ArrayList<>();fileList.add("F:\\me\\photos\\动漫\\3ba39425fec1965f4d088d2f.bmp"); fileList.add("F:\\me\\photos\\动漫\\09b3970fd3f5cc65b1351da4.bmp"); fileList.add("F:\\me\\photos\\动漫\\89ff57d93cd1b72cd0164ec9.bmp"); //json字符串，模拟了⼀个，传图⽚名字吧String jsonString = "{\n" +" \"token\": \"stream data\", \n" +" \"content\": [\n" +" {\n" +" \"id\": \"1\", \n" +" \"name\": \"3ba39425fec1965f4d088d2f.bmp\"\n" +" }, \n" +" {\n" +" \"id\": \"2\", \n" +" \"name\": \"09b3970fd3f5cc65b1351da4.bmp\"\n" +" }, \n" +" {\n" +" \"id\": \"3\", \n" +" \"name\": \"89ff57d93cd1b72cd0164ec9.bmp\"\n" +" }\n" +" ]\n" +"}";JSONObject json = JSONObject.parseObject(jsonString);doPostFileStreamAndJsonObj(url, fileList, json);}-----------------------------------------接收端：@RestController@RequestMapping("/test")//跨域注解@CrossOriginpublic class TestController {/*** 接收流信息** @param request* @return*/@PostMapping("/receiveStream")public String receiveStream(HttpServletRequest request) {String result = "";System.out.println("进来了");try {//获取request⾥的所有部分Collection<Part> parts = request.getParts();for (Iterator<Part> iterator = parts.iterator(); iterator.hasNext(); ) {Part part = iterator.next();System.out.println("名称========" + part.getName());if ("JsonObj".equals(part.getName())) {//解析json对象BufferedReader reader = new BufferedReader(new InputStreamReader(part.getInputStream()));String line = "";String parseString = "";while ((line = reader.readLine()) != null) {parseString += line;}JSONObject json = JSONObject.parseObject(parseString);System.out.println("接收到的json对象为=====" + json.toJSONString());} else if ("File".equals(part.getName())) {String fileName = "";Long size = part.getSize();//⽂件名的获取，可以直接获取header⾥定义好的FIleName（⼤部分没有），或从Content-Disposition去剪切出来// String head = part.getHeader("Content-Disposition");// fileName = head.substring(head.indexOf("filename=")+ 10, stIndexOf("\""));fileName = part.getHeader("FileName");System.out.println(fileName + size);// //这⾥就是⽂件，⽂件流就可以直接写⼊到⽂件了// InputStream inputStream = part.getInputStream();// OutputStream outputStream = new FileOutputStream(fileName);// int bytesWritten = 0;// int byteCount = 0;// byte[] bytes = new byte[1024];// while ((byteCount = inputStream.read(bytes)) != -1) {// outputStream.write(bytes, bytesWritten, byteCount);// bytesWritten += byteCount;// }// inputStream.close();// outputStream.close();}}//如果嫌上⾯获取⽂件的⿇烦，⽤下⾯这个⽐较简单，解析成multipartFile MultipartHttpServletRequest multiRequest = (MultipartHttpServletRequest) request; //统计⽂件数Integer fileCount = 0;//请求⾥key为File的元素（即⽂件元素）List<MultipartFile> list = multiRequest.getFiles("File");while (fileCount < list.size()) {MultipartFile file = list.get(fileCount);System.out.println(file.getName());System.out.println(file.getOriginalFilename());System.out.println(file.getSize());fileCount++;}System.out.println("共有" + fileCount + "个⽂件");} catch (Exception e) {e.printStackTrace();}return result;}}。
JAVA代码实现HTTP请求的常用方法
JAVA代码实现HTTP请求的常用方法在Java中，有多种方法可以实现HTTP请求。
下面将介绍几种常用的方法。
1. 使用Java内置的URL类和HttpURLConnection类：```javaimport java.io.BufferedReader;import java.io.InputStreamReader;public class HTTPRequestExamplepublic static void main(String[] args) throws ExceptionURL obj = new URL(url);HttpURLConnection con = (HttpURLConnection)obj.openConnection(;//设置请求方法con.setRequestMethod("GET");//添加请求头con.setRequestProperty("User-Agent", "Mozilla/5.0");//获取响应码int responseCode = con.getResponseCode(;System.out.println("Response Code: " + responseCode);BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream());String inputLine;StringBuffer response = new StringBuffer(;while ((inputLine = in.readLine() != null)response.append(inputLine);}in.close(;//打印响应内容System.out.println(response.toString();}```2. 使用第三方库HttpClient：```javapublic class HTTPRequestExamplepublic static void main(String[] args) throws Exception //创建GET请求//发送请求并获取响应//解析响应实体内容//打印响应内容System.out.println(response);// 关闭HttpClient连接}```3. 使用第三方库OkHttp：```javapublic class HTTPRequestExamplepublic static void main(String[] args) throws Exception// 创建OkHttpClient对象OkHttpClient okHttpClient = new OkHttpClient(;// 创建Request对象Request request = new Request.Builder.url(url).build(;//发送请求并获取响应Response response = okHttpClient.newCall(request).execute(;String responseBody = response.body(.string(;//打印响应内容System.out.println(responseBody);}```4. 使用第三方库RestTemplate（Spring框架的一部分）：```javaimport org.springframework.web.client.RestTemplate;public class HTTPRequestExamplepublic static void main(String[] args)// 创建RestTemplate对象RestTemplate restTemplate = new RestTemplate(;//发送GET请求，并获取响应ResponseEntity<String> responseEntity = restTemplate.getForEntity(url, String.class);//获取响应内容String response = responseEntity.getBody(;//打印响应内容System.out.println(response);}```这些方法提供了不同的方式来实现HTTP请求，使用Java内置的URL 类和HttpURLConnection类相对简单，但是需要自己处理底层连接和数据读取。
java发送带BasicAuth认证的httppost请求实例代码
java发送带BasicAuth认证的httppost请求实例代码构造http headerprivate static final String URL = "url";private static final String APP_KEY = "key";private static final String SECRET_KEY = "secret";/*** 构造Basic Auth认证头信息** @return*/private String getHeader() {String auth = APP_KEY + ":" + SECRET_KEY;byte[] encodedAuth = Base64.encodeBase64(auth.getBytes(Charset.forName("US-ASCII")));String authHeader = "Basic " + new String(encodedAuth);return authHeader;}⽅式⼀：private void send(JPushObject pushObject) {CloseableHttpClient client = HttpClients.createDefault();HttpPost post = new HttpPost(URL);System.out.println("要发送的数据" + JSON.toJSONString(pushObject));StringEntity myEntity = new StringEntity(JSON.toJSONString(pushObject), ContentType.APPLICATION_JSON); // 构造请求数据post.addHeader("Authorization", getHeader());post.setEntity(myEntity); // 设置请求体String responseContent = null; // 响应内容CloseableHttpResponse response = null;try {response = client.execute(post);System.out.println(JSON.toJSONString(response));if (response.getStatusLine().getStatusCode() == 200) {HttpEntity entity = response.getEntity();responseContent = EntityUtils.toString(entity, "UTF-8");}if (response != null)response.close();if (client != null)client.close();System.out.println("responseContent:" + responseContent);} catch(ClientProtocolException e) {e.printStackTrace();} catch(IOException e) {e.printStackTrace();}}⽅式⼆：引⽤到的jar： httpclient-4.5.jar; httpcore-4.4.1.jar; commons-logging-1.2.jar; common-codec-1.9.jarimport java.io.IOException;import org.apache.http.HttpEntity;import org.apache.http.HttpResponse;import org.apache.http.auth.AuthScope;import ernamePasswordCredentials;import org.apache.http.client.ClientProtocolException;import org.apache.http.client.CredentialsProvider;import org.apache.http.client.methods.HttpGet;import org.apache.http.impl.client.BasicCredentialsProvider;import org.apache.http.impl.client.CloseableHttpClient;import org.apache.http.impl.client.HttpClientBuilder;import org.apache.http.util.EntityUtils;public class HttpClientWithBasicAuth {public static void main(String args[]) {String host = "10.104.203.166";int port = 8080;String URI = "http://localhost/rest/channel/receipt";// 创建HttpClientBuilderhttpClientBuilder httpClientBuilder = HttpClientBuilder.create();// 设置BasicAuthCredentialsProvider provider = new BasicCredentialsProvider();// Create the authentication scopeAuthScope scope = new AuthScope(AuthScope.ANY_HOST, AuthScope.ANY_PORT, AuthScope.ANY_REALM);// Create credential pair，在此处填写⽤户名和密码UsernamePasswordCredentials credentials = new UsernamePasswordCredentials("root", "superuser");// Inject the credentialsprovider.setCredentials(scope, credentials);// Set the default credentials providerhttpClientBuilder.setDefaultCredentialsProvider(provider);// HttpClientCloseableHttpClient closeableHttpClient = httpClientBuilder.build();String result = "";HttpGet httpGet = null;HttpResponse httpResponse = null;HttpEntity entity = null;httpGet = new HttpGet("http://"+host+URI);try {httpResponse = closeableHttpClient.execute(httpGet);entity = httpResponse.getEntity();if( entity != null ){result = EntityUtils.toString(entity);}} catch (ClientProtocolException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}// 关闭连接closeableHttpClient.close();// System.out.println(result);}}⽅式三.import java.io.IOException;import net.sf.json.JSONObject;import er;import org.apache.http.HttpResponse;import org.apache.http.client.ClientProtocolException;import org.apache.http.client.HttpClient;import org.apache.http.client.methods.Ht @Testpublic void HttpPostData() {try {HttpClient httpclient = new DefaultHttpClient();HttpClient httpclient = new DefaultHttpClient();String uri = "http://localhost:8080/springMVC/user/getUserByName";HttpPost httppost = new HttpPost(uri);//添加http头信息httppost.addHeader("Authorization", "your token"); //认证tokenhttppost.addHeader("Content-Type", "application/json");httppost.addHeader("User-Agent", "imgfornote");JSONObject obj = new JSONObject();obj.put("name", "cwh");httppost.setEntity(new StringEntity(obj.toString()));HttpResponse response;response = httpclient.execute(httppost);//检验状态码，如果成功接收数据int code = response.getStatusLine().getStatusCode();System.out.println(code+"code");if (code == 200) {String rev = EntityUtils.toString(response.getEntity());//返回json格式： {"id": "","name": ""} obj= JSONObject.fromObject(rev);User user = (User)JSONObject.toBean(obj,User.class);System.out.println("返回数据==="+user.toString());}} catch (ClientProtocolException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} catch (Exception e) {e.printStackTrace();}}}。
java 通用请求头写法 -回复
java 通用请求头写法-回复Java通用请求头写法在Java开发中，我们经常需要发送HTTP请求到服务器端，并且在请求中设置一些通用的请求头。
通用的请求头可以包括用户身份验证、接受的数据格式、用户代理信息等。
本文将一步一步回答关于Java通用请求头写法的问题。
第一步：导入依赖在Java中，我们可以使用Apache HttpClient库来发送HTTP请求，并且设置请求头。
首先，我们需要在项目的构建文件中添加HttpClient 的依赖。
如果你正在使用Maven构建你的项目，可以在pom.xml文件中添加以下内容：xml<dependency><groupId>org.apache.httpcomponents</groupId><artifactId>httpclient</artifactId><version>4.5.13</version></dependency>如果你正在使用Gradle构建你的项目，可以在build.gradle文件中添加以下内容：groovyimplementation 'org.apache.httpcomponents:httpclient:4.5.13' 第二步：创建HttpClient实例在发送HTTP请求之前，我们首先需要创建一个HttpClient的实例。
HttpClient是Apache HttpClient库中的核心类，它用于执行HTTP请求。
下面是创建HttpClient实例的代码：javaCloseableHttpClient httpClient =HttpClientBuilder.create().build();第三步：创建Http请求在创建HttpClient实例之后，我们可以使用HttpClient的实例来创建一个Http请求。
Java发送http请求（get、post）的示例
Java发送http请求（get、post）的⽰例1.情景展⽰ java发送get请求、post请求（form表单、json数据）⾄另⼀服务器； 可设置HTTP请求头部信息，可以接收服务器返回cookie信息，可以上传⽂件等；2.代码实现所需jar包：httpcore-4.4.1.jar；httpclient-4.4.1.jar；httpmime-4.4.1.jar；epoint-utils-9.3.3.jarimport java.io.File;import java.io.IOException;import java.io.InputStream;import java.nio.charset.Charset;import java.security.GeneralSecurityException;import java.security.cert.CertificateException;import java.security.cert.X509Certificate;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import .ssl.HostnameVerifier;import .ssl.SSLContext;import .ssl.SSLSession;import org.apache.http.Header;import org.apache.http.HttpEntity;import org.apache.http.HttpResponse;import ValuePair;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.HttpDelete;import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;import org.apache.http.client.methods.HttpGet;import org.apache.http.client.methods.HttpPatch;import org.apache.http.client.methods.HttpPost;import org.apache.http.client.methods.HttpRequestBase;import org.apache.http.conn.ssl.SSLConnectionSocketFactory;import org.apache.http.conn.ssl.TrustStrategy;import org.apache.http.entity.ContentType;import org.apache.http.entity.StringEntity;import org.apache.http.entity.mime.MultipartEntityBuilder;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.impl.conn.PoolingHttpClientConnectionManager;import org.apache.http.message.BasicNameValuePair;import org.apache.http.ssl.SSLContextBuilder;import org.apache.http.util.EntityUtils;import com.epoint.core.utils.string.StringUtil;/*** HttpClient⼯具类，使⽤http-client包实现，原先的common-httpclient已经淘汰** @作者 ko* @version [版本号, 2017年10⽉18⽇]*/public class HttpUtil{private static PoolingHttpClientConnectionManager connMgr;private static RequestConfig requestConfig;private static final int MAX_TIMEOUT = 7000;/*** 直接以流返回*/public static final int RTN_TYPE_1 = 1;/*** 直接以string返回*/public static final int RTN_TYPE_2 = 2;/*** 以map返回，reslut:接⼝结果string;statusCode:http状态码*/public static final int RTN_TYPE_3 = 3;/*** 以map返回，reslut:接⼝结果string;statusCode:http状态码;cookie:response的cookie * cookie值键值对，格式 key1=value1;key2=value2;...*/public static final int RTN_TYPE_4 = 4;/*** 默认上传⽂件的⽂件流或file 的key Name*/private static final String DEFAULT_BINARYBODY_KEYNAME = "file";static {// 设置连接池connMgr = new PoolingHttpClientConnectionManager();// 设置连接池⼤⼩connMgr.setMaxTotal(100);connMgr.setDefaultMaxPerRoute(connMgr.getMaxTotal());// 在提交请求之前测试连接是否可⽤connMgr.setValidateAfterInactivity(1);RequestConfig.Builder configBuilder = RequestConfig.custom();// 设置连接超时configBuilder.setConnectTimeout(MAX_TIMEOUT);// 设置读取超时configBuilder.setSocketTimeout(MAX_TIMEOUT);// 设置从连接池获取连接实例的超时configBuilder.setConnectionRequestTimeout(MAX_TIMEOUT);requestConfig = configBuilder.build();}/*** 发送 GET请求** @param apiUrl* API接⼝URL* @return String 响应内容*/public static String doGet(String apiUrl) {return doHttp(apiUrl, null, "get", RTN_TYPE_2);}/*** 发送POST请求** @param apiUrl* API接⼝URL* @param params* K-V参数* @return String 响应内容*/public static String doPost(String apiUrl, Map<String, Object> params) {return doHttp(apiUrl, params, "post", RTN_TYPE_2);}/*** 发送POST请求** @param apiUrl* API接⼝URL* @param json* json参数* @return String 响应内容*/public static String doPostJson(String apiUrl, String json) {return doHttp(apiUrl, json, "post", RTN_TYPE_2);}/*** 发送 http 请求** @param apiUrl* API接⼝URL* @param params* {Map<String, Object> K-V形式、json字符串}* @param method* {null、或者post:POST请求、patch:PATCH请求、delete:DELETE请求、get:GET请求}* @param type* {HttpUtil.RTN_TYPE_1:请求返回stream(此时流需要在外部⼿动关闭);HttpUtil.* RTN_TYPE_2:string;HttpUtil.RTN_TYPE_3:返回⼀个map,map包含结果(* 结果是string形式)以及http状态码;HttpUtil.RTN_TYPE_4:返回⼀个map,map包含结果(* 结果是string形式), http状态码和cookie;其他情况返回string}* 如果结果是个map,key为:result,statusCode,cookie,分别返回结果* string,http状态码，cookie; cookie值键值对，格式* key1=value1;key2=value2;...* @return stream或 string 或 map*/public static <T> T doHttp(String apiUrl, Object params, String method, int type) {return doHttp(apiUrl, null, params, method, type);}/*** 发送 http 请求** @param apiUrl* API接⼝URL* @param headerMap* header信息Map<String, String>,可设置cookie* @param params* {Map<String, Object> K-V形式、json字符串}* @param method* {null、或者post:POST请求、patch:PATCH请求、delete:DELETE请求、get:GET请求}* @param type* {HttpUtil.RTN_TYPE_1:请求返回stream(此时流需要在外部⼿动关闭);HttpUtil.* RTN_TYPE_2:string;HttpUtil.RTN_TYPE_3:返回⼀个map,map包含结果(* 结果是string形式)以及http状态码;HttpUtil.RTN_TYPE_4:返回⼀个map,map包含结果(* 结果是string形式), http状态码和cookie;其他情况返回string}* 如果结果是个map,key为:result,statusCode,cookie,分别返回结果* string,http状态码，cookie; cookie值键值对，格式* key1=value1;key2=value2;...* @return stream或 string 或 map*/public static <T> T doHttp(String apiUrl, Map<String, String> headerMap, Object params, String method, int type) { CloseableHttpClient httpClient = null;if (isSSL(apiUrl)) {httpClient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory()).setConnectionManager(connMgr).setDefaultRequestConfig(requestConfig).build();}else {httpClient = HttpClients.createDefault();}return doHttp(httpClient, apiUrl, headerMap, params, method, type);}/*** 发送 http 请求** @param httpClient* httpclient对象由外部传⼊，⽤户需要保持登录状态等情况此时如果要ssl,那么要在外部加⼊ssl特性* httpClient =* HttpClients.custom().setSSLSocketFactory(HttpUtil.* createSSLConnSocketFactory())* .setConnectionManager(HttpUtil.getConnMgr()).* setDefaultRequestConfig(HttpUtil..getRequestConfig()).build();* @param apiUrl* API接⼝URL* @param headerMap* header信息Map<String, String>,可设置cookie** @param params* {Map<String, Object> K-V形式、json字符串}* @param method* {null、或者post:POST请求、patch:PATCH请求、delete:DELETE请求、get:GET请求}* @param type* {HttpUtil.RTN_TYPE_1:请求返回stream(此时流需要在外部⼿动关闭);HttpUtil.* RTN_TYPE_2:string;HttpUtil.RTN_TYPE_3:返回⼀个map,map包含结果(* 结果是string形式)以及http状态码;HttpUtil.RTN_TYPE_4:返回⼀个map,map包含结果(* 结果是string形式), http状态码和cookie;其他情况返回string}* 如果结果是个map,key为:result,statusCode,cookie,分别返回结果* string,http状态码，cookie; cookie值键值对，格式* key1=value1;key2=value2;...* @return stream或 string 或 map*/@SuppressWarnings("unchecked")public static <T> T doHttp(CloseableHttpClient httpClient, String apiUrl, Map<String, String> headerMap, Object params, String method, int type) {HttpRequestBase httpPost = null;if (StringUtil.isNotBlank(method)) {if ("patch".equalsIgnoreCase(method)) {httpPost = new HttpPatch(apiUrl);}else if ("delete".equalsIgnoreCase(method)) {httpPost = new HttpDelete(apiUrl);}else if ("get".equalsIgnoreCase(method)) {httpPost = new HttpGet(apiUrl);}else if ("post".equalsIgnoreCase(method)) {httpPost = new HttpPost(apiUrl);}}else {httpPost = new HttpPost(apiUrl);}CloseableHttpResponse response = null;try {// 设置header信息if (headerMap != null && !headerMap.isEmpty()) {for (Map.Entry<String, String> entry : headerMap.entrySet()) {httpPost.addHeader(entry.getKey(), entry.getValue());}}if (isSSL(apiUrl)) {httpPost.setConfig(requestConfig);}// 参数不为null、要处理参数if (params != null) {// get请求拼接在url后⾯if (httpPost instanceof HttpGet) {StringBuffer param = new StringBuffer();if (params instanceof Map) {Map<String, Object> paramsConvert = (Map<String, Object>) params;int i = 0;for (String key : paramsConvert.keySet()) {if (i == 0)param.append("?");elseparam.append("&");param.append(key).append("=").append(paramsConvert.get(key));i++;}}else {param.append("?" + params.toString());}apiUrl += param;}// delete请求暂不处理else if (!(httpPost instanceof HttpDelete)) {// K-V形式if (params instanceof Map) {Map<String, Object> paramsConvert = (Map<String, Object>) params;List<NameValuePair> pairList = new ArrayList<>(paramsConvert.size());for (Map.Entry<String, Object> entry : paramsConvert.entrySet()) {NameValuePair pair = new BasicNameValuePair(entry.getKey(),entry.getValue() == null ? "" : entry.getValue().toString());pairList.add(pair);}((HttpEntityEnclosingRequestBase) httpPost).setEntity(new UrlEncodedFormEntity(pairList, Charset.forName("UTF-8")));}// json格式else {StringEntity stringEntity = new StringEntity(params.toString(), "UTF-8");stringEntity.setContentEncoding("UTF-8");stringEntity.setContentType("application/json");((HttpEntityEnclosingRequestBase) httpPost).setEntity(stringEntity);}}}response = httpClient.execute(httpPost);// int statusCode = response.getStatusLine().getStatusCode();// if (statusCode != HttpStatus.SC_OK) {// return null;// }HttpEntity entity = response.getEntity();if (entity != null) {if (type == RTN_TYPE_1) {return (T) entity.getContent();}else if (RTN_TYPE_2 == type) {return (T) EntityUtils.toString(entity, "UTF-8");}else if (RTN_TYPE_3 == type || RTN_TYPE_4 == type) {Map<String, String> rtnMap = new HashMap<String, String>();rtnMap.put("result", EntityUtils.toString(entity, "UTF-8"));rtnMap.put("statusCode", response.getStatusLine().getStatusCode() + "");if (RTN_TYPE_4 == type) {rtnMap.put("cookie", getCookie(response));}return (T) rtnMap;}else {return (T) EntityUtils.toString(entity, "UTF-8");}}}catch (Exception e) {e.printStackTrace();}finally {if (response != null && type != RTN_TYPE_1) {try {EntityUtils.consume(response.getEntity());}catch (IOException e) {e.printStackTrace();}}}return null;}/*** 上传附件(post形式)** @param url* 请求地址* @param headerMap* header参数map Map<String, String>* @param paramMap* 额外的参数map,Map<String, String>* @param file* 可以选择本地⽂件上传；如果传了file，⼜传了fileName，那么⽂件名以fileName为准，否则是file的⽂件名 * @param fileName* 以流传输时，必须指定⽂件名* @param ssl* 是否需要ssl* @return result,返回上传结果，如果接⼝没有返回值，则为状态码*/public static String upload(String url, Map<String, String> headerMap, Map<String, String> paramMap, File file,String fileName, boolean ssl) {return upload(url, headerMap, paramMap, file, null, fileName, ssl);}/*** 上传附件(post形式)** @param url* 请求地址* @param headerMap* header参数map Map<String, String>* @param paramMap* 额外的参数map,Map<String, String>* @param in* ⽂件流* @param fileName* 以流传输时，必须指定⽂件名* @param ssl* 是否需要ssl* @return result,返回上传结果，如果接⼝没有返回值，则为状态码*/public static String upload(String url, Map<String, String> headerMap, Map<String, String> paramMap, InputStream in, String fileName, boolean ssl) {return upload(url, headerMap, paramMap, null, in, fileName, ssl);}/*** 上传附件(post形式)** @param httpClient* 外部传⼊httpClient* @param url* 请求地址* @param headerMap* header参数map Map<String, String>* @param paramMap* 额外的参数map,Map<String, String>* @param file* 可以选择本地⽂件上传；如果传了file，⼜传了fileName，那么⽂件名以fileName为准，否则是file的⽂件名* @param fileName* 以流传输时，必须指定⽂件名* @param ssl* 是否需要ssl* @return result,返回上传结果，如果接⼝没有返回值，则为状态码*/public static String upload(CloseableHttpClient httpClient, String url, Map<String, String> headerMap,Map<String, String> paramMap, File file, String fileName, boolean ssl) {return upload(httpClient, url, headerMap, paramMap, file, null, fileName, ssl);}/*** 上传附件(post形式)** @param httpClient* 外部传⼊httpClient* @param url* 请求地址* @param headerMap* header参数map Map<String, String>* @param paramMap* 额外的参数map,Map<String, String>* @param in* ⽂件流* @param fileName* 以流传输时，必须指定⽂件名* @param ssl* 是否需要ssl* @return result,返回上传结果，如果接⼝没有返回值，则为状态码*/public static String upload(CloseableHttpClient httpClient, String url, Map<String, String> headerMap,Map<String, String> paramMap, InputStream in, String fileName, boolean ssl) {return upload(httpClient, url, headerMap, paramMap, null, in, fileName, ssl);}/*** 上传附件(post形式)** @param url* 请求地址* @param headerMap* header参数map Map<String, String>* @param paramMap* 额外的参数map,Map<String, String>* @param file* 可以选择本地⽂件上传，file,in互斥；如果传了file，⼜传了fileName，那么⽂件名以fileName为准，否则* 是file的⽂件名* @param in* ⽂件流* @param fileName* 以流传输时，必须指定⽂件名* @param ssl* 是否需要ssl* @return result,返回上传结果，如果接⼝没有返回值，则为状态码*/private static String upload(String url, Map<String, String> headerMap, Map<String, String> paramMap, File file,InputStream in, String fileName, boolean ssl) {CloseableHttpClient httpClient = null;if (ssl) {httpClient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory()).setConnectionManager(connMgr).setDefaultRequestConfig(requestConfig).build();}else {httpClient = HttpClients.createDefault();}return upload(httpClient, url, headerMap, paramMap, file, in, fileName, ssl);}/*** 上传附件(post形式)** @param httpClient* 外部传⼊httpClient* @param url* 请求地址* @param headerMap* header参数map Map<String, String>* @param paramMap* 额外的参数map,Map<String, String>* @param file* 可以选择本地⽂件上传，file,in互斥；如果传了file，⼜传了fileName，那么⽂件名以fileName为准，否则* 是file的⽂件名* @param in* ⽂件流* @param fileName* 以流传输时，必须指定⽂件名* @param ssl* 是否需要ssl* @return result,返回上传结果，如果接⼝没有返回值，则为状态码*/private static String upload(CloseableHttpClient httpClient, String url, Map<String, String> headerMap,Map<String, String> paramMap, File file, InputStream in, String fileName, boolean ssl) {String result = "";CloseableHttpResponse response = null;try {HttpPost httpPost = new HttpPost(url);// 设置header信息if (headerMap != null && !headerMap.isEmpty()) {for (Map.Entry<String, String> entry : headerMap.entrySet()) {httpPost.addHeader(entry.getKey(), entry.getValue());}}if (ssl) {httpPost.setConfig(requestConfig);}MultipartEntityBuilder builder = MultipartEntityBuilder.create();// 选择以file形式上传if (file != null && file.exists()) {if (StringUtil.isNotBlank(fileName)) {builder.addBinaryBody(DEFAULT_BINARYBODY_KEYNAME, file, ContentType.DEFAULT_BINARY, fileName); }else {builder.addBinaryBody(DEFAULT_BINARYBODY_KEYNAME, file);}}// 以流上传else if (in != null && StringUtil.isNotBlank(fileName)) {builder.addBinaryBody(DEFAULT_BINARYBODY_KEYNAME, in, ContentType.DEFAULT_BINARY, fileName);}if (paramMap != null && !paramMap.isEmpty()) {for (Map.Entry<String, String> entry : paramMap.entrySet()) {builder.addPart(entry.getKey(), new StringBody(entry.getValue(), ContentType.TEXT_PLAIN));}}HttpEntity reqEntity = builder.build();httpPost.setEntity(reqEntity);response = httpClient.execute(httpPost);HttpEntity entity = response.getEntity();if (entity != null) {result = EntityUtils.toString(entity, "UTF-8");}else {result = response.getStatusLine().getStatusCode() + "";}}catch (Exception e) {e.printStackTrace();}finally {if (response != null) {try {EntityUtils.consume(response.getEntity());}catch (IOException e) {e.printStackTrace();}}}return result;}private static String getCookie(HttpResponse httpResponse) {Map<String, String> cookieMap = new HashMap<String, String>(64);Header headers[] = httpResponse.getHeaders("Set-Cookie");if (headers == null || headers.length == 0) {return null;}String cookie = "";for (int i = 0; i < headers.length; i++) {cookie += headers[i].getValue();if (i != headers.length - 1) {cookie += ";";}}String cookies[] = cookie.split(";");for (String c : cookies) {c = c.trim();if (cookieMap.containsKey(c.split("=")[0])) {cookieMap.remove(c.split("=")[0]);}cookieMap.put(c.split("=")[0],c.split("=").length == 1 ? "" : (c.split("=").length == 2 ? c.split("=")[1] : c.split("=", 2)[1]));}String cookiesTmp = "";for (String key : cookieMap.keySet()) {cookiesTmp += key + "=" + cookieMap.get(key) + ";";}return cookiesTmp.substring(0, cookiesTmp.length() - 2);}/*** 创建SSL安全连接** @return*/public static SSLConnectionSocketFactory createSSLConnSocketFactory() {SSLConnectionSocketFactory sslsf = null;try {SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy(){public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException { return true;}}).build();sslsf = new SSLConnectionSocketFactory(sslContext, new HostnameVerifier(){@Overridepublic boolean verify(String arg0, SSLSession arg1) {return true;}});}catch (GeneralSecurityException e) {e.printStackTrace();}return sslsf;}public static PoolingHttpClientConnectionManager getConnMgr() {return connMgr;}public static RequestConfig getRequestConfig() {return requestConfig;}private static boolean isSSL(String apiUrl) {if (apiUrl.indexOf("https") != -1 ) {return true;}else {return false;}}}以上就是Java 发送http请求（get、post）的⽰例的详细内容，更多关于Java 发送http请求的资料请关注其它相关⽂章！。
Java如何发起http请求的实现（GETPOST）
Java如何发起http请求的实现（GETPOST）前⾔在未来做项⽬中，⼀些功能模块可能会采⽤不同的语⾔进⾏编写。
这就需要http请求进⾏模块的调⽤。
那么下⾯，我将以Java 为例，详细说明如何发起http请求。
⼀、GET与POSTGET和POST是HTTP的两个常⽤⽅法。
GET指从指定的服务器中获取数据POST指提交数据给指定的服务器处理1.GET⽅法GET请求能够被缓存GET请求会保存在浏览器的浏览记录中以GET请求的URL能够保存为浏览器书签GET请求有长度限制GET请求主要⽤以获取数据2.POST⽅法使⽤POST⽅法，需要传递的参数在POST信息中单独存在，和HTTP请求⼀起发送到服务器。
例如：POST /submit HTTP/1.1Host 121.41.111.94name=zxy&age=21特点：POST请求不能被缓存下来POST请求不会保存在浏览器浏览记录中以POST请求的URL⽆法保存为浏览器书签POST请求没有长度限制实现代码下⾯将Java发送GET/POST请求封装成HttpRequest类，可以直接使⽤。
HttpRequest类代码如下：import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.io.PrintWriter;import .URL;import .URLConnection;import java.util.List;import java.util.Map;public class HttpRequest {/*** 向指定URL发送GET⽅法的请求** @param url* 发送请求的URL* @param param* 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
Java发送httpgetpost请求，调用接口方法
Java发送httpgetpost请求，调⽤接⼝⽅法由于项⽬中要⽤，所以找了⼀些资料，整理下来。
例1：使⽤ HttpClient （commons-httpclient-3.0.jar1import java.io.ByteArrayInputStream;2import java.io.ByteArrayOutputStream;3import java.io.IOException;4import java.io.InputStream;56import mons.httpclient.HttpClient;7import mons.httpclient.methods.InputStreamRequestEntity;8import mons.httpclient.methods.PostMethod;9import mons.httpclient.methods.RequestEntity;1011public class HttpTool {1213/**14 * 发送post请求15 *16 * @param params17 * 参数18 * @param requestUrl19 * 请求地址20 * @param authorization21 * 授权书22 * @return返回结果23 * @throws IOException24*/25public static String sendPost(String params, String requestUrl,26 String authorization) throws IOException {2728byte[] requestBytes = params.getBytes("utf-8"); // 将参数转为⼆进制流29 HttpClient httpClient = new HttpClient();// 客户端实例化30 PostMethod postMethod = new PostMethod(requestUrl);31//设置请求头Authorization32 postMethod.setRequestHeader("Authorization", "Basic " + authorization);33// 设置请求头 Content-Type34 postMethod.setRequestHeader("Content-Type", "application/json");35 InputStream inputStream = new ByteArrayInputStream(requestBytes, 0,36 requestBytes.length);37 RequestEntity requestEntity = new InputStreamRequestEntity(inputStream,38 requestBytes.length, "application/json; charset=utf-8"); // 请求体39 postMethod.setRequestEntity(requestEntity);40 httpClient.executeMethod(postMethod);// 执⾏请求41 InputStream soapResponseStream = postMethod.getResponseBodyAsStream();// 获取返回的流42byte[] datas = null;43try {44 datas = readInputStream(soapResponseStream);// 从输⼊流中读取数据45 } catch (Exception e) {46 e.printStackTrace();47 }48 String result = new String(datas, "UTF-8");// 将⼆进制流转为String49// 打印返回结果50// System.out.println(result);5152return result;5354 }5556/**57 * 从输⼊流中读取数据58 *59 * @param inStream60 * @return61 * @throws Exception62*/63public static byte[] readInputStream(InputStream inStream) throws Exception {64 ByteArrayOutputStream outStream = new ByteArrayOutputStream();65byte[] buffer = new byte[1024];66int len = 0;67while ((len = inStream.read(buffer)) != -1) {68 outStream.write(buffer, 0, len);69 }70byte[] data = outStream.toByteArray();71 outStream.close();72 inStream.close();73return data;74 }75 }例2：1import java.io.BufferedReader;2import java.io.IOException;3import java.io.InputStream;4import java.io.InputStreamReader;5import java.io.OutputStreamWriter;6import java.io.UnsupportedEncodingException;7import .HttpURLConnection;8import .InetSocketAddress;9import .Proxy;10import .URL;11import .URLConnection;12import java.util.List;13import java.util.Map;1415/**16 * Http请求⼯具类17*/18public class HttpRequestUtil {19static boolean proxySet = false;20static String proxyHost = "127.0.0.1";21static int proxyPort = 8087;22/**23 * 编码24 * @param source25 * @return26*/27public static String urlEncode(String source,String encode) {28 String result = source;29try {30 result = .URLEncoder.encode(source,encode);31 } catch (UnsupportedEncodingException e) {32 e.printStackTrace();33return "0";34 }35return result;36 }37public static String urlEncodeGBK(String source) {38 String result = source;39try {40 result = .URLEncoder.encode(source,"GBK");41 } catch (UnsupportedEncodingException e) {42 e.printStackTrace();43return "0";44 }45return result;46 }47/**48 * 发起http请求获取返回结果49 * @param req_url 请求地址50 * @return51*/52public static String httpRequest(String req_url) {53 StringBuffer buffer = new StringBuffer();54try {55 URL url = new URL(req_url);56 HttpURLConnection httpUrlConn = (HttpURLConnection) url.openConnection();5758 httpUrlConn.setDoOutput(false);59 httpUrlConn.setDoInput(true);60 httpUrlConn.setUseCaches(false);6162 httpUrlConn.setRequestMethod("GET");63 httpUrlConn.connect();6465// 将返回的输⼊流转换成字符串66 InputStream inputStream = httpUrlConn.getInputStream();67 InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");68 BufferedReader bufferedReader = new BufferedReader(inputStreamReader);6970 String str = null;71while ((str = bufferedReader.readLine()) != null) {72 buffer.append(str);73 }74 bufferedReader.close();75 inputStreamReader.close();76// 释放资源77 inputStream.close();78 inputStream = null;79 httpUrlConn.disconnect();8081 } catch (Exception e) {82 System.out.println(e.getStackTrace());83 }84return buffer.toString();85 }8687/**88 * 发送http请求取得返回的输⼊流89 * @param requestUrl 请求地址90 * @return InputStream91*/92public static InputStream httpRequestIO(String requestUrl) {93 InputStream inputStream = null;94try {95 URL url = new URL(requestUrl);96 HttpURLConnection httpUrlConn = (HttpURLConnection) url.openConnection();97 httpUrlConn.setDoInput(true);98 httpUrlConn.setRequestMethod("GET");99 httpUrlConn.connect();100// 获得返回的输⼊流101 inputStream = httpUrlConn.getInputStream();102 } catch (Exception e) {103 e.printStackTrace();104 }105return inputStream;106 }107108109/**110 * 向指定URL发送GET⽅法的请求111 *112 * @param url113 * 发送请求的URL114 * @param param115 * 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Java实现发送Http请求JDK中提供了一些对无状态协议请求（HTTP）的支持：首先让我们先构建一个请求类（HttpRequester）。
该类封装了JAVA实现简单请求的代码，如下：import java.io.BufferedReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import .HttpURLConnection;import .URL;import java.nio.charset.Charset;import java.util.Map;import java.util.Vector;/*** HTTP请求对象** @author YYmmiinngg*/public class HttpRequester {private String defaultContentEncoding;public HttpRequester() {this.defaultContentEncoding = Charset.defaultCharset().name();}/*** 发送GET请求** @param urlString* URL地址* @return 响应对象* @throws IOException*/public HttpRespons sendGet(String urlString) throws IOException { return this.send(urlString, "GET", null, null);}/*** 发送GET请求** @param urlString* URL地址* @param params* 参数集合* @return 响应对象* @throws IOException*/public HttpRespons sendGet(String urlString, Map<String, String> params) throws IOException {return this.send(urlString, "GET", params, null);}/*** 发送GET请求** @param urlString* URL地址* @param params* 参数集合* @param propertys* 请求属性* @return 响应对象* @throws IOException*/public HttpRespons sendGet(String urlString, Map<String, String> params, Map<String, String> propertys) throws IOException { return this.send(urlString, "GET", params, propertys);}/*** 发送POST请求** @param urlString* URL地址* @return 响应对象* @throws IOException*/public HttpRespons sendPost(String urlString) throws IOException { return this.send(urlString, "POST", null, null);}/*** 发送POST请求** @param urlString* URL地址* @param params* 参数集合* @return 响应对象* @throws IOException*/public HttpRespons sendPost(String urlString, Map<String, String> params) throws IOException {return this.send(urlString, "POST", params, null);}/*** 发送POST请求** @param urlString* URL地址* @param params* 参数集合* @param propertys* 请求属性* @return 响应对象* @throws IOException*/public HttpRespons sendPost(String urlString, Map<String, String> params, Map<String, String> propertys) throws IOException { return this.send(urlString, "POST", params, propertys);}/*** 发送HTTP请求** @param urlString* @return 响映对象* @throws IOException*/private HttpRespons send(String urlString, String method,Map<String, String> parameters, Map<String, String> propertys)throws IOException {HttpURLConnection urlConnection = null;if (method.equalsIgnoreCase("GET") && parameters != null) {StringBuffer param = new StringBuffer();int i = 0;for (String key : parameters.keySet()) {if (i == 0)param.append("?");elseparam.append("&");param.append(key).append("=").append(parameters.get(key));i++;}urlString += param;}URL url = new URL(urlString);urlConnection = (HttpURLConnection) url.openConnection();urlConnection.setRequestMethod(method);urlConnection.setDoOutput(true);urlConnection.setDoInput(true);urlConnection.setUseCaches(false);if (propertys != null)for (String key : propertys.keySet()) {urlConnection.addRequestProperty(key, propertys.get(key));}if (method.equalsIgnoreCase("POST") && parameters != null) { StringBuffer param = new StringBuffer();for (String key : parameters.keySet()) {param.append("&");param.append(key).append("=").append(parameters.get(key));}urlConnection.getOutputStream().write(param.toString().getBytes());urlConnection.getOutputStream().flush();urlConnection.getOutputStream().close();}return this.makeContent(urlString, urlConnection);}/*** 得到响应对象** @param urlConnection* @return 响应对象* @throws IOException*/private HttpRespons makeContent(String urlString,HttpURLConnection urlConnection) throws IOException { HttpRespons httpResponser = new HttpRespons();try {InputStream in = urlConnection.getInputStream();BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(in));httpResponser.contentCollection = new Vector<String>(); StringBuffer temp = new StringBuffer();String line = bufferedReader.readLine();while (line != null) {httpResponser.contentCollection.add(line);temp.append(line).append("\r\n");line = bufferedReader.readLine();}bufferedReader.close();String ecod = urlConnection.getContentEncoding();if (ecod == null)ecod = this.defaultContentEncoding;httpResponser.urlString = urlString;httpResponser.defaultPort = urlConnection.getURL().getDefaultPort(); httpResponser.file = urlConnection.getURL().getFile(); httpResponser.host = urlConnection.getURL().getHost(); httpResponser.path = urlConnection.getURL().getPath(); httpResponser.port = urlConnection.getURL().getPort();httpResponser.protocol = urlConnection.getURL().getProtocol();httpResponser.query = urlConnection.getURL().getQuery();httpResponser.ref = urlConnection.getURL().getRef();erInfo = urlConnection.getURL().getUserInfo();httpResponser.content = new String(temp.toString().getBytes(), ecod);httpResponser.contentEncoding = ecod;httpResponser.code = urlConnection.getResponseCode();httpResponser.message = urlConnection.getResponseMessage();httpResponser.contentType = urlConnection.getContentType();httpResponser.method = urlConnection.getRequestMethod();httpResponser.connectTimeout = urlConnection.getConnectTimeout();httpResponser.readTimeout = urlConnection.getReadTimeout();return httpResponser;} catch (IOException e) {throw e;} finally {if (urlConnection != null)urlConnection.disconnect();}}/*** 默认的响应字符集*/public String getDefaultContentEncoding() {return this.defaultContentEncoding;}/*** 设置默认的响应字符集*/public void setDefaultContentEncoding(String defaultContentEncoding) { this.defaultContentEncoding = defaultContentEncoding;}}其次我们来看看响应对象（HttpRespons）。