JAVA发起HHTP请求

最新推荐文章于 2024-09-12 23:58:52 发布
最新推荐文章于 2024-09-12 23:58:52 发布
阅读量344 收藏
点赞数
分类专栏： java 文章标签： java http
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wu_qing_song/article/details/114090778
版权

JAVA发起HHTP请求

文章目录

一、HttpUtil工具类

package com.test.common.util;

import com.fasterxml.jackson.core.type.TypeReference;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.apache.http.HttpStatus;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.Map;
import java.util.stream.Collectors;

@Slf4j
@Component
public class HttpUtil {
    private static final String CONTENT_TYPE = "application/x-www-form-urlencoded";
    private static final String CONTENT_TYPE_JSON = "application/json;charset=utf-8";

    public static <T> T post(String url, Map<String, Object> dataMap, TypeReference<T> typeReference) {
        String result = null;
        InputStream inputStream = null;
        try {
            CloseableHttpClient client = HttpClients.createDefault();
            HttpPost post = new HttpPost(url);
            if (dataMap == null) dataMap = Collections.emptyMap();
            ByteArrayEntity byteArrayEntity = new ByteArrayEntity(JsonUtil.toByte(dataMap), ContentType.APPLICATION_JSON);
            byteArrayEntity.setContentEncoding("utf-8");
            byteArrayEntity.setContentType(CONTENT_TYPE_JSON);
            post.setEntity(byteArrayEntity);
            CloseableHttpResponse response = client.execute(post);
            inputStream = response.getEntity().getContent();
            result = IOUtils.toString(inputStream, StandardCharsets.UTF_8);
            return JsonUtil.parse(result, typeReference);
        } catch (Exception e) {
            log.error("请求异常：{} -> {}", url, e.getMessage(), e);
            throw new RuntimeException(e);
        } finally {
            log.info("请求成功：{} -> {}", url, result);
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (Exception e) {
                    log.error("请求异常（关流）：{} -> {}", url, e.getMessage(), e);
                }
            }
        }
    }

    public static byte[] post(String url, Map<String, String> headers, byte[] data) {
        byte[] result = null;
        InputStream inputStream = null;
        try {
            CloseableHttpClient client = HttpClients.createDefault();
            HttpPost post = new HttpPost(url);
            if (headers != null) {
                headers.forEach(post::addHeader);
            }
            ByteArrayEntity byteArrayEntity = new ByteArrayEntity(data, ContentType.TEXT_PLAIN);
            byteArrayEntity.setContentEncoding("utf-8");
            byteArrayEntity.setContentType("text/plain;charset=utf-8");
            post.setEntity(byteArrayEntity);
            CloseableHttpResponse response = client.execute(post);
            inputStream = response.getEntity().getContent();
            return IOUtils.toByteArray(inputStream);
        } catch (Exception e) {
            log.error("请求异常：{} -> {}", url, e.getMessage(), e);
            throw new RuntimeException(e);
        } finally {
            log.info("请求成功：{} -> {}", url, result);
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (Exception e) {
                    log.error("请求异常（关流）：{} -> {}", url, e.getMessage(), e);
                }
            }
        }
    }

    public static <T> T postUrl(String url, Map<String, Object> dataMap, TypeReference<T> typeReference) {
        String result = null;
        InputStream inputStream = null;
        try {
            CloseableHttpClient client = HttpClients.createDefault();
            HttpPost post = new HttpPost(url);
            if (dataMap == null) dataMap = Collections.emptyMap();
            String urlParam = dataMap.entrySet().stream().map(e -> e.getKey() + "=" + e.getValue()).collect(Collectors.joining("&"));
            StringEntity reqEntity = new StringEntity(urlParam, StandardCharsets.UTF_8.name());
            reqEntity.setContentType(CONTENT_TYPE);
            post.setEntity(reqEntity);
            CloseableHttpResponse response = client.execute(post);
            inputStream = response.getEntity().getContent();
            result = IOUtils.toString(inputStream, StandardCharsets.UTF_8);
            return JsonUtil.parse(result, typeReference);
        } catch (Exception e) {
            log.error("请求异常：{} -> {}", url, e.getMessage(), e);
            throw new RuntimeException(e);
        } finally {
            log.info("请求成功：{} -> {}", url, result);
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (Exception e) {
                    log.error("请求异常（关流）：{} -> {}", url, e.getMessage(), e);
                }
            }
        }
    }

    @SneakyThrows
    public static <T> T get(String url, Map<String, Object> dataMap, Map<String, String> header, TypeReference<T> typeReference) {
        CloseableHttpResponse closeableHttpResponse = null;
        try {
            CloseableHttpClient client = HttpClients.createDefault();
            if (header == null) header = Collections.emptyMap();
            if (dataMap != null && !dataMap.isEmpty()) {
                url += "?" + dataMap.entrySet().stream().map(e -> e.getKey() + "=" + e.getValue()).collect(Collectors.joining("&"));
            }
            HttpGet get = new HttpGet(url);
            header.entrySet().stream().forEach(entry -> get.setHeader(entry.getKey(), entry.getValue()));
            closeableHttpResponse = client.execute(get);
            if (closeableHttpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                log.info("请求成功：{}", closeableHttpResponse.toString());
                return JsonUtil.parse(closeableHttpResponse.getEntity().getContent(), typeReference);
            } else {
                log.info("请求失败：{}", closeableHttpResponse.toString());
                return null;
            }
        } catch (Exception e) {
            log.error("请求异常：{} -> {}", url, e.getMessage(), e);
            throw new RuntimeException(e);
        } finally {
            if (closeableHttpResponse != null) {
                closeableHttpResponse.close();
            }
        }
    }


    public static String getIp(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        if (!checkIp(ip)) {
            if (ip.contains(",")) {
                ip = ip.split(",")[0];
            }
        }
        if (checkIp(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (checkIp(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (checkIp(ip)) {
            ip = request.getHeader("HTTP_CLIENT_IP");
        }
        if (checkIp(ip)) {
            ip = request.getHeader("HTTP_X_FORWARDED_FOR");
        }
        if (checkIp(ip)) {
            ip = request.getHeader("X-Real-IP");
        }
        if (checkIp(ip)) {
            ip = request.getRemoteAddr();
        }
        return ip;
    }

    private static boolean checkIp(String ip) {
        return null == ip || ip.length() == 0 || "unknown".equalsIgnoreCase(ip);
    }
}

二、使用步骤

1.示例一

代码如下（示例）：

DataVo msgDataResponseVo = HttpUtil.post(url, bodyMap, new TypeReference<DataVo>() {
});

2.示例二

代码如下（示例）：

 Map<String, String> headers = new HashMap<>();
 headers.put("token", token);
 DataVo dataVo = new DataVo();
 dataVo.setId("123456");
 byte[] requestBody = JsonUtil.toByte(dataVo);
 String post = post(interfaceDownlinkUrl, headers, requestBody);

三、JsonUtil工具类

package com.test.common.util;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.io.IOException;
import java.io.InputStream;

public class JsonUtil {

    private static final ObjectMapper objectMapper = new ObjectMapper();

    static {
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        objectMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
        objectMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
    }

    public static byte[] toByte(Object obj) {
        try {
            return objectMapper.writeValueAsBytes(obj);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }

    public static String toString(Object obj) {
        try {
            return objectMapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }

    public static <T> T parse(String json, Class<T> clazz) {
        try {
            return objectMapper.readValue(json, clazz);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public static <T> T parse(byte[] json, Class<T> clazz) {
        try {
            if (json == null) {
                return null;
            }
            return objectMapper.readValue(json, clazz);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public static <T> T parse(InputStream json, Class<T> clazz) {
        try {
            return objectMapper.readValue(json, clazz);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public static <T> T parse(InputStream json, TypeReference<T> clazz) {
        try {
            return objectMapper.readValue(json, clazz);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public static <T> T parse(String json, TypeReference<T> clazz) {
        try {
            return objectMapper.readValue(json, clazz);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

四、Json解析类

package com.test.common.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.io.InputStream;

@Component
public class JsonMapper {
    @Autowired
    private ObjectMapper objectMapper;

    {
        if (objectMapper != null) {
            objectMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
        }
    }

    public String toString(Object obj) {
        try {
            return objectMapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
    }

    public <T> T parse(String json, Class<T> clazz) {
        try {
            return objectMapper.readValue(json, clazz);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public <T> T parse(InputStream json, Class<T> clazz) {
        try {
            return objectMapper.readValue(json, clazz);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public <T> T parse(String json, TypeReference<T> clazz) {
        try {
            return objectMapper.readValue(json, clazz);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}
青椒1013
关注
专栏目录
java HTTP通信
杨丙的博客
10-13 5991
java HTTP通信 一、相关知识学习 1、 HTTP通信原理   HTTP是一套计算机通过网络进行通信的规则，HTTP使HTTP客户（如Web浏览器）能够从HTTP服务器(Web服务器)请求信息和服务，HTTP是一种无状态的协议，无状态是指Web浏览器和Web服务器之间不需要建立持久的连接，这意味着当一个客户端向服务器端发出请求，然后Web服务器返回响应(response)，连接就被关闭了，在...
基于Java发起HTTP请求实现文件的上传
怕什么真理无穷，进一寸有一寸的欢喜。即使开了一辆老掉牙的破车，只要在前行就好，偶尔吹点小风，这就是幸
06-23 830
需要用到的包 后端代码以及接口见我之前发的文章：文章地址 之前的实现方式是通过html上传文件实现文件上传，而现在是基于Java实现发起http请求进行问价的上传。在本地使用Java对文件进行分片上传。 基于Java实现的发起http请求的工具类 JSON格式转map的工具类 基于apache框架实现的发起http请求的工具类...
Java网络编程——创建非阻塞的HTTP服务器
码说芯语的博客
12-07 1031
Http简介、创建非阻塞的HTPP服务器
总结下自己一路走过的java http客户端
唯一的专栏
02-27 4531
这篇文章主要是用来总结自己写代码以来，使用java http客户端的历程，从最开始的原生方式到 httpclient4再到okhttp到现在的unirest，在此只是记录一些demo，没有按使用习惯进行封装。
java.lang.IllegalArgumentException: host parameter is null
爱春秋
09-29 653
      项目中使用到HttpClient调用接口，部署时出现此问题，后来经检查为配置项出错。       即 URL 应为 hhtp://www.baidu.com  但是实际配置成了  www.baidu.com 所以出现此错误    ...
Java中Http连接的两种方式
一路风顺
08-16 2万+
在java中连接http，介绍两种方法，一种是java的HttpUrlConnection，另一种是apacha公司的httpClient，后者是第三方的类库需要从外部，导入，同时这也是第一次使用外部的类库，以后还会有很多需要导入外部类库的需求。 http协议是基于tcp的一种协议。 tcp是一种保证可靠连接的传输协议，通过三次握手，和丢失重传的机制保证数据的传输。首先来看HttpUrlConn
java发起http请求获取返回的Json对象方法
10-18
本篇内容将详细介绍如何使用Java发起HTTP请求并处理返回的JSON对象。 首先，要发起一个HTTP请求，我们可以使用Java内置的URL和HttpURLConnection类。URL类用于表示一个统一资源定位符（URL），它是互联网上标准的...
java发起http请求提交表单
08-27
...此方法通常用于向服务器...综上所述，使用Java发起HTTP请求提交表单是一个涉及多方面技术的过程。从构建HTML表单到使用不同的库来模拟HTTP请求，再到处理表单参数，每一步都需要仔细考虑以确保数据的安全性和准确性。
java发送http get请求的两种方法(总结)
08-30
Java 发送 HTTP GET 请求的两种方法总结 Java 中发送 HTTP GET 请求有多种方法，本文将总结两种常用的方法，分别使用 HttpClient 和流的形式发送 GET 请求。 Method 1: 使用 HttpClient 使用 HttpClient 发送 ...
Java如何发起http请求的实现(GET/POST)
p1830095583的博客
05-13 6867
前言 在未来做项目中，一些功能模块可能会采用不同的语言进行编写。这就需要http请求进行模块的调用。那么下面，我将以Java为例，详细说明如何发起http请求。 一、GET与POST GET和POST是HTTP的两个常用方法。 GET指从指定的服务器中获取数据 POST指提交数据给指定的服务器处理 1.GET方法 使用GET方法，需要传递的参数被附加在URL地址后面一起发送到服务器。 例如：http://121.41.111.94/submit?name=zxy&age=21 特点： GET请求能
Java处理Http请求
书香水墨
05-09 2425
import java.io.*; import java.net.HttpURLConnection; import java.net.URL; /** * Java处理HTTP请求 */ public class HttpClient { // 获取百度首页源码 public static void main(String[] args) throws IOException ...
java实现HTTP请求方式
程序猿劝退师的博客
10-24 7756
目录 1.HttpURLConnection 2.Apache的HttpClient例子 1.HttpURLConnection import javax.imageio.stream.ImageInputStreamImpl; import org.eclipse.jetty.util.ajax.JSON; public class Client { /** * Http ge...
http状态码
java821643的博客
12-20 678
IIS状态代码的含义 概要 当用户试图通过HTTP或文件传输协议(FTP)访问一台正在运行Internet信息服务(IIS)的服务器上的内容时，IIS返回一个表示该请求的状态的数字代码。该状态代码记录在IIS日志中，同时也可能在Web浏览器或FTP客户端显示。状态代码可以指明具体请求是否已成功，还可以揭示请求失败的确切原因。 更多信息 日志文件的位置 在默认状态下，IIS把它的日志文件放在%WI...
JAVA发送HTTP请求方式总结
热门推荐
灵药的博客
05-30 6万+
java 发送HTTP请求方式总结 源代码：http://github.com/lovewenyo/HttpDemo 1. HttpURLConnection 使用JDK原生提供的net，无需其他jar包； HttpURLConnection是URLConnection的子类，提供更多的方法，使用更方便。 package httpURLConnection; import...
java调用接口之okhttp
Himly_Zhang的博客
05-20 1171
JAVA调用restful接口 目前随着互联网微服务的兴起，需要通过接口进行服务的传输情况越来越多，原始的webservice相对较为臃肿，常见代表为aix2,xfire等等。新兴的则以restfull标准接口为代表的例如httpUrlConnection,okhttpclient,Unirest为代表。 首先先介绍一下httpurlconnection 本对象为JDK原生支持方法，不用引入任何第三方依赖包。具体代码如下： public static String sendGet(String ur
HTTP传输byte[ ] 两种方式
Sammie.Zhang的博客
03-24 3万+
//========第一种======== public class HttpUtil { public static InputStream http(String url, byte[] PostData) { URL u = null; HttpURLConnection con = null; InputStream inputStre
java调用http接口
userlhj的博客
01-17 991
代码： public class Test{ public static void interfaceUtil(String path,String data) { try { URL url = new URL(path); //打开和url之间的连接 HttpURLConnection conn = (H...
HttpClient Post 二进制/字节流/byte[]
SomeTimes
06-03 2万+
HttpClient 3.x HttpClient 4.x
【学习笔记】手写 Tomcat 三
最新发布
LearnTech_123的博客
09-12 1109
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
java发起http请求
05-26
Java 可以使用内置的 `java.net` 包来发起 HTTP 请求。以下是一个示例： ```java import java.net.*; import java.io.*; public class HttpRequest { public static void main(String[] args) throws Exception {...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值