httpClient常用类整理

最新推荐文章于 2021-07-20 22:01:21 发布
最新推荐文章于 2021-07-20 22:01:21 发布
阅读量493 收藏
点赞数
分类专栏： core
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46681279/article/details/106792235
版权 

```csharp
namespace CoreHuaXia.Common
{
    #region Using

    using global::System;
    using global::System.Collections.Generic;
    using global::System.Linq;
    using global::System.Net.Http;
    using global::System.Net.Http.Headers;
    using global::System.Reflection;

    using Newtonsoft.Json;
    using System.IO;

    #endregion

    public static class LightingHttpClient
    {
        internal static readonly HttpClient L_HttpClient;

        static LightingHttpClient()
        {
            L_HttpClient = new HttpClient();
            L_HttpClient.Timeout = TimeSpan.FromSeconds(120);
        }
        static int HttpCount = 0;
        public static string Get(string url, object urldatas, Action<Exception> error = null, object headerdatas = null)
        {
            string content = "";

            List<Tuple<string, string>> parlist = ObjectPropertiesConvertKeyValuePirs(urldatas);
            List<Tuple<string, string>> headerlist = ObjectPropertiesConvertKeyValuePirs(headerdatas);

            url = ConvertToUrl(url, parlist);

            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, url);

            foreach (Tuple<string, string> header in headerlist)
            {
                request.Headers.Add(header.Item1, header.Item2);
            }

            request.Headers.Add("Connection", "close");
            try
            {
                HttpResponseMessage response = L_HttpClient.SendAsync(request).Result;

                if ((Action<Exception>)null != error)
                {
                    if (!response.IsSuccessStatusCode)
                    {
                        //不成功再执行一次
                        try
                        {
                            response.EnsureSuccessStatusCode();
                        }
                        catch (HttpRequestException e)
                        {
                            error(e);
                        }
                    }
                    else
                    {
                        content = response.Content.ReadAsStringAsync().Result;
                    }
                }
            }
            catch (Exception e)
            {

                error(e);
            }

            return content;
        }

        public static string Post(string url, object datas, Action<Exception> error = null, object headerdatas = null)
        {
            string content = "";
            List<Tuple<string, string>> parlist = ObjectPropertiesConvertKeyValuePirs(datas);
            List<Tuple<string, string>> headerlist = ObjectPropertiesConvertKeyValuePirs(headerdatas);

            List<KeyValuePair<string, string>> urlpars = ConvertToKeyValuePair(parlist);

            FormUrlEncodedContent urlcontent = new FormUrlEncodedContent(urlpars);

            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, url);

            foreach (Tuple<string, string> header in headerlist)
            {
                request.Headers.Add(header.Item1, header.Item2);
            }

            request.Headers.Add("Connection", "close");

            request.Content = urlcontent;

            try
            {
                HttpResponseMessage response = L_HttpClient.SendAsync(request).Result;

                if ((Action<Exception>)null != error)
                {
                    if (!response.IsSuccessStatusCode)
                    {
                        try
                        {
                            response.EnsureSuccessStatusCode();
                        }
                        catch (HttpRequestException e)
                        {
                            error(e);
                        }
                    }
                    else
                    {
                        content = response.Content.ReadAsStringAsync().Result;
                    }
                }
            }
            catch (Exception e)
            {
                error(e);
            }

            return content;
        }

        public static string Put(string url, object datas, Action<Exception> error = null, object headerdatas = null)
        {
            string content = "";
            List<Tuple<string, string>> parlist = ObjectPropertiesConvertKeyValuePirs(datas);
            List<Tuple<string, string>> headerlist = ObjectPropertiesConvertKeyValuePirs(headerdatas);

            List<KeyValuePair<string, string>> urlpars = ConvertToKeyValuePair(parlist);

            FormUrlEncodedContent urlcontent = new FormUrlEncodedContent(urlpars);

            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Put, url);

            foreach (Tuple<string, string> header in headerlist)
            {
                request.Headers.Add(header.Item1, header.Item2);
            }

            request.Headers.Add("Connection", "close");

            request.Content = urlcontent;

            try
            {
                HttpResponseMessage response = L_HttpClient.SendAsync(request).Result;

                if ((Action<Exception>)null != error)
                {
                    if (!response.IsSuccessStatusCode)
                    {
                        try
                        {
                            response.EnsureSuccessStatusCode();
                        }
                        catch (HttpRequestException e)
                        {
                            error(e);
                        }
                    }
                    else
                    {
                        content = response.Content.ReadAsStringAsync().Result;
                    }
                }
            }
            catch (Exception e)
            {
                error(e);
            }

            return content;
        }

        public static string Delete(string url, object datas, Action<Exception> error = null, object headerdatas = null)
        {
            string content = "";
            List<Tuple<string, string>> parlist = ObjectPropertiesConvertKeyValuePirs(datas);
            List<Tuple<string, string>> headerlist = ObjectPropertiesConvertKeyValuePirs(headerdatas);

            url = ConvertToUrl(url, parlist);

            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Delete, url);

            foreach (Tuple<string, string> header in headerlist)
            {
                request.Headers.Add(header.Item1, header.Item2);
            }

            request.Headers.Add("Connection", "close");

            try
            {
                HttpResponseMessage response = L_HttpClient.SendAsync(request).Result;

                if ((Action<Exception>)null != error)
                {
                    if (!response.IsSuccessStatusCode)
                    {
                        try
                        {
                            response.EnsureSuccessStatusCode();
                        }
                        catch (HttpRequestException e)
                        {
                            error(e);
                        }
                    }
                    else
                    {
                        content = response.Content.ReadAsStringAsync().Result;
                    }
                }
            }
            catch (Exception e)
            {
                error(e);
            }

            return content;
        }

        public static string PostAsJSON<T>(string url, T value, Action<Exception> error = null, object headerdatas = null)
        {
            string content = "";
            List<Tuple<string, string>> headerlist = ObjectPropertiesConvertKeyValuePirs(headerdatas);

            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, url);

            foreach (Tuple<string, string> header in headerlist)
            {
                request.Headers.Add(header.Item1, header.Item2);
            }

            request.Headers.Add("Connection", "close");

            StringContent stringcontent = new StringContent(JsonConvert.SerializeObject(value));
            stringcontent.Headers.ContentType = new MediaTypeHeaderValue("application/json");

            request.Content = stringcontent;
            try
            {
                HttpResponseMessage response = L_HttpClient.SendAsync(request).Result;

                if ((Action<Exception>)null != error)
                {
                    if (!response.IsSuccessStatusCode)
                    {
                        try
                        {
                            response.EnsureSuccessStatusCode();
                        }
                        catch (HttpRequestException e)
                        {
                            error(e);
                        }
                    }
                    else
                    {
                        content = response.Content.ReadAsStringAsync().Result;
                    }
                }
            }
            catch (Exception e)
            {
                error(e);
            }
            return content;
        }
        
        public static string Form(string url, string filePath, Action<Exception> error = null, object headerdatas = null)
        {
            string content = "";
            List<Tuple<string, string>> headerlist = ObjectPropertiesConvertKeyValuePirs(headerdatas);

            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, url);

            foreach (Tuple<string, string> header in headerlist)
            {
                request.Headers.Add(header.Item1, header.Item2);
            }
            request.Headers.Add("Connection", "keep-alive");
            MultipartFormDataContent mContent = new MultipartFormDataContent();
            if (File.Exists(filePath))
            {
                StreamContent fileContent = new StreamContent((Stream)new MemoryStream(File.ReadAllBytes(filePath)));
                fileContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    FileName = Path.GetFileName("huaxia." + filePath.Substring(filePath.LastIndexOf("."))),
                    Name = "file"
                };
                fileContent.Headers.Add("ContentType", "application/octet-stream");

                mContent.Add(fileContent);
                request.Content = mContent;
            }
            try
            {
                HttpResponseMessage response = L_HttpClient.SendAsync(request).Result;
                if ((Action<Exception>)null != error)
                {
                    if (!response.IsSuccessStatusCode)
                    {
                        try
                        {
                            response.EnsureSuccessStatusCode();
                        }
                        catch (HttpRequestException e)
                        {
                            error(e);
                        }
                    }
                    else
                    {
                        content = response.Content.ReadAsStringAsync().Result;
                    }
                }
            }
            catch (Exception e)
            {
                error(e);
            }

            return content;
        }

        public static string PostAsJSONNonSingleton<T>(HttpClient myhttpClient, string url, T value, Action<Exception> error = null, object headerdatas = null)
        {
            string content = "";
            List<Tuple<string, string>> headerlist = ObjectPropertiesConvertKeyValuePirs(headerdatas);

            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, url);

            foreach (Tuple<string, string> header in headerlist)
            {
                request.Headers.Add(header.Item1, header.Item2);
            }

            request.Headers.Add("Connection", "close");

            StringContent stringcontent = new StringContent(JsonConvert.SerializeObject(value));
            stringcontent.Headers.ContentType = new MediaTypeHeaderValue("application/json");

            request.Content = stringcontent;
            try
            {
                HttpResponseMessage response = myhttpClient.SendAsync(request).Result;

                if ((Action<Exception>)null != error)
                {
                    if (!response.IsSuccessStatusCode)
                    {
                        try
                        {
                            response.EnsureSuccessStatusCode();
                        }
                        catch (HttpRequestException e)
                        {
                            error(e);
                        }
                    }
                    else
                    {
                        content = response.Content.ReadAsStringAsync().Result;
                    }
                }
            }
            catch (Exception e)
            {
                error(e);
            }
            return content;
        }

        #region Private Methods

        private static List<Tuple<string, string>> ObjectPropertiesConvertKeyValuePirs(object obj)
        {
            List<Tuple<string, string>> parlist = new List<Tuple<string, string>>();

            if (null != obj)
            {
                PropertyInfo[] propertys = obj.GetType().GetProperties();

                foreach (PropertyInfo propertyinfo in propertys)
                {
                    if (typeof(string) == propertyinfo.PropertyType)
                    {
                        string pkey = propertyinfo.Name.Trim();
                        string pvalue = (propertyinfo.GetValue(obj) == null) ? "" : propertyinfo.GetValue(obj).ToString();

                        parlist.Add(new Tuple<string, string>(pkey, pvalue));
                    }
                }
            }

            return parlist;
        }

        private static List<KeyValuePair<string, string>> ConvertToKeyValuePair(List<Tuple<string, string>> from)
        {
            List<KeyValuePair<string, string>> to = new List<KeyValuePair<string, string>>(from.Count);

            to.AddRange(@from.Select(tuple => new KeyValuePair<string, string>(tuple.Item1, tuple.Item2)));

            return to;
        }

        private static string ConvertToUrl(string url, List<Tuple<string, string>> from)
        {
            return @from.Aggregate(url, (current, tuple) => current + (((current.Contains("?")) ? "&" : "?") + tuple.Item1 + "=" + tuple.Item2));
        }

        #endregion
    }
}
赖龙
关注
专栏目录
2. HttpClient类
singhwong
06-04 919
HttpClient类用于发送HTTP请求，接收请求的响应。它在System.Net.Http名称空间中。System.Net.Http名称空间中的类有助于简化在客户端和服务器上使用Web服务。 HttpClient类派生于HttpMessageInvoker类，这个基类负责执行SendAsync方法。SendAsync方法是HttpClient类的主干。如本节后面所述，这个方法有几个派生物。顾名思义，SendAsync方法调用是异步的，这样就可以编写一个完全异步的系统来调用Web服务。 ...
C#——如何使用HttpClient类实现Http通信
最新发布
weixin_59555766的博客
07-13 1574
HttpClient类实例充当发送HTTP请求的会话。HttpClient实例是应用于该实例执行的所有请求的设置集合。此外，每个HttpClient实例都使用自己的连接池，将自己的请求与其他HttpClient实例执行的请求隔离开来。
HTTPClient工具类，完整
08-07
HTTPClient工具类，完整，HTTPClient工具类，完整，HTTPClient工具类，完整HTTPClient工具类，完整，HTTPClient工具类，完整
HttpClient（附带工具类）
鹿慕溪水的博客
07-24 1883
一、特性 1. 基于标准、纯净的java语言。实现了Http1.0和Http1.1 2. 以可扩展的面向对象的结构实现了Http全部的方法（GET, POST, PUT, DELETE, HEAD, OPTIONS, and TRACE）。 3. 支持HTTPS协议。 4. 通过Http代理建立透明的连接。 5. 利用CONNECT方法通过Http代理建立隧道的https连接。 6. ...
Day04JavaWeb【Request】请求行
翁老师的教学团队
09-10 614
Http协议回顾 （1）Http协议是什么？ HTTP协议：超文本传输协议（HTTP，HyperText Transfer Protocol)是互联网上应用最为广泛的一种网络协议。用于定义WEB浏览器与WEB服务器之间交换数据的过程 （2）有什么特点？ 基于请求/响应模型的协议。请求和响应必须成对；先有请求后有响应。 HTTP协议默认的端口:80 Mysql 3306 Tomcat 8080 request-概述 （1）什么是request? 有两种含义 A：Http中的request B：Servle
分享一下常用的httpclient工具类
wwwzhouzy的专栏
07-20 647
一、需要Authorization权限认证的 传递的参数进行URLEncode编码的，HttpUtils.java package com.zhouzy.base.http; import java.util.ArrayList; import java.util.Base64; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; import org.apach
精心整理的java常用的26个工具类
09-15
精心整理的26个java常用工具类，如：FastJsonUtil，StringHelper，RandomHelper，FileHelper，HttpClientHelper等等，直接使用maven导入到eclipse中使用即可。
httpclient介绍及常用方法mm文档
06-25
httpclient的介绍以及基本方法整理
C#常用类整理 都是工作中用到的
12-31
在C#编程语言中，有许多常用的类用于构建各种应用程序，特别是在ASP.NET开发、数据库操作（如SQL）以及软件项目实施中。以下是一些关键的知识点，这些知识点在工作中的使用非常广泛： 1. **System.IO**: 这个命名...
精心整理的编程常用的58个类打包分享
03-15
这些文件代表了编程中不同领域的实用工具类，涵盖了硬件交互、网络通信、数据库操作、文件管理、图像处理、文本操作以及网页解析等多个方面。以下是对每个类可能包含的知识点的详细解释： 1. **AmazonReference.cs*...
.net 开发常用类 通用类集
12-31
至于压缩包内的`Common`文件夹，很可能包含了作者整理的一些自定义通用类。这些类可能扩展了.NET BCL的功能，或者提供了特定场景下的便利方法，比如日志记录、缓存管理、数据验证等。为了提高代码的可维护性和可读性...
HTTP Client C++实现
01-15
CHttpClient.rar HTTP Client C++实现
httpclient工具类
qq279071978的专栏
01-18 754
1.引入maven依赖 <dependency> <groupId>commons-httpclient</groupId> <artifactId>commons-httpclient</artifactId> <version>3.1</version> </dependency>2.HttpC
HTTP Client 的类
czw698的专栏
10-23 616
类的主要方法见附件 在spring 中的配置 使用方式：
httpclient工具类分享
coding不止的博客
01-06 398
因最近在做一个下载功能，所以学习了一下httpClient，现在给大家分享一下我写的httpClient工具类： 该工具类依赖以下jar包： dependency> groupId>commons-httpclientgroupId> artifactId>commons-httpclientartifactId> version>${commons-httpcl
写的一个HttpClient类
liehen2046的专栏
06-25 83
package com.ca.test.cainterface.common.util.http; import com.ca.test.cainterface.common.util.data.Data; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.databind...
网络请求之HttpClient 类的使用
xxs1984的专栏
11-28 1132
HttpClient httpclient = new DefaultHttpClient(); // Prepare a request object HttpGet httpget = new HttpGet("http://www.apache.org/"); // Execute the request HttpResponse response = h
httpClient工具类
pengjwhx的博客
01-14 304
1. 概念 httpClient区分 HttpComponent 是 apache-commons区别：在apache的官网上下载httpclient的jar包时，会发现它是在一个叫HttpComponent的项目下，这个HttpComponent是apache的顶级项目。而以前的commons的那三个包都是commons的项目下，原来，commons-httpclient 是 apache-co...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值