（4）学习笔记） ASP.NET CORE微服务 Micro-Service ---- Consul服务发现和消费-低调大师

（4）学习笔记） ASP.NET CORE微服务 Micro-Service ---- Consul服务发现和消费

2018-06-21 610

上一章说了 Consul服务注册现在我要连接上Consul里面的服务请求它们的API接口应该怎么做呢？

1.找Consul要一台你需要的服务器

1.1 获取Consul下的所有注册的服务

using (var consulClient = new ConsulClient(c => c.Address = new Uri("http://127.0.0.1:8500"))) 
{ 
 　　var services = consulClient.Agent.Services().Result.Response;  
　　 foreach(var service in services.Values) 
     { 
 　　　　　　Console.WriteLine($"id={service.ID},name={service.Service},ip={service.Address},port={service.Port}"); 
     } 
}

1.2 随机取一个Name为MsgService的服务

下面的代码使用当前 TickCount 进行取模的方式达到随机获取一台服务器实例的效果，这叫做“客户端负载均衡”：

using (var consulClient = new ConsulClient(c => c.Address = new Uri("http://127.0.0.1:8500"))) 
{ 
     var services = consulClient.Agent.Services().Result.Response.Values.Where(s => s.Service.Equals("MsgService", StringComparison.OrdinalIgnoreCase));  
     if(!services.Any()) 
     { 
          Console.WriteLine("找不到服务的实例"); 
     } 
     else 
     { 
          var service = services.ElementAt(Environment.TickCount%services.Count()); 
          Console.WriteLine($"{service.Address}:{service.Port}"); 
     } 
} 

当然在一个毫秒之类会所有请求都压给一台服务器，基本就够用了。也可以自己写随机、轮询等客户端负载均衡算法，也可以自己实现按不同权重分配（注册时候 Tags 带上配置、权重等信息）等算法。

2.请求服务器的接口

你拿到了http地址难道还不会请求接口么找个httphelper 直接请求就好了如果还是不会就来群里问吧群号：608188505

