httpClient 请求

最新推荐文章于 2024-05-03 21:17:42 发布
最新推荐文章于 2024-05-03 21:17:42 发布
阅读量193 收藏
点赞数
分类专栏： 小点滴
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39509262/article/details/84560951
版权 

import java.io.*;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.MultipartEntity;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;

import net.sf.json.JSONObject;

public class ClientUtil {


    private static final String FAR_SERVICE_DIR = "http://192.168.10.88:8080/getService";
    private static final long yourMaxRequestSize = 10000000;

    public  Logger logger = LoggerFactory.getLogger(this.getClass());

    public String upload(HttpServletRequest request) throws Exception {
        // 判断enctype属性是否为multipart/form-data
        boolean isMultipart = ServletFileUpload.isMultipartContent(request);
        if (!isMultipart)
            throw new IllegalArgumentException(
                    "上传内容不是有效的multipart/form-data类型.");

        // Create a factory for disk-based file items
        DiskFileItemFactory factory = new DiskFileItemFactory();

        // Create a new file upload handler
        ServletFileUpload upload = new ServletFileUpload(factory);

        // 设置上传内容的大小限制（单位：字节）
        upload.setSizeMax(yourMaxRequestSize);

        // Parse the request
        List<?> items = upload.parseRequest(request);

        Iterator iter = items.iterator();
        while (iter.hasNext()) {
            FileItem item = (FileItem) iter.next();

            if (item.isFormField()) {
                // 如果是普通表单字段
                String name = item.getFieldName();
                String value = item.getString();
                // ...
            } else {
                // 如果是文件字段
                String fieldName = item.getFieldName();
                String fileName = item.getName();
                String contentType = item.getContentType();
                boolean isInMemory = item.isInMemory();
                long sizeInBytes = item.getSize();
                // ...

                // 上传到远程服务器
                HashMap<String, FileItem> files = new HashMap<String, FileItem>();
                files.put(fileName, item);
                uploadToFarServiceByHttpClient(files);
            }
        }
        return "redirect:/";
    }

    private void uploadToFarServiceByHttpClient(HashMap<String, FileItem> files) {
        HttpClient httpclient = new DefaultHttpClient();
        try {
            HttpPost httppost = new HttpPost(FAR_SERVICE_DIR);
            MultipartEntity reqEntity = new MultipartEntity();
            Iterator iter = files.entrySet().iterator();
            while (iter.hasNext()) {
                Map.Entry entry = (Map.Entry) iter.next();
                String key = (String) entry.getKey();
                FileItem val = (FileItem) entry.getValue();
                FileBody filebdody = new FileBody(inputstreamtofile(
                        val.getInputStream(), key));
                reqEntity.addPart(key, filebdody);
            }
            httppost.setEntity(reqEntity);

            HttpResponse response = httpclient.execute(httppost);

            int statusCode = response.getStatusLine().getStatusCode();

            if (statusCode == HttpStatus.SC_OK) {
                System.out.println("服务器正常响应.....");
                HttpEntity resEntity = response.getEntity();
                System.out.println(EntityUtils.toString(resEntity,"UTF-8"));// httpclient自带的工具类读取返回数据
                EntityUtils.consume(resEntity);
            }

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            try {
                httpclient.getConnectionManager().shutdown();
            } catch (Exception ignore) {

            }
        }

    }

    public File inputstreamtofile(InputStream ins, String filename)
            throws IOException {
        File file = new File(filename);
        OutputStream os = new FileOutputStream(file);
        int bytesRead = 0;
        byte[] buffer = new byte[8192];
        while ((bytesRead = ins.read(buffer, 0, 8192)) != -1) {
            os.write(buffer, 0, bytesRead);
        }
        os.close();
        ins.close();
        return file;
    }



