Java实现post请求详细代码(带有参数)

 更新时间:2023年08月23日 10:37:00   作者:FJ.  
这篇文章主要给大家介绍了关于Java实现带有参数post请求的相关资料,文中通过代码示例介绍的非常详细,对大家学习或者使用Java具有一定的参考学习价值,需要的朋友可以参考下

Java技术迷

代码示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
package Sort.pay;
import net.sf.json.JSONObject;
import org.apache.commons.codec.digest.DigestUtils;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.URL;
import java.net.URLConnection;
import java.util.*;
public class Pay {
    public static void main(String[] args) {
        String url = "http://xxxxxx";//访问路径
        Random random = new Random();
        Map<String, Object> map = new HashMap<>();
        map.put("authCode", "1423009170000001");
        map.put("resource", "api.hl.order.pay.unified");
        map.put("requestTime", "20230129105758");
        map.put("versionNo", "1");
        Map<String, Object> params = new HashMap<>();
        params.put("businessOrderNo", random.nextInt(1000000000));//202105623000002
        params.put("payAmount", "90.00");
        params.put("remark", "购买山核桃20斤");
        params.put("merchantNo", "771389");
        params.put("operatorAccount", "19884151060");
        params.put("deviceNo", "402102317000001");
        params.put("notifyUrl", "http://testapi.liankok.com/notify/pay");
        params.put("payExpireTime", "600");
        params.put("limitPay", "1");
        params.put("payUrlExpireTime", "60");
        params.put("subject", "山核桃");
        params.put("goodsTag", "guolicheng");
        params.put("goodsInfo", "{\"receiptid\":\"323323\",\"costprice\":200.00,\"goodsdetail\":[{\"goodsid\":\"123123123\",\"goodsname\":\"小石头\",\"thirdgoodsid\":\"23323453\",\"quantity\":1,\"price\":5.00}]}");
        map.putAll(params);
//            map.put("params",params);
        //排序集合
        map = PaySortUtil.sortByKey(map);
        //遍历输出拼接字符串
        Set<String> keys = map.keySet();
        String str = "";
        for (String key : keys) {
            str += key + "=" + map.get(key) + "&";
        }
        str = str.toLowerCase() + "U7iIPg2x1k";
        //md5加密字符串
        String md5sr = DigestUtils.md5Hex(str);
        map.put("sign", md5sr);
        Map<String, Object> map3 = new HashMap<>();//存放结果
        //将需要比较删除的两个集合添加
        map3.putAll(map);
        map3.putAll(params);
        //for - each遍历比较且删除
        for (String a : map.keySet()) {
            if (params.containsKey(a) || params.containsValue(map.get(a))) {
                map3.remove(a);
            }
        }
        map3.put("versionNo", "1");
        map3.put("params", params);
        System.out.println(map3);
        JSONObject jsonObject=JSONObject.fromObject(map3);
        System.out.println(jsonObject.toString());
       String ss= Pay.sendPost(url,jsonObject.toString());
        System.out.println(ss);
    }
    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("Content-Type", "application/json");
            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.err.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;
    }
}
class PaySortUtil {
    public static Map<String, Object> sortByKey(Map<String, Object> map){
        //创建一个带有比较器的TreeMap
        Map<String, Object> treeMap = new TreeMap<>(String::compareTo);
        //将你的map传入treeMap
        treeMap.putAll(map);
        return treeMap;
    }
}

pom文件所需依赖,有些依赖不是必需的,这里没有删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
<dependencies>
<!--        post请求的依赖-->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpmime</artifactId>
            <version>4.5.2</version>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>16.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.78</version>
        </dependency>
        <!--MD5依赖-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.12.0</version>
        </dependency>
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>1.3</version>
        </dependency>
        <dependency>
            <groupId>org.apache.maven.surefire</groupId>
            <artifactId>maven-surefire-common</artifactId>
            <version>2.12.4</version>
        </dependency>
        <dependency>
            <groupId>org.kie.modules</groupId>
            <artifactId>org-apache-commons-httpclient</artifactId>
            <version>6.2.0.CR2</version>
            <type>pom</type>
        </dependency>
        <!-- JSONObject对象依赖的jar包 -->
        <dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>1.9.3</version>
        </dependency>
        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
            <version>3.2.1</version>
        </dependency>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.1.1</version>
        </dependency>
        <dependency>
            <groupId>net.sf.ezmorph</groupId>
            <artifactId>ezmorph</artifactId>
            <version>1.0.6</version>
        </dependency>
        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.2.3</version>
            <classifier>jdk15</classifier><!-- 指定jdk版本 -->
        </dependency>
        <!-- Json依赖架包下载 -->
    </dependencies>
    <properties>
        <maven.compiler.source>7</maven.compiler.source>
        <maven.compiler.target>7</maven.compiler.target>
    </properties>

附:java使用post请求带参(放在body中)访问外部连接