给大家上一个我常用的httphelper 可能被我该的不像样了不过相信大家都会用不会的话来群里找我吧。

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Diagnostics;
  4 using System.IO;
  5 using System.IO.Compression;
  6 using System.Linq;
  7 using System.Net;
  8 using System.Net.Security;
  9 using System.Runtime.InteropServices;
 10 using System.Security.Cryptography.X509Certificates;
 11 using System.Text;
 12 using System.Text.RegularExpressions;
 13 using System.Threading.Tasks;
 14 
 15 namespace ClientApp
 16 {/// <summary>
 17  /// Http连接操作帮助类
 18  /// </summary>
 19     public class HttpHelper
 20     {
 21         private const int ConnectionLimit = 100;
 22         //编码
 23         private Encoding _encoding = Encoding.Default;
 24         //浏览器类型
 25         private string[] _useragents = new string[]{
 26             "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.90 Safari/537.36",
 27             "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.1; WOW64; Trident/7.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0)",
 28             "Mozilla/5.0 (Windows NT 6.1; rv:36.0) Gecko/20100101 Firefox/36.0",
 29             "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:31.0) Gecko/20130401 Firefox/31.0"
 30         };
 31 
 32         private String _useragent = "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.90 Safari/537.36";
 33         //接受类型
 34         private String _accept = "text/html, application/xhtml+xml, application/xml, */*";
 35         //超时时间
 36         private int _timeout = 30 * 1000;
 37         //类型
 38         private string _contenttype = "application/x-www-form-urlencoded";
 39         //cookies
 40         private String _cookies = "";
 41         //cookies
 42         private CookieCollection _cookiecollection;
 43         //custom heads
 44         private Dictionary<string, string> _headers = new Dictionary<string, string>();
 45 
 46         public HttpHelper()
 47         {
 48             _headers.Clear();
 49             //随机一个useragent
 50             _useragent = _useragents[new Random().Next(0, _useragents.Length)];
 51             //解决性能问题?
 52             ServicePointManager.DefaultConnectionLimit = ConnectionLimit;
 53         }
 54 
 55         public void InitCookie()
 56         {
 57             _cookies = "";
 58             _cookiecollection = null;
 59             _headers.Clear();
 60         }
 61 
 62         /// <summary>
 63         /// 设置当前编码
 64         /// </summary>
 65         /// <param name="en"></param>
 66         public void SetEncoding(Encoding en)
 67         {
 68             _encoding = en;
 69         }
 70 
 71         /// <summary>
 72         /// 设置UserAgent
 73         /// </summary>
 74         /// <param name="ua"></param>
 75         public void SetUserAgent(String ua)
 76         {
 77             _useragent = ua;
 78         }
 79 
 80         public void RandUserAgent()
 81         {
 82             _useragent = _useragents[new Random().Next(0, _useragents.Length)];
 83         }
 84 
 85         public void SetCookiesString(string c)
 86         {
 87             _cookies = c;
 88         }
 89 
 90         /// <summary>
 91         /// 设置超时时间
 92         /// </summary>
 93         /// <param name="sec"></param>
 94         public void SetTimeOut(int msec)
 95         {
 96             _timeout = msec;
 97         }
 98 
 99         public void SetContentType(String type)
100         {
101             _contenttype = type;
102         }
103 
104         public void SetAccept(String accept)
105         {
106             _accept = accept;
107         }
108 
109         /// <summary>
110         /// 添加自定义头
111         /// </summary>
112         /// <param name="key"></param>
113         /// <param name="ctx"></param>
114         public void AddHeader(String key, String ctx)
115         {
116             //_headers.Add(key,ctx);
117             _headers[key] = ctx;
118         }
119 
120         /// <summary>
121         /// 清空自定义头
122         /// </summary>
123         public void ClearHeader()
124         {
125             _headers.Clear();
126         }
127 
128         /// <summary>
129         /// 获取HTTP返回的内容
130         /// </summary>
131         /// <param name="response"></param>
132         /// <returns></returns>
133         private String GetStringFromResponse(HttpWebResponse response)
134         {
135             String html = "";
136             try
137             {
138                 Stream stream = response.GetResponseStream();
139                 StreamReader sr = new StreamReader(stream, Encoding.UTF8);
140                 html = sr.ReadToEnd();
141 
142                 sr.Close();
143                 stream.Close();
144             }
145             catch (Exception e)
146             {
147                 Trace.WriteLine("GetStringFromResponse Error: " + e.Message);
148             }
149 
150             return html;
151         }
152 
153         /// <summary>
154         /// 检测证书
155         /// </summary>
156         /// <param name="sender"></param>
157         /// <param name="certificate"></param>
158         /// <param name="chain"></param>
159         /// <param name="errors"></param>
160         /// <returns></returns>
161         private bool CheckCertificate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors)
162         {
163             return true;
164         }
165 
166         /// <summary>
167         /// 发送GET请求
168         /// </summary>
169         /// <param name="url"></param>
170         /// <returns></returns>
171         public String HttpGet(String url)
172         {
173             return HttpGet(url, url);
174         }
175 
176 
177         /// <summary>
178         /// 发送GET请求
179         /// </summary>
180         /// <param name="url"></param>
181         /// <param name="refer"></param>
182         /// <returns></returns>
183         public String HttpGet(String url, String refer)
184         {
185             String html;
186             try
187             {
188                 ServicePointManager.ServerCertificateValidationCallback = new System.Net.Security.RemoteCertificateValidationCallback(CheckCertificate);
189                 HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
190                 request.UserAgent = _useragent;
191                 request.Timeout = _timeout;
192                 request.ContentType = _contenttype;
193                 request.Accept = _accept;
194                 request.Method = "GET";
195                 request.Referer = refer;
196                 request.KeepAlive = true;
197                 request.AllowAutoRedirect = true;
198                 request.UnsafeAuthenticatedConnectionSharing = true;
199                 request.CookieContainer = new CookieContainer();
200                 //据说能提高性能
201                 //request.Proxy = null;
202                 if (_cookiecollection != null)
203                 {
204                     foreach (Cookie c in _cookiecollection)
205                     {
206                         c.Domain = request.Host;
207                     }
208 
209                     request.CookieContainer.Add(_cookiecollection);
210                 }
211 
212                 foreach (KeyValuePair<String, String> hd in _headers)
213                 {
214                     request.Headers[hd.Key] = hd.Value;
215                 }
216 
217                 HttpWebResponse response = (HttpWebResponse)request.GetResponse();
218                 html = GetStringFromResponse(response);
219                 if (request.CookieContainer != null)
220                 {
221                     response.Cookies = request.CookieContainer.GetCookies(request.RequestUri);
222                 }
223 
224                 if (response.Cookies != null)
225                 {
226                     _cookiecollection = response.Cookies;
227                 }
228                 if (response.Headers["Set-Cookie"] != null)
229                 {
230                     string tmpcookie = response.Headers["Set-Cookie"];
231                     _cookiecollection.Add(ConvertCookieString(tmpcookie));
232                 }
233 
234                 response.Close();
235                 return html;
236             }
237             catch (Exception e)
238             {
239                 Trace.WriteLine("HttpGet Error: " + e.Message);
240                 return String.Empty;
241             }
242         }
243 
244         /// <summary>
245         /// 获取MINE文件
246         /// </summary>
247         /// <param name="url"></param>
248         /// <returns></returns>
249         public Byte[] HttpGetMine(String url)
250         {
251             Byte[] mine = null;
252             try
253             {
254                 ServicePointManager.ServerCertificateValidationCallback = new System.Net.Security.RemoteCertificateValidationCallback(CheckCertificate);
255                 HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
256                 request.UserAgent = _useragent;
257                 request.Timeout = _timeout;
258                 request.ContentType = _contenttype;
259                 request.Accept = _accept;
260                 request.Method = "GET";
261                 request.Referer = url;
262                 request.KeepAlive = true;
263                 request.AllowAutoRedirect = true;
264                 request.UnsafeAuthenticatedConnectionSharing = true;
265                 request.CookieContainer = new CookieContainer();
266                 //据说能提高性能
267                 request.Proxy = null;
268                 if (_cookiecollection != null)
269                 {
270                     foreach (Cookie c in _cookiecollection)
271                         c.Domain = request.Host;
272                     request.CookieContainer.Add(_cookiecollection);
273                 }
274 
275                 foreach (KeyValuePair<String, String> hd in _headers)
276                 {
277                     request.Headers[hd.Key] = hd.Value;
278                 }
279 
280                 HttpWebResponse response = (HttpWebResponse)request.GetResponse();
281                 Stream stream = response.GetResponseStream();
282                 MemoryStream ms = new MemoryStream();
283 
284                 byte[] b = new byte[1024];
285                 while (true)
286                 {
287                     int s = stream.Read(b, 0, b.Length);
288                     ms.Write(b, 0, s);
289                     if (s == 0 || s < b.Length)
290                     {
291                         break;
292                     }
293                 }
294                 mine = ms.ToArray();
295                 ms.Close();
296 
297                 if (request.CookieContainer != null)
298                 {
299                     response.Cookies = request.CookieContainer.GetCookies(request.RequestUri);
300                 }
301 
302                 if (response.Cookies != null)
303                 {
304                     _cookiecollection = response.Cookies;
305                 }
306                 if (response.Headers["Set-Cookie"] != null)
307                 {
308                     _cookies = response.Headers["Set-Cookie"];
309                 }
310 
311                 stream.Close();
312                 stream.Dispose();
313                 response.Close();
314                 return mine;
315             }
316             catch (Exception e)
317             {
318                 Trace.WriteLine("HttpGetMine Error: " + e.Message);
319                 return null;
320             }
321         }
322 
323         /// <summary>
324         /// 发送POST请求
325         /// </summary>
326         /// <param name="url"></param>
327         /// <param name="data"></param>
328         /// <returns></returns>
329         public String HttpPost(String url, String data)
330         {
331             return HttpPost(url, data, url,null);
332         }
333 
334         /// <summary>
335         /// 发送POST请求
336         /// </summary>
337         /// <param name="url"></param>
338         /// <param name="data"></param>
339         /// <param name="refer"></param>
340         /// <returns></returns>
341         public String HttpPost(String url, String data, String refer,string cookie)
342         {
343             String html;
344             try
345             {
346                 ServicePointManager.ServerCertificateValidationCallback = new System.Net.Security.RemoteCertificateValidationCallback(CheckCertificate);
347                 HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
348                 request.UserAgent = _useragent;
349                 request.Timeout = _timeout;
350                 request.Referer = refer;
351                 request.ContentType = _contenttype;
352                 request.Accept = _accept;
353                 request.Method = "POST";
354                 request.KeepAlive = true;
355                 request.AllowAutoRedirect = true;
356 
357                 request.CookieContainer = new CookieContainer();
358                 if (!string.IsNullOrEmpty(cookie))
359                 {
360                     _cookiecollection = this.ConvertCookieString(cookie);
361                 }
362                 //据说能提高性能
363                 request.Proxy = null;
364 
365                 if (_cookiecollection != null)
366                 {
367                     foreach (Cookie c in _cookiecollection)
368                     {
369                         c.Domain = request.Host;
370                         if (c.Domain.IndexOf(':') > 0)
371                             c.Domain = c.Domain.Remove(c.Domain.IndexOf(':'));
372                     }
373                     request.CookieContainer.Add(_cookiecollection);
374                 }
375 
376                 foreach (KeyValuePair<String, String> hd in _headers)
377                 {
378                     request.Headers[hd.Key] = hd.Value;
379                 }
380                 byte[] buffer = _encoding.GetBytes(data.Trim());
381                 request.ContentLength = buffer.Length;
382                 request.GetRequestStream().Write(buffer, 0, buffer.Length);
383                 request.GetRequestStream().Close();
384 
385                 HttpWebResponse response = (HttpWebResponse)request.GetResponse();
386                 html = GetStringFromResponse(response);
387                 if (request.CookieContainer != null)
388                 {
389                     response.Cookies = request.CookieContainer.GetCookies(request.RequestUri);
390                 }
391                 if (response.Cookies != null)
392                 {
393                     _cookiecollection = response.Cookies;
394                 }
395                 if (response.Headers["Set-Cookie"] != null)
396                 {
397                     string tmpcookie = response.Headers["Set-Cookie"];
398                     _cookiecollection.Add(ConvertCookieString(tmpcookie));
399                 }
400 
401                 response.Close();
402                 return html;
403             }
404             catch (Exception e)
405             {
406                 Trace.WriteLine("HttpPost Error: " + e.Message);
407                 return String.Empty;
408             }
409         }
410 
411 
412         public string UrlEncode(string str)
413         {
414             StringBuilder sb = new StringBuilder();
415             byte[] byStr = _encoding.GetBytes(str);
416             for (int i = 0; i < byStr.Length; i++)
417             {
418                 sb.Append(@"%" + Convert.ToString(byStr[i], 16));
419             }
420 
421             return (sb.ToString());
422         }
423 
424         /// <summary>
425         /// 转换cookie字符串到CookieCollection
426         /// </summary>
427         /// <param name="ck"></param>
428         /// <returns></returns>
429         private CookieCollection ConvertCookieString(string ck)
430         {
431             CookieCollection cc = new CookieCollection();
432             string[] cookiesarray = ck.Split(";".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
433             for (int i = 0; i < cookiesarray.Length; i++)
434             {
435                 string[] cookiesarray_2 = cookiesarray[i].Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
436                 for (int j = 0; j < cookiesarray_2.Length; j++)
437                 {
438                     string[] cookiesarray_3 = cookiesarray_2[j].Trim().Split("=".ToCharArray());
439                     if (cookiesarray_3.Length == 2)
440                     {
441                         string cname = cookiesarray_3[0].Trim();
442                         string cvalue = cookiesarray_3[1].Trim();
443                         if (cname.ToLower() != "domain" && cname.ToLower() != "path" && cname.ToLower() != "expires")
444                         {
445                             Cookie c = new Cookie(cname, cvalue);
446                             cc.Add(c);
447                         }
448                     }
449                 }
450             }
451 
452             return cc;
453         }
454 
455 
456         public void DebugCookies()
457         {
458             Trace.WriteLine("**********************BEGIN COOKIES*************************");
459             foreach (Cookie c in _cookiecollection)
460             {
461                 Trace.WriteLine(c.Name + "=" + c.Value);
462                 Trace.WriteLine("Path=" + c.Path);
463                 Trace.WriteLine("Domain=" + c.Domain);
464             }
465             Trace.WriteLine("**********************END COOKIES*************************");
466         }
467 
468     }
469 }

