java发送http的get、post请求
java打印日志get请求和post请求的参数
【Java打印日志:深入探讨get请求和post请求的参数】在Java开发中,打印日志是非常重要的一环,它可以帮助开发者快速定位问题,特别是在处理HTTP请求的过程中。
本文将围绕着Java打印日志的主题展开,重点探讨get请求和post请求的参数处理。
通过分析和比较两种请求方式,帮助读者更深入地理解请求参数的处理过程,并从中获取有价值的经验和技巧。
## 1. 请求参数的处理在处理HTTP请求时,无论是get还是post请求,参数的处理都是至关重要的。
对于get请求,参数通常会以key-value对的形式出现在URL中,而对于post请求,参数则通常放在请求体中。
为了更好地理解这一过程,让我们分别来看一下get请求和post请求中参数的处理方法。
### 1.1 GET请求参数处理对于get请求,参数通常会出现在URL中,形式如下:``````在Java中,我们可以通过HttpServletRequest对象来获取get请求中的参数,并进行处理。
一般来说,我们可以通过以下方式来获取参数:```javaString param1 = request.getParameter("param1");String param2 = request.getParameter("param2");```### 1.2 POST请求参数处理相比get请求,post请求的参数处理稍有不同。
参数通常会放在请求体中,而不是直接暴露在URL中。
在Java中,我们可以通过HttpServletRequest对象同样来获取post请求中的参数:```javaBufferedReader reader = request.getReader(); StringBuilder sb = new StringBuilder();String line;while ((line = reader.readLine()) != null) {sb.append(line);}String requestBody = sb.toString();```通过上述代码,我们可以获取post请求中的请求体,并对参数进行处理。
java post请求传递参数
java post请求传递参数在Java中进行HTTP请求时,我们通常需要传递参数。
其中,POST 请求是常见的一种方式,下面介绍如何通过POST请求传递参数。
1. 使用Java原生URLConnection发送POST请求Java原生提供了URLConnection类,可以用于发送HTTP请求。
通过URLConnection发送POST请求时,需要设置请求方法为'POST',并设置请求参数。
示例代码如下:```javaURL url = new URL('http://localhost:8080/api');HttpURLConnection connection = (HttpURLConnection)url.openConnection();connection.setRequestMethod('POST');connection.setDoOutput(true);// 设置请求参数String data = 'param1=value1¶m2=value2';OutputStream outputStream =connection.getOutputStream();outputStream.write(data.getBytes('UTF-8'));outputStream.flush();outputStream.close();// 发送请求并获取响应InputStream inputStream = connection.getInputStream();BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, 'UTF-8'));String line;while ((line = reader.readLine()) != null) {System.out.println(line);}reader.close();inputStream.close();connection.disconnect();```2. 使用第三方库OkHttp发送POST请求OkHttp是一款常用的HTTP请求库,可以用于发送POST请求。
JAVA-用HttpClient来模拟浏览器GET,POST
一般的情况下我们都是使用IE或者Navigator浏览器来访问一个WEB服务器,用来浏览页面查看信息或者提交一些数据等等。
所访问的这些页面有的仅仅是一些普通的页面,有的需要用户登录后方可使用,或者需要认证以及是一些通过加密方式传输,例如HTTPS。
目前我们使用的浏览器处理这些情况都不会构成问题。
不过你可能在某些时候需要通过程序来访问这样的一些页面,比如从别人的网页中“偷”一些数据;利用某些站点提供的页面来完成某种功能,例如说我们想知道某个手机号码的归属地而我们自己又没有这样的数据,因此只好借助其他公司已有的网站来完成这个功能,这个时候我们需要向网页提交手机号码并从返回的页面中解析出我们想要的数据来。
如果对方仅仅是一个很简单的页面,那我们的程序会很简单,本文也就没有必要大张旗鼓的在这里浪费口舌。
但是考虑到一些服务授权的问题,很多公司提供的页面往往并不是可以通过一个简单的URL就可以访问的,而必须经过注册然后登录后方可使用提供服务的页面,这个时候就涉及到COOKIE问题的处理。
我们知道目前流行的动态网页技术例如ASP、JSP无不是通过COOKIE来处理会话信息的。
为了使我们的程序能使用别人所提供的服务页面,就要求程序首先登录后再访问服务页面,这过程就需要自行处理cookie,想想当你用.HttpURLConnection来完成这些功能时是多么恐怖的事情啊!况且这仅仅是我们所说的顽固的WEB服务器中的一个很常见的“顽固”!再有如通过HTTP来上传文件呢?不需要头疼,这些问题有了“它”就很容易解决了!我们不可能列举所有可能的顽固,我们会针对几种最常见的问题进行处理。
当然了,正如前面说到的,如果我们自己使用.HttpURLConnection来搞定这些问题是很恐怖的事情,因此在开始之前我们先要介绍一下一个开放源码的项目,这个项目就是Apache开源组织中的httpclient,它隶属于Jakarta的commons项目,目前的版本是2.0RC2。
javahttpput请求方式_使用HttpClient发送GETPOSTPUTDe
javahttpput请求方式_使用HttpClient发送GETPOSTPUTDe在Java中,我们可以使用HttpClient库来发送HTTP请求,包括GET、POST、PUT、DELETE等请求方式。
下面是使用HttpClient发送这些请求的示例代码。
1.发送GET请求:```javapublic class HttpGetExamplepublic static void main(String[] args) throws Exceptionint statusCode = response.getStatusLine(.getStatusCode(;System.out.println("Status Code: " + statusCode);//处理响应数据//...}```2.发送POST请求:```javapublic class HttpPostExamplepublic static void main(String[] args) throws Exception//设置请求体StringEntity requestBody = new StringEntity("request body", "UTF-8");int statusCode = response.getStatusLine(.getStatusCode(;System.out.println("Status Code: " + statusCode);//处理响应数据//...}```3.发送PUT请求:```javapublic class HttpPutExamplepublic static void main(String[] args) throws Exception//设置请求体StringEntity requestBody = new StringEntity("request body", "UTF-8");int statusCode = response.getStatusLine(.getStatusCode(;System.out.println("Status Code: " + statusCode);//处理响应数据//...}```4.发送DELETE请求:```javapublic class HttpDeleteExamplepublic static void main(String[] args) throws Exceptionint statusCode = response.getStatusLine(.getStatusCode(;System.out.println("Status Code: " + statusCode);//处理响应数据//...}```以上代码示例了如何使用HttpClient库发送GET、POST、PUT、DELETE请求,并处理响应数据。
get和post参数传递方式
get和post参数传递方式“GET和POST参数传递方式”是指通过HTTP协议传递参数的两种常用方式。
在网络开发中,我们经常需要将参数传递给服务器端处理,以便进行相应的操作。
本文将以GET和POST参数传递方式为主题,详细介绍这两种方法的使用场景、优缺点以及具体实现步骤等内容,希望能帮助读者更好地理解和运用这两种传参方式。
一、GET和POST参数传递方式的概念及区别GET和POST是HTTP协议中的两种常用HTTP请求方法,用于从客户端向服务器发送请求。
它们的主要区别在于参数的传递方式以及适用场景。
1. GET方式:通过URL的查询字符串传递参数,参数会附加在URL后面,形如“2. POST方式:通过请求体传递参数,参数不会出现在URL中,而是通过请求头的Content-Type字段指定参数的格式(如application/x-www-form-urlencoded或multipart/form-data)。
POST请求适合传递大量参数以及需要保密性的数据,如表单数据、文件上传等。
二、GET参数传递方式的实现步骤及示例GET参数传递方式相对简单,一般适用于只传递少量参数的场景。
其实现步骤如下:1. 构造URL:需要将参数以键值对的形式添加到URL的查询字符串中。
例如,我们要传递name和age两个参数,可以构造URL:“2. 发送请求:客户端向服务器发送GET请求,将参数附加在URL后面。
服务器端通过解析URL中的查询字符串,获取参数并进行相应的处理。
3. 接收参数:服务器端解析URL,获取参数的值。
具体的实现方式根据使用的编程语言和框架而有所不同。
下面以Python和Flask框架为例,演示GET参数传递方式的实现:pythonfrom flask import Flask, requestapp = Flask(__name__)@app.route('/page', methods=['GET'])def handle_page():name = request.args.get('name')age = request.args.get('age')# 在这里对接收到的参数进行相应的处理return f"Hello, {name}! You are {age} years old."if __name__ == '__main__':app.run()在上述示例中,我们使用Flask框架搭建了一个简单的Web应用。
java中的post的方法
java中的post的方法在Java中,HTTP POST方法用于向指定的URL提交数据。
它是用来向服务器提交数据,并在服务器上创建新的资源的一种请求方法。
在Java中,我们可以使用不同的方式来实现HTTP POST请求,包括使用原生的Java API、使用第三方库或框架等。
下面我们将介绍在Java中实现HTTP POST请求的一些常用方法。
1. 使用原生的Java API实现HTTP POST请求在Java中,我们可以使用原生的Java API来实现HTTP POST请求。
下面是一个简单的例子:javaimport java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.io.OutputStream;import .HttpURLConnection;import .URL;import java.nio.charset.StandardCharsets;public class HttpPostExample {public static void main(String[] args) throws IOException { String url = "String data = "param1=value1¶m2=value2";byte[] postData = data.getBytes(StandardCharsets.UTF_8);int postDataLength = postData.length;URL obj = new URL(url);HttpURLConnection con = (HttpURLConnection)obj.openConnection();con.setDoOutput(true);con.setRequestMethod("POST");con.setRequestProperty("Content-Type","application/x-www-form-urlencoded");con.setRequestProperty("Content-Length",Integer.toString(postDataLength));try (OutputStream os = con.getOutputStream()) {os.write(postData);}StringBuilder response = new StringBuilder();try (BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()))) {String inputLine;while ((inputLine = in.readLine()) != null) {response.append(inputLine);}}System.out.println(response.toString());}}在上面的例子中,我们使用了`HttpURLConnection`来发送HTTP POST请求。
HTTP请求(GET与POST区别)和响应(get是从服务器上获取数据,post是向服务器。。。
HTTP请求(GET与POST区别)和响应(get是从服务器上获取数据,post是向服务器。
HTTP有两部分组成:请求与响应,下⾯分别整理。
⼀.HTTP请求1.HTTP请求格式:<request line><headers><blank line>[<request-body>]在HTTP请求中,第⼀⾏必须是⼀个请求⾏(request line),⽤来说明请求类型、要访问的资源以及使⽤的HTTP版本。
紧接着是⼀个⾸部(header)⼩节,⽤来说明服务器要使⽤的附加信息。
在⾸部之后是⼀个空⾏,再此之后可以添加任意的其他数据[称之为主体(body)]。
2.GET与POST区别HTTP 定义了与服务器交互的不同⽅法,最基本的⽅法是 GET 和 POST(Ajax开发,关⼼的只有GET请求和POST请求)。
GET与POST⽅法有以下区别:(1)在客户端,Get⽅式在通过URL提交数据,数据在URL中可以看到;POST⽅式,数据放置在HTML HEADER内提交。
(2) GET⽅式提交的数据最多只能有1024字节,⽽POST则没有此限制。
(3)安全性问题。
正如在(1)中提到,使⽤ Get 的时候,参数会显⽰在地址栏上,⽽ Post 不会。
所以,如果这些数据是中⽂数据⽽且是⾮敏感数据,那么使⽤ get;如果⽤户输⼊的数据不是中⽂字符⽽且包含敏感数据,那么还是使⽤ post为好。
(4)安全的和幂等的。
所谓安全的意味着该操作⽤于获取信息⽽⾮修改信息。
幂等的意味着对同⼀ URL 的多个请求应该返回同样的结果。
完整的定义并不像看起来那样严格。
换句话说,GET 请求⼀般不应产⽣副作⽤。
从根本上讲,其⽬标是当⽤户打开⼀个链接时,她可以确信从⾃⾝的⾓度来看没有改变资源。
⽐如,新闻站点的头版不断更新。
虽然第⼆次请求会返回不同的⼀批新闻,该操作仍然被认为是安全的和幂等的,因为它总是返回当前的新闻。
JAVA调用HTTP接口POST或GET实现方式
JAVA调⽤HTTP接⼝POST或GET实现⽅式HTTP是⼀个客户端和服务器端请求和应答的标准(TCP),客户端是终端⽤户,服务器端是⽹站。
通过使⽤Web浏览器、⽹络爬⾍或者其它的⼯具,客户端发起⼀个到服务器上指定端⼝(默认端⼝为80)的HTTP请求。
具体POST或GET实现代码如下:package com.yoodb.util;import java.io.ByteArrayOutputStream;import java.io.IOException;import java.io.InputStream;import mons.httpclient.DefaultHttpMethodRetryHandler;import mons.httpclient.HttpClient;import mons.httpclient.HttpException;import mons.httpclient.methods.GetMethod;import mons.httpclient.methods.PostMethod;import mons.httpclient.params.HttpMethodParams;public class HttpConnectUtil {private static String DUOSHUO_SHORTNAME = "yoodb";//多说短域名 ****.yoodb.****private static String DUOSHUO_SECRET = "xxxxxxxxxxxxxxxxx";//多说秘钥/*** get⽅式* @param url* @author * @return*/public static String getHttp(String url) {String responseMsg = "";HttpClient httpClient = new HttpClient();GetMethod getMethod = new GetMethod(url);getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler());try {httpClient.executeMethod(getMethod);ByteArrayOutputStream out = new ByteArrayOutputStream();InputStream in = getMethod.getResponseBodyAsStream();int len = 0;byte[] buf = new byte[1024];while((len=in.read(buf))!=-1){out.write(buf, 0, len);}responseMsg = out.toString("UTF-8");} catch (HttpException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {//释放连接getMethod.releaseConnection();}return responseMsg;}/*** post⽅式* @param url* @param code* @param type* @author * @return*/public static String postHttp(String url,String code,String type) {String responseMsg = "";HttpClient httpClient = new HttpClient();httpClient.getParams().setContentCharset("GBK");PostMethod postMethod = new PostMethod(url);postMethod.addParameter(type, code);postMethod.addParameter("client_id", DUOSHUO_SHORTNAME);postMethod.addParameter("client_secret", DUOSHUO_SECRET);try {httpClient.executeMethod(postMethod);ByteArrayOutputStream out = new ByteArrayOutputStream();InputStream in = postMethod.getResponseBodyAsStream();int len = 0;byte[] buf = new byte[1024];while((len=in.read(buf))!=-1){out.write(buf, 0, len);}responseMsg = out.toString("UTF-8");} catch (HttpException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {postMethod.releaseConnection();}return responseMsg;}}1、下⾯说⼀下多说单点登录(SSO)获取access_token访问多说API的凭证。
get和post参数传递方式
get和post参数传递方式摘要:1.了解GET和POST的含义和用途2.对比GET和POST的区别3.分析GET和POST的安全性4.实际应用场景和建议正文:在网络编程中,GET和POST是两种常见的数据传递方式。
它们在Web 开发中发挥着重要作用,帮助服务器和客户端之间进行数据交互。
本文将对比GET和POST的区别,分析它们的安全性,并讨论在实际应用中的使用场景和建议。
一、GET和POST的含义和用途1.GET:GET是一种HTTP请求方法,用于从服务器获取数据。
它将数据放在URL中,以键值对的形式传递给服务器。
GET请求的数据量有限制,一般不超过2KB,且不适用于传输敏感信息。
2.POST:POST是一种HTTP请求方法,用于向服务器提交数据。
它将数据放在HTTP请求体中,可以传输较大体积的数据和敏感信息。
POST请求的数据保密性相对较好,但传输数据时可能会受到长度限制。
二、GET和POST的区别1.数据传递方式:GET将数据放在URL中,而POST将数据放在请求体中。
因此,GET请求的参数会在浏览器地址栏中显示,而POST请求的参数则不会显示。
2.数据长度:GET请求的数据长度有限制,不超过2KB,而POST请求可以传输较大体积的数据。
3.安全性:由于GET请求的数据直接暴露在URL中,容易受到跨站脚本攻击(XSS)等安全威胁。
而POST请求的数据在请求体中,相对更安全。
4.缓存:GET请求的数据可以被浏览器缓存,而POST请求的数据不会被缓存。
5.功能性:GET主要用于获取数据,而POST主要用于提交数据。
三、GET和POST的安全性分析1.GET请求:由于GET请求的数据直接暴露在URL中,容易受到XSS攻击。
此外,GET请求传输的数据长度有限,不适合传输敏感信息。
2.POST请求:POST请求的数据在请求体中,相对更安全。
但是,如果服务器端没有对POST数据进行恰当的验证和过滤,仍然可能受到攻击。
java的post,get,put,delete对应数据库用法
java的post,get,put,delete对应数据库用法一、引言在Java中,post,get,put,delete是常见的HTTP请求方法,用于在Web应用程序中进行数据交互。
而在数据库操作中,我们通常使用SQL语句来执行增删查改操作。
那么,如何将这几种HTTP请求方法与数据库操作结合起来呢?本文将详细介绍Java中的post,get,put,delete请求方法对应数据库的用法。
二、Java中的HTTP请求方法1. POST:用于提交数据到服务器,通常用于创建或更新数据。
2. GET:用于获取数据,通常用于查询服务器上的数据。
3. PUT:用于更新单个资源,通常用于更新服务器上的数据。
4. DELETE:用于删除资源,通常用于删除服务器上的数据。
三、数据库操作1. 插入(Insert):使用SQL语句的INSERT INTO...VALUES...将数据插入数据库表中。
对应GET请求方法,可通过查询数据库表获取需要插入的数据。
2. 查询(Select):使用SQL语句的SELECT...FROM...来查询数据库表中的数据。
对应POST和GET请求方法,可以提交查询条件到服务器,或者通过GET请求直接查询服务器上的数据。
3. 更新(Update):使用SQL语句的UPDATE...SET...WHERE...来更新数据库表中的数据。
对应PUT请求方法,可以提交需要更新的数据到服务器。
4. 删除(Delete):使用SQL语句的DELETE FROM...来删除数据库表中的数据。
对应DELETE请求方法,可以提交需要删除的数据到服务器。
四、Java代码示例以MySQL数据库为例,展示如何使用Java的post,get,put,delete请求方法进行数据库操作。
1. POST请求并插入数据:```java// 创建连接对象Connection conn =DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb ", "username", "password");// 创建PreparedStatement对象并执行插入操作PreparedStatement pstmt = conn.prepareStatement("INSERT INTO mytable (column1, column2) VALUES (?, ?)");pstmt.setString(1, "value1");pstmt.setString(2, "value2");pstmt.executeUpdate();```2. GET请求并查询数据:```java// 创建连接对象Connection conn =DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb ", "username", "password");// 创建Statement对象并执行查询操作Statement stmt = conn.createStatement();ResultSet rs = stmt.executeQuery("SELECT * FROM mytable WHERE column1 = 'value1'");// 处理查询结果集while (rs.next()) {// 输出查询到的数据System.out.println(rs.getString("column2"));}```3. PUT请求并更新数据:PUT请求和更新数据库表中的数据的示例代码相似于POST请求和插入数据的示例代码,只不过在SQL语句中使用了UPDATE...SET...WHERE...来更新数据。
get请求和post请求的用法
get请求和post请求的用法
GET请求和POST请求都是HTTP协议的请求方式,用于向服务器请求数据。
它们的区别在于:
1. GET请求通过URL传递请求参数,而POST请求通过请求体传递请求参数。
2. GET请求的请求参数会显示在URL中,而POST请求的请求参数不会显示在URL中。
3. GET请求适合用于请求数据,而POST请求适合用于提交数据。
4. GET请求的请求参数长度有限制,一般为2048个字符,而POST请求的请求参数长度没有限制。
GET请求的用法:
1. 用于请求资源
2. 请求参数通过URL传递,可以通过URL参数直接获取参数
3. 没有上传文件等二进制数据的需求
4. 不需要向服务器发送敏感数据
POST请求的用法:
1. 用于向服务器提交数据
2. 请求参数通过请求体传递,需要通过请求体解析参数
3. 可以上传二进制数据,如文件、图片等
4. 需要向服务器发送敏感数据,如用户名密码等
综上所述,GET请求和POST请求的用法需要根据实际情况进行选择。
一般来说,GET请求适合用于请求数据,而POST请求适合用于提交数据。
同时,需要注意请求参数的传递方式及数据安全性。
java get请求 方法
java get请求方法"Java Get请求方法"引言:在网络开发中,我们经常需要使用HTTP协议来进行数据的传输和交互。
HTTP 协议有多种请求方法,包括GET、POST、PUT、DELETE等。
本篇文章将着重介绍Java中的GET请求方法,包括使用Java标准库的URLConnection类和使用第三方库Apache HttpClient来发送GET请求。
第一步:使用Java标准库的URLConnection类发送GET请求(简介)Java标准库提供了URLConnection类来进行HTTP请求的发送和接收。
它支持多种请求方法,其中包括GET请求。
下面是使用URLConnection发送GET 请求的步骤:1. 创建URL对象,指定要请求的URL地址。
2. 调用URL对象的openConnection方法,返回URLConnection对象。
3. 调用URLConnection对象的setRequestMethod方法,设置请求方法为GET。
4. 调用URLConnection对象的connect方法,建立与目标URL的连接。
5. 获取URLConnection对象的输入流,读取接收到的数据。
6. 关闭连接。
下面我们将详细介绍每一步的具体实现。
第二步:使用Java标准库的URLConnection类发送GET请求(具体实现)1. 创建URL对象,指定要请求的URL地址。
javaURL url = new URL("2. 调用URL对象的openConnection方法,返回URLConnection对象。
javaURLConnection conn = url.openConnection();3. 调用URLConnection对象的setRequestMethod方法,设置请求方法为GET。
javaconn.setRequestMethod("GET");4. 调用URLConnection对象的connect方法,建立与目标URL的连接。
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发送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 的形式。
java 中post 和get方法
java 中post 和get方法
Java中的POST和GET方法是HTTP通信协议中常用的两种方法,分别用于向服务器发送数据和从服务器获取数据。
POST 方法是一种向服务器提交数据的方式,可以通过 HTTP 请求体传递请求参数。
对于大量数据的传递,POST 方法更为合适。
在Java 中,可以使用 HttpURLConnection 或 HttpClient 类来实现POST 请求。
GET 方法则是一种向服务器请求数据的方式,可以将请求参数通过 URL 传递。
GET 方法主要用于获取数据,对于数据的修改,应该使用 POST 方法。
在 Java 中,可以使用 URLConnection 或HttpClient 类来实现 GET 请求。
在使用 POST 和 GET 方法时,需要注意以下几点:
1. POST 方法适用于传输大量数据,而 GET 方法适用于传输小量数据。
2. POST 方法的请求参数通过请求体传递,而 GET 方法的请求参数通过 URL 传递,因此 GET 方法的请求参数会暴露在 URL 中。
3. POST 方法的请求参数可以是任意类型的数据,而 GET 方法的请求参数只能是字符串类型的数据。
4. POST 方法的请求可以提交文件等类型的数据,而 GET 方法只能提交文本数据。
总之,在选择使用 POST 或 GET 方法时,需要根据具体情况来决定使用哪种方法,以达到最好的效果。
java中的http请求的封装(GET、POST、form表单形式)
java中的http请求的封装(GET、POST、form表单形式)⽬前JAVA实现HTTP请求的⽅法⽤的最多的有两种:⼀种是通过HTTPClient这种第三⽅的开源框架去实现。
HTTPClient对HTTP的封装性⽐较不错,通过它基本上能够满⾜我们⼤部分的需求,HttpClient3.1 是 mons.httpclient下操作远程 url的⼯具包,虽然已不再更新,但实现⼯作中使⽤httpClient3.1的代码还是很多,HttpClient4.5是org.apache.http.client下操作远程 url的⼯具包,最新的;另⼀种则是通过HttpURLConnection去实现,HttpURLConnection是JAVA的标准类,是JAVA⽐较原⽣的⼀种实现⽅式。
第⼀种⽅式:java原⽣HttpURLConnectionpackage com.mobile.utils;import com.alibaba.fastjson.JSONObject;import org.apache.log4j.Logger;import java.io.*;import .HttpURLConnection;import .MalformedURLException;import .URL;import java.util.*;public class HttpUtil {static Logger log = Logger.getLogger(HttpUtil.class);/*** 向指定URL发送GET⽅法的请求** @param httpurl* 请求参数⽤?拼接在url后边,请求参数应该是 name1=value1&name2=value2 的形式。
* @return result 所代表远程资源的响应结果*/public static String doGet(String httpurl) {HttpURLConnection connection = null;InputStream is = null;BufferedReader br = null;String result = null;// 返回结果字符串try {// 创建远程url连接对象URL url = new URL(httpurl);// 通过远程url连接对象打开⼀个连接,强转成httpURLConnection类connection = (HttpURLConnection) url.openConnection();// 设置连接⽅式:getconnection.setRequestMethod("GET");// 设置连接主机服务器的超时时间:15000毫秒connection.setConnectTimeout(15000);// 设置读取远程返回的数据时间:60000毫秒connection.setReadTimeout(60000);// 发送请求connection.connect();// 通过connection连接,获取输⼊流if (connection.getResponseCode() == 200) {is = connection.getInputStream();// 封装输⼊流is,并指定字符集br = new BufferedReader(new InputStreamReader(is, "UTF-8"));// 存放数据StringBuffer sbf = new StringBuffer();String temp = null;while ((temp = br.readLine()) != null) {sbf.append(temp);sbf.append("\r\n");}result = sbf.toString();}} catch (MalformedURLException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {// 关闭资源if (null != br) {try {br.close();} catch (IOException e) {e.printStackTrace();}}if (null != is) {try {is.close();} catch (IOException e) {e.printStackTrace();}}connection.disconnect();// 关闭远程连接}return result;}/*** 向指定 URL 发送POST⽅法的请求** @param httpUrl* 发送请求的 URL* @param param* 请求参数应该是{"key":"==g43sEvsUcbcunFv3mHkIzlHO4iiUIT R7WwXuSVKTK0yugJnZSlr6qNbxsL8OqCUAFyCDCoRKQ882m6cTTi0q9uCJsq JJvxS+8mZVRP/7lWfEVt8/N9mKplUA68SWJEPSXyz4MDeFam766KEyvqZ99d"}的形式 * @return所代表远程资源的响应结果*/public static String doPost(String httpUrl, String param) {HttpURLConnection connection = null;InputStream is = null;OutputStream os = null;BufferedReader br = null;String result = null;try {URL url = new URL(httpUrl);// 通过远程url连接对象打开连接connection = (HttpURLConnection) url.openConnection();// 设置连接请求⽅式connection.setRequestMethod("POST");// 设置连接主机服务器超时时间:15000毫秒connection.setConnectTimeout(15000);// 设置读取主机服务器返回数据超时时间:60000毫秒connection.setReadTimeout(60000);// 默认值为:false,当向远程服务器传送数据/写数据时,需要设置为trueconnection.setDoOutput(true);// 默认值为:true,当前向远程服务读取数据时,设置为true,该参数可有可⽆connection.setDoInput(true);// 设置传⼊参数的格式:请求参数应该是 name1=value1&name2=value2 的形式。
java的post,get,put,delete对应数据库用法 -回复
java的post,get,put,delete对应数据库用法-回复Java中的post、get、put和delete方法是常用的HTTP请求方法,用于与服务器进行数据传输。
它们在数据库应用中有着不同的用法和含义。
本文将一步一步回答中括号内的问题,深入探讨这些方法的数据库用法。
首先,我们需要理解HTTP请求方法和数据库操作之间的关系。
HTTP是一种用于客户端和服务器之间通信的协议,它定义了一系列的请求方法,包括GET、POST、PUT和DELETE等。
而数据库是一种用于存储和管理数据的系统。
在Java中,我们通常使用HTTP请求方法来与服务器进行数据传输,而服务器则会将这些请求映射到相应的数据库操作。
GET方法在数据库中的用法如何?GET方法通常用于从服务器获取资源。
在数据库应用中,我们可以使用GET方法来查询数据库中的数据。
通过GET请求,客户端可以向服务器发送一个查询请求,并获得符合条件的数据结果。
这些数据可以是特定表中的所有记录,也可以是符合特定条件的记录集合。
在Java中,我们可以使用数据库操作的API(如JDBC)来执行查询操作,并将查询结果返回给客户端。
POST方法在数据库中的用法如何?POST方法通常用于向服务器添加新资源。
在数据库应用中,我们可以使用POST方法将新的记录添加到数据库表中。
通过POST请求,客户端可以向服务器发送一个添加数据的请求,并将数据作为请求体发送到服务器。
服务器接收到请求后,会将数据解析并插入到相应的数据库表中。
在Java中,我们可以使用数据库操作的API 来执行插入操作,并将插入结果返回给客户端。
PUT方法在数据库中的用法如何?PUT方法通常用于更新服务器上的资源。
在数据库应用中,我们可以使用PUT方法来更新数据库中的数据。
通过PUT请求,客户端可以向服务器发送一个更新数据的请求,并将更新后的数据作为请求体发送到服务器。
服务器接收到请求后,会将数据解析并更新相应的数据库记录。
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发送HTTPPOST请求(内容为xml格式)
Java发送HTTPPOST请求(内容为xml格式)今天在给平台⽤户提供http简单接⼝的时候,顺便写了个调⽤的Java类供他参考。
服务器地址:http://5.0.217.50:17001/VideoSend服务器提供的是xml格式的http接⼝,接⼝定义如下:<!--视频点送: videoSend--><videoSend><header><sid>%s</sid><type>service</type></header><service name="videoSend"><fromNum>%s</fromNum><toNum>%s</toNum> <!--需要接通的⽤户的电话号码 --><videoPath>%s</videoPath> <!--视频⽂件路径 --><chargeNumber>%s</chargeNumber> <!--计费号码 --></service></videoSend><!--视频点送返回结果: videoSendResult--><videoSend><header><sid>%s</sid><type>service</type></header><service name="videoSendResult">rescode>%s</rescode> <!--0000:视频点送成功,0001:请求参数信息错误, 0002:接通⽤户失败--></service></videoSend>对应调⽤端的Java代码(只是个demo,参数都暂时写死了)如下:import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.io.OutputStreamWriter;import .MalformedURLException;import .URL;import .URLConnection;public class HttpPostTest {void testPost(String urlStr) {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 = new OutputStreamWriter(con.getOutputStream());String xmlInfo = getXmlInfo();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()));String line = "";for (line = br.readLine(); line != null; line = br.readLine()) {System.out.println(line);}} catch (MalformedURLException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}}private String getXmlInfo() {StringBuilder sb = new StringBuilder();sb.append("<videoSend>");sb.append(" <header>");sb.append(" <sid>1</sid>");sb.append(" <type>service</type>");sb.append(" </header>");sb.append(" <service name=\"videoSend\">");sb.append(" <fromNum>0000021000011001</fromNum>");sb.append(" <toNum>33647405</toNum>");sb.append(" <videoPath>mnt/5.0.217.50/resources/80009.mov</videoPath>"); sb.append(" <chargeNumber>0000021000011001</chargeNumber>");sb.append(" </service>");sb.append("</videoSend>");return sb.toString();}public static void main(String[] args) {String url = "http://5.0.217.50:17001/VideoSend";new HttpPostTest().testPost(url);}}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
package wzh.Http;
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 的形式。
* @return URL 所代表远程资源的响应结果
*/
public static String sendGet(String url, String param) {
String result = "";
BufferedReader in = null;
try {
String urlNameString = url + "?" + param;
URL realUrl = new URL(urlNameString);
// 打开和URL之间的连接
URLConnection connection = realUrl.openConnection();
// 设置通用的请求属性
connection.setRequestProperty("accept", "*/*");
connection.setRequestProperty("connection", "Keep-Alive");
connection.setRequestProperty("user-agent",
"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
// 建立实际的连接
connection.connect();
// 获取所有响应头字段
Map<String, List<String>> map = connection.getHeaderFields();
// 遍历所有的响应头字段
for (String key : map.keySet()) {
System.out.println(key + "--->" + map.get(key));
}
// 定义BufferedReader输入流来读取URL的响应
in = new BufferedReader(new InputStreamReader(
connection.getInputStream()));
String line;
while ((line = in.readLine()) != null) {
result += line;
}
} catch (Exception e) {
System.out.println("发送GET请求出现异常!" + e);
e.printStackTrace();
}
// 使用finally块来关闭输入流
finally {
try {
if (in != null) {
in.close();
}
} catch (Exception e2) {
e2.printStackTrace();
}
}
return result;
}
/**
* 向指定URL 发送POST方法的请求
*
* @param url
* 发送请求的URL
* @param param
* 请求参数,请求参数应该是name1=value1&name2=value2 的形式。
* @return 所代表远程资源的响应结果
*/
public static String sendPost(String url, String param) {
PrintWriter out = null;
BufferedReader in = null;
String result = "";
try {
URL realUrl = new URL(url);
// 打开和URL之间的连接
URLConnection conn = realUrl.openConnection();
// 设置通用的请求属性
conn.setRequestProperty("accept", "*/*");
conn.setRequestProperty("connection", "Keep-Alive");
conn.setRequestProperty("user-agent",
"Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
// 发送POST请求必须设置如下两行
conn.setDoOutput(true);
conn.setDoInput(true);
// 获取URLConnection对象对应的输出流
out = new PrintWriter(conn.getOutputStream());
// 发送请求参数
out.print(param);
// flush输出流的缓冲
out.flush();
// 定义BufferedReader输入流来读取URL的响应
in = new BufferedReader(
new InputStreamReader(conn.getInputStream()));
String line;
while ((line = in.readLine()) != null) {
result += line;
}
} catch (Exception e) {
System.out.println("发送POST 请求出现异常!"+e);
e.printStackTrace();
}
//使用finally块来关闭输出流、输入流
finally{
try{
if(out!=null){
out.close();
}
if(in!=null){
in.close();
}
}
catch(IOException ex){
ex.printStackTrace();
}
}
return result;
}
}。