java使用post请求带参(放在body中)访问外部连接

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package com.bxzn.bxgd.service.impl;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.bxzn.bxgd.util.yuntai.HTTPClientUtil;
import com.bxzn.bxgd.util.yuntai.HttpsClientUtil;
import netscape.javascript.JSObject;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.mime.MultipartEntity;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.DefaultHttpClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.*;
                JSONObject jsonObject = new JSONObject();
                jsonObject.put("create_time", checkLog.getCreateTime());
                jsonObject.put("camera_loc", checkLog.getCameraLoc());
                jsonObject.put("state", checkLog.getState());
                jsonObject.put("type", checkLog.getType());
                jsonObject.put("attach_file", checkLog.getAttachFile());
                jsonObject.put("level", checkLog.getLevel());
                HTTPClientUtil.sendPost(urls, null, JSON.toJSONString(jsonObject));

HTTPClientUtil类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
package com.bxzn.bxgd.util.yuntai;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.bxzn.bxgd.util.socket.WebSocket;
import com.bxzn.bxgd.util.socket.WssSocket;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.methods.DeleteMethod;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.methods.PutMethod;
import org.apache.commons.httpclient.UsernamePasswordCredentials;
import org.apache.commons.httpclient.auth.AuthScope;
import org.apache.http.HttpEntity;
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.HttpPost;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import javax.sound.sampled.*;
import javax.sql.rowset.serial.SerialBlob;
import java.io.*;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.ByteBuffer;
import java.sql.Blob;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Stream;
/**
 * 和云台进行http的连接
 *
 * @author xxy
 */
public class HTTPClientUtil {
    /**
     * 编码格式。发送编码格式统一用UTF-8
     */
    private static final String ENCODING = "UTF-8";
    /**
     * 设置连接超时时间,单位毫秒。
     */
    private static final Integer CONNECT_TIMEOUT = 6000;
    /**
     * 请求获取数据的超时时间(即响应时间),单位毫秒。
     */
    private static final Integer SOCKET_TIMEOUT = 6000;
    /**
     * @param url  请求地址
     * @param data 只支持JSON对象(com.alibaba.fastjson.JSONObject)
     * @return String
     * @Title:POST请求
     * @Decription:发送POST请求,data参数只支持JSON对象(com.alibaba.fastjson.JSONObject)
     */
    public static String sendPost(String url, Map<String, String> header, JSONObject data) throws IOException {
        // 设置默认请求头
        Map<String, String> headers = new HashMap<>();
        if (header != null) {
            headers = header;
        } else {
            headers.put("Content-Type", "application/json;charset=utf-8");
        }
        return doPostByJSON(url, headers, data, ENCODING);
    }
    /**
     * @param url  请求地址
     * @param data 只支持JSON对象(com.alibaba.fastjson.JSONObject)
     * @return String
     * @Title:POST请求
     * @Decription:发送POST请求,data参数只支持JSON对象(com.alibaba.fastjson.JSONObject)
     */
    public static String sendPost(String url, Map<String, String> header, String data) throws IOException {
        // 设置默认请求头
        Map<String, String> headers = new HashMap<>();
        if (header != null) {
            headers = header;
        } else {
            headers.put("Content-Type", "application/json;charset=utf-8");
        }
        return doPostByJSON(url, headers, JSONObject.parseObject(data), ENCODING);
    }
    /**
     * @param url     请求地址
     * @param headers Map集合的请求头参数
     * @param params  Map集合(输入参数为JSON对象)
     * @return String
     * @Title POST请求(默认编码:UTF-8)
     */
    public static String sendPost(String url, Map<String, String> headers, Map<String, String> params) throws IOException {
        // 将map转成json
        JSONObject data = JSONObject.parseObject(JSON.toJSONString(params));
        return doPostByJSON(url, headers, data, ENCODING);
    }
    /**
     * @param url      请求地址
     * @param headers  请求头
     * @param data     请求实体
     * @param encoding 字符集
     * @return String
     * @throws IOException
     * @Title: sendPost
     * @Description: TODO(发送post请求)
     */
    private static String doPostByJSON(String url, Map<String, String> headers, JSONObject data, String encoding) throws IOException {
        // 请求返回结果
        String resultJson = null;
        // 创建Client
        CloseableHttpClient client = HttpClients.createDefault();
        // 发送请求,返回响应对象
        CloseableHttpResponse response = null;
        // 创建HttpPost对象
        HttpPost httpPost = new HttpPost();
        /**
         * setConnectTimeout:设置连接超时时间,单位毫秒。
         * setConnectionRequestTimeout:设置从connect Manager(连接池)获取Connection
         * 超时时间,单位毫秒。这个属性是新加的属性,因为目前版本是可以共享连接池的。
         * setSocketTimeout:请求获取数据的超时时间(即响应时间),单位毫秒。
         * 如果访问一个接口,多少时间内无法返回数据,就直接放弃此次调用。
         */
        RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECT_TIMEOUT).setSocketTimeout(SOCKET_TIMEOUT).build();
        httpPost.setConfig(requestConfig);
        try {
            // 设置请求地址
            httpPost.setURI(new URI(url));
            // 设置请求头
            packageHeader(headers, httpPost);
            // 设置实体
            httpPost.setEntity(new StringEntity(JSON.toJSONString(data), encoding));
//            httpPost.addHeader("Content-Type", "application/json;charset=utf-8");
            // 发送请求,返回响应对象
            response = client.execute(httpPost);
            // 获取响应状态
            int status = response.getStatusLine().getStatusCode();
            if (status != HttpStatus.SC_OK) {
                System.out.println("响应失败,状态码:" + status);
            }
            // 获取响应结果
            resultJson = EntityUtils.toString(response.getEntity(), encoding);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            release(response, client);
        }
        return resultJson;
    }
    /**
     * Description: 封装请求头
     *
     * @param params
     * @param httpMethod
     */
    public static void packageHeader(Map<String, String> params, HttpRequestBase httpMethod) {
        // 封装请求头
        if (params != null) {
            Set<Map.Entry<String, String>> entrySet = params.entrySet();
            for (Map.Entry<String, String> entry : entrySet) {
                // 设置到请求头到HttpRequestBase对象中
                httpMethod.setHeader(entry.getKey(), entry.getValue());
            }
        }
    }
    /**
     * Description: 释放资源
     *
     * @param httpResponse
     * @param httpClient
     * @throws IOException
     */
    public static void release(CloseableHttpResponse httpResponse, CloseableHttpClient httpClient) throws IOException {
        // 释放资源
        if (httpResponse != null) {
            httpResponse.close();
        }
        if (httpClient != null) {
            httpClient.close();
        }
    }
}