Httphelper

小哥哥小姐姐们如果本篇文章对你们有帮助的话就点点右下角的推荐吧 0.0

现在的努力只是为了更好的将来，将来你一定不会后悔你现在的努力。一起加油吧！！！

C#/.NetCore技术交流群：608188505 欢迎加群交流
如果您认为这篇文章还不错或者有所收获，您可以点击右下角的【推荐】按钮精神支持，因为这种支持是我继续写作，分享的最大动力！

微信关注我们

原文链接：https://yq.aliyun.com/articles/610927

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

前端常见跨域解决方案（全）

什么是跨域？跨域是指一个域下的文档或脚本试图去请求另一个域下的资源，这里跨域是广义的。广义的跨域： 1.) 资源跳转： A链接、重定向、表单提交 2.) 资源嵌入： <link>、<script>、<img>、 <frame>等dom标签，还有样式中background:url()、 @font-face()等文件外链 3.) 脚本请求： js发起的ajax请求、dom和js对象的跨域操作等其实我们通常所说的跨域是狭义的，是由浏览器同源策略限制的一类请求场景。什么是同源策略？同源策略/SOP（Same origin policy）是一种约定，由Netscape公司1995年引入浏览器，它是浏览器最核心也最基本的安全功能，如果缺少了同源策略，浏览器很容易受到XSS、CSFR等攻击。所谓同源是指"协议+域名+端口"三者相同，即便两个不同的域名指向同一个ip地址，也非同源。同源策略限制以下几种行为： 1.) Cookie、LocalStorage 和 IndexDB 无法读取 2.) DOM 和 Js对象无法获得 3.) ...

2018-06-22

515

前言：对于应用，配制文件通常是放在项目中管理的，它可能有spring、mybatis、log等等各种各样的配置文件和属性文件，另外你还可能有开发环境、测试环境、生产环境等，这样的话就得一式三份，若是传统应用还好说，如果是微服务呢，这样不光配置文件有可能冗余而且量大，繁重复杂，不好维护，这样的话就需要一个配置文件的统一管理了。一、SpringCloud Config简介 SpringCloud Config为分布式系统外部化配置提供了服务器端和客户端的支持，它包括ConfigServer和ConfigClient两部分。 Server: 实例一般多于两个，以实现HA；配置以文件形式存储，快速支持目前以SpringBoot的开发方式的配置文件；支持GIt，码云，SVN，本地文件等多种形式；支持属性加密； Client：即各自的微服务应用；使用SpringCloud BUS配置和借助Git仓库的WebHooks自动刷新；二、SpringCloud Config基本使用创建服务端： 1、前面简单介绍了一下Config，那么首先要做的准备是先到Git仓库或者码云中创建一个项目并新...

2018-06-22

598

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。