    public static void upload2() throws ClientProtocolException, IOException{
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        CloseableHttpResponse httpResponse = null;
        RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(200000).setSocketTimeout(200000000).build();
        HttpPost httpPost = new HttpPost("http://127.0.0.1:8081/sys/TestData");
        httpPost.setConfig(requestConfig);
        MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create();
        //multipartEntityBuilder.setCharset(Charset.forName("UTF-8"));

        //File file = new File("F:\\Ken\\1.PNG");
        //FileBody bin = new FileBody(file); 

        File file = new File("E:\\destdir\\新建文本文档.txt");

        //multipartEntityBuilder.addBinaryBody("file", file,ContentType.create("image/png"),"abc.pdf");
        //当设置了setSocketTimeout参数后，以下代码上传PDF不能成功，将setSocketTimeout参数去掉后此可以上传成功。上传图片则没有个限制
        //multipartEntityBuilder.addBinaryBody("file",file,ContentType.create("application/octet-stream"),"abd.pdf");
        multipartEntityBuilder.addBinaryBody("file",file);
        //multipartEntityBuilder.addPart("comment", new StringBody("This is comment", ContentType.TEXT_PLAIN));
        multipartEntityBuilder.addTextBody("comment", "this is comment");
        HttpEntity httpEntity = multipartEntityBuilder.build();
        httpPost.setEntity(httpEntity);

        httpResponse = httpClient.execute(httpPost);
        HttpEntity responseEntity = httpResponse.getEntity();
        int statusCode= httpResponse.getStatusLine().getStatusCode();
        if(statusCode == 200){
            BufferedReader reader = new BufferedReader(new InputStreamReader(responseEntity.getContent()));
            StringBuffer buffer = new StringBuffer();
            String str = "";
            while(!"".equals(str = reader.readLine())) {
                buffer.append(str);
            }

            System.out.println(buffer.toString());
        }

        httpClient.close();
        if(httpResponse!=null){
            httpResponse.close();
        }

    }

    public static void main(String[] args) {
//        File file = new File("E:\\destdir\\协助查询财产通知书.jpg");
//        Map<String, String> params = new HashMap();
//        params.put("fileName", file.getName());
//        params.put("userId", "25252525");
//        String url = "http://127.0.0.1:8081/sys/uploadFile";
//        String result = post(url,params,file);
    	
    	String invokeUrl="http://10.12.223.230:8581/GatewayMsg/rest/invoke";
    	String	userName="wangqigong";
    	String	certNo="350301198906180060";
    	String	deptNo="5555";
    	String	szzsbm="555";
    	String senderId="C00-20000004";
    	String serviceId="S10-20000070";
    	String task_period = "60";
    	String json = "{\"endUser\":\"wangqigong,350301198906180060,5555,555\"}";
    
//    	String result = post2(invokeUrl,senderId,serviceId,json,task_period);
//    	System.out.println(result);
    	
    	Map<String, String> params = new HashMap<String,String>();
    	RestTemplate template = new RestTemplate();
    	HttpHeaders httpHeaders = new HttpHeaders();
    	httpHeaders.add("sender_id", senderId);
    	httpHeaders.add("service_id", serviceId);
    	//请求用户信息
    	try {
    	    //中文需要先编码、不然获取会乱码
    	    httpHeaders.add("fingerprint", "{\"endUser\":\""+ URLEncoder.encode(userName,"UTF-8")+","+certNo+","+deptNo+","+szzsbm+"\"}");
    	} catch (UnsupportedEncodingException e) {
    	    e.printStackTrace();
    	}
    	//任务超时时间
    	httpHeaders.add("task_period", "60");
    	String body = null;
    	org.springframework.http.HttpEntity<String> requestEntity = new org.springframework.http.HttpEntity<String>(body, httpHeaders);
    	try {
    	    System.out.println("fsdfs");
    	    ResponseEntity<String> responseEntity = template.exchange(invokeUrl, HttpMethod.GET, requestEntity, String.class, params);
    	    String resulr = responseEntity.getBody();
    	    int i = responseEntity.getStatusCode().value();
    	    System.out.print(i+"========="+resulr);
    	}catch(Exception e){
    		e.printStackTrace();
    	}
      	
    	
    }