然后自己写个测试类就行,顺便一提,HTTPClientUtil.sendPost(urls, null, JSON.toJSONString(jsonObject));这个方法返回值取决于服务器的返回值,是字符串类型

总结 

到此这篇关于Java实现post请求的文章就介绍到这了,更多相关Java实现post请求内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

蓄力AI

微信公众号搜索 “ 脚本之家 ” ,选择关注

程序猿的那些事、送书等活动等着你

原文链接:https://blog.csdn.net/wnagqie/article/details/128790791

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。
如若内容造成侵权/违法违规/事实不符,请将相关资料发送至 reterry123@163.com 进行投诉反馈,一经查实,立即处理!

相关文章

  • SpringBoot web开发源码深入分析

    SpringBoot web开发源码深入分析

    Web开发的核心内容主要包括内嵌的Servlet容器和SpringMVCSpringBoot使用起来非常简洁,大部分配置都有SpringBoot自动装配,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习吧
    2022-10-10
  • Java实现经典游戏之大鱼吃小鱼

    Java实现经典游戏之大鱼吃小鱼

    这篇文章主要为大家详细介绍了如何利用Java语言实现经典游戏之大鱼吃小鱼,文中的示例代码讲解详细,对我们学习Java游戏开发有一定帮助,需要的可以参考一下
    2022-08-08
  • Java中如何将json字符串转换成map/list

    Java中如何将json字符串转换成map/list

    这篇文章主要介绍了Java中如何将json字符串转换成map/list,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2022-07-07
  • MyBatis 多个条件使用Map传递参数进行批量删除方式

    MyBatis 多个条件使用Map传递参数进行批量删除方式

    这篇文章主要介绍了MyBatis 多个条件使用Map传递参数进行批量删除方式,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2021-12-12
  • mybatis实现增删改查_动力节点Java学院整理

    mybatis实现增删改查_动力节点Java学院整理

    本文通过实例代码给大家介绍了mybatis实现增删改查功能,非常不错,具有参考借鉴价值,需要的朋友参考下吧
    2017-09-09
  • IDEA Maven下载依赖包速度过慢的问题及解决方案

    IDEA Maven下载依赖包速度过慢的问题及解决方案

    这篇文章主要介绍了IDEA Maven下载依赖包速度过慢的问题及解决方案,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2023-09-09
  • SpringBoot利用随机盐值实现密码的加密与验证

    SpringBoot利用随机盐值实现密码的加密与验证

    这篇文章主要为大家详细介绍了SpringBoot如何利用随机盐值实现密码的加密与验证,文中的示例代码讲解详细,有需要的小伙伴可以参考下
    2024-02-02
  • Java静态方法和实例方法区别详解

    Java静态方法和实例方法区别详解

    这篇文章主要为大家详细介绍了Java静态方法和实例方法的区别,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2016-12-12
  • Logback日志存放路径不统一解决方案

    Logback日志存放路径不统一解决方案

    这篇文章主要介绍了Logback日志存放路径不统一解决方案,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-10-10
  • 新手了解java IO基础知识

    新手了解java IO基础知识

    这篇文章主要介绍了java 基础知识之IO总结的相关资料,Java中的I/O分为两种类型,一种是顺序读取,一种是随机读取,需要的朋友可以参考下,希望对你有帮助
    2021-07-07

最新评论