    /**
     * client的post传文件
     * @param url
     * @param params
     * @param file
     * @return
     */
    public String post(String url,Map<String, String> params,File file) {
       String result = "";
        CloseableHttpClient httpclient = HttpClients.createDefault();
        //CloseableHttpClient httpclient = HttpClientBuilder.create().build();
        try {
            HttpPost httppost = new HttpPost(url);
            

            RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(200000).setSocketTimeout(200000).build();
            httppost.setConfig(requestConfig);

            StringBody comment = new StringBody("This is comment", ContentType.create("text/plain", Consts.UTF_8));

            MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create();
            setUploadParams(multipartEntityBuilder, params);
            if(file != null){
            	FileBody bin = new FileBody(file);
            	HttpEntity reqEntity = multipartEntityBuilder.addPart("multipartFile", bin).addPart("comment", comment).build();
            	httppost.setEntity(reqEntity);
            }else{
            	HttpEntity reqEntity = multipartEntityBuilder.addPart("comment", comment).build();
            	httppost.setEntity(reqEntity);
            }
//            HttpEntity reqEntity = multipartEntityBuilder.addPart("file", bin).addPart("comment", comment).build();

//            httppost.setEntity(reqEntity);

            System.out.println("executing request " + httppost.getRequestLine());
            CloseableHttpResponse response = httpclient.execute(httppost);
            try {
                System.out.println(response.getStatusLine());
                HttpEntity resEntity = response.getEntity();
                if (resEntity != null) {
                    result = EntityUtils.toString(response.getEntity());
//                    System.out.println(result);
//                    System.out.println("Response content length: " + resEntity.getContentLength());
                }
                EntityUtils.consume(resEntity);
            } finally {
                response.close();
            }
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                httpclient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    /**
     * 设置请求参数
     * @param multipartEntityBuilder
     * @param params
     */
    private static void setUploadParams(MultipartEntityBuilder multipartEntityBuilder,  Map<String, String> params) {
        if (params != null && params.size() > 0) {
            Set<String> keys = params.keySet();
            for (String key : keys) {
                multipartEntityBuilder .addPart(key, new StringBody(params.get(key), ContentType.create("text/plain", Consts.UTF_8)));
            }
        }
    }
    
    /**
     * get请求
     * @param invokeUrl
     * @param senderId
     * @param serviceId
     * @param json
     * @param task_period
     * @param userName
     * @param certNo
     * @param deptId 单位代码
     * @param szzsbm
     * @return
     */
    public  String get(String invokeUrl, String senderId, String serviceId,  String task_period,String userName,String certNo,String deptId,String szzsbm ) {
     	String resultUrl = "";
    	Map<String, String> params = new HashMap<String,String>();
    	RestTemplate template = new RestTemplate();
    	HttpHeaders httpHeaders = new HttpHeaders();
    	httpHeaders.add("sender_id", senderId);
    	httpHeaders.add("service_id", serviceId);
    	//请求用户信息
    	try {
    	    //中文需要先编码、不然获取会乱码
    	    httpHeaders.add("fingerprint", "{\"endUser\":\""+ URLEncoder.encode(userName,"UTF-8")+","+certNo+","+deptId+","+szzsbm+"\"}");
    	  //任务超时时间
        	httpHeaders.add("task_period", task_period);
        	String body = null;
        	org.springframework.http.HttpEntity<String> requestEntity = new org.springframework.http.HttpEntity<String>(body, httpHeaders);
        	System.out.println("fsdfs");
     	    ResponseEntity<String> responseEntity = template.exchange(invokeUrl, HttpMethod.GET, requestEntity, String.class, params);
     	    int i = responseEntity.getStatusCode().value();
     	   logger.info("请求状态:"+i);
     	    if(i == 200){
     	    	String resulr = responseEntity.getBody();
     	    	JSONObject jsonObj = JSONObject.fromObject(resulr);
     	    	resultUrl = jsonObj.get("url").toString();
     	    }
    	} catch (UnsupportedEncodingException e) {
    	    e.printStackTrace();
    	}
    	
    	return resultUrl;
      	
     }
    
    
    public  String getToSendCode(String url,Map<String, String> params, Map<String,String> paramHead) {
    	String result = "";
        CloseableHttpClient httpclient = HttpClients.createDefault();
        //CloseableHttpClient httpclient = HttpClientBuilder.create().build();
        try {
            HttpPost httppost = new HttpPost(url);
            

            RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(200000).setSocketTimeout(200000).build();
            httppost.setConfig(requestConfig);
            MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create();
            setUploadParams(multipartEntityBuilder, params);
           
            HttpEntity reqEntity = multipartEntityBuilder.build();
        	httppost.setEntity(reqEntity);
        	httppost.setHeader("stepNum", paramHead.get("stepNum"));
        	httppost.setHeader("receiveAppId", paramHead.get("receiveAppId"));
        	httppost.setHeader("invokingAppId", paramHead.get("invokingAppId"));
        	httppost.setHeader("processNum", paramHead.get("processNum"));

            System.out.println("executing request " + httppost.getRequestLine());
            CloseableHttpResponse response = httpclient.execute(httppost);
            try {
                System.out.println(response.getStatusLine());
                HttpEntity resEntity = response.getEntity();
                if (resEntity != null) {
                    result = EntityUtils.toString(response.getEntity());
//                    System.out.println(result);
//                    System.out.println("Response content length: " + resEntity.getContentLength());
                }
                EntityUtils.consume(resEntity);
            } finally {
                response.close();
            }
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                httpclient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
      	
     }
     

}

httpmime-4.5.3.jar

httpclient-4.5.3.jar

小样yb
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HttpClient请求
12-17
android中使用HttpClient请求资源并返回数据
java发送HttpClient请求及接收请求结果过程的简单实例
09-01
下面将详细解释如何使用HttpClient发送请求以及处理返回结果的过程。 首先，我们需要导入必要的依赖库，这通常包括Apache HttpClient库和JSON处理库，如net.sf.json.JSONObject。在本例中，我们看到代码使用了`org....
httpClient请求
托妞专栏
08-17 354
import java.util.ArrayList; import java.util.Date; import java.util.List; import org.apache.http.HttpResponse; import org.apache.http.NameValuePair; import org.apache.http.client.entity.UrlEncodedFor...
java中HttpClient使用【含例子】
最新发布
hac1322的博客
05-03 1520
但是，如果你在使用Java 11之前的版本，并且想要使用类似的功能，你可能需要引入第三方库的依赖，如Apache HttpClient。通过HttpRequest对象，您可以设置请求的URL、请求方法、请求头、请求体等信息，并构建一个完整的HTTP请求对象，用于发送给服务器。它提供了一种简单且一致的方式来执行HTTP操作，包括同步和异步的请求发送、连接池管理、请求和响应的拦截器等功能。被设计成与Java平台更好地集成，使得开发者能够更轻松地处理HTTP请求和响应，同时减少了对外部库的依赖。
使用HttpClient操作请求
轻风木竹
06-16 324
HttpClientBuilder httpClientBuilder =HttpClientBuilder.create(); CloseableHttpClient build = httpClientBuilder.build(); HttpPost post = new HttpPost("http://www.apache.org/"); CloseableHttpResponse ex
httpclient 请求http数据,json转map的实例
10-20
在Java编程中，HTTP客户端库Apache HttpClient是一个常用的工具，用于发送HTTP请求并接收响应。在本例中，我们将讨论如何使用HttpClient来获取HTTP数据，并将接收到的JSON格式的响应数据转换为Map对象。以下是对这个...
HttpURLConnection请求和HttpClient请求
12-04
HttpURLConnection请求和HttpClient请求...................................................................
HttpClient使用详解
cihongmo6452的博客
08-01 762
Http协议的重要性相信不用我多说了，HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性（具体区别，日后我们再讨论），它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。因...
利用HttpClient发送HTTP请求
06-14
利用HttpClient发送HTTP请求 利用HttpClient发送HTTP请求
httpclient请求方式+cookies
12-11
httpclient 请求两种方式,如果有cookie可加上cookies，同步获取返回值
HttpClient请求之基础
07-12
HttpClient请求（get请求、post请求）
JAVA发送HttpClient请求及接收请求结果过程
11-04
JAVA发送HttpClient请求及接收请求结果过程
JAVA发送HttpClient请求及接收请求完整代码实例
08-13
NULL 博文链接：https://bijian1013.iteye.com/blog/2310211
HttpClient发送请求
weixin_43573186的博客
11-14 3749
HttpClient发送请求 前言：前段时间接到一个需求，要求系统中实现一个可以上传语音文件的功能，然后将文件和需要的参数发送到电信的接口上； 开始说起来感觉很简单，但是就真的被折磨了好几天，主要还是httpClient发送文件和参数到指定url，还有要从公司内网调中台再调电信接口这个过程花费了不少时间。既然涉及到了文件的上传，就想着把涉及到的东西都系统的学一遍，毕竟之前也没做过这些。 HttpClient请求数据到指定接口 对于通过HttpClien发送文件，就要先了解HttpClient的知识了； Ht
Httpclient发送http请求
zj972535075的专栏
03-07 972
1.引入httpclient 所需要的jars<dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpclient</artifactId> <version>4.5.2</version> </dependency> <dependency> <groupId>org.apa
httpClient请求超详解
Xunyinyiran的博客
11-25 5307
@# 常用httpClient 文章目录前言一、引入依赖二、httpClient请求1.Get请求2.读入数据总结 前言 在和其它一下系统进行交互的时候，我们经常需要调用第三方和其它一些系统的接口，那么httpClient的出现就很好的解决了这个问题，下面将对常用的httpClient请求演示。 一、引入依赖 <dependency> <groupId>org.apache.httpcomponents</groupId>
httpclient 请求post接口
05-03
好的，以下是使用Apache HttpClient请求POST接口的示例代码： ```java import java.io.IOException; import java.io.UnsupportedEncodingException; import java.nio.charset.StandardCharsets; import org.apache....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值