了解HttpListener:用于创建基于HTTP协议的桌面&Web应用程序

开发 前端
HttpListener是一个强大而灵活的类,可以用于创建基于HTTP协议的服务器应用程序。它提供了丰富的功能和灵活的配置选项,能够轻松地处理HTTP请求和响应。

一、场景思考

在某些情况下,如使用WPF、WinForm或Windows服务开发的程序,可能需要提供接口以便第三方服务主动与其通信,并进行服务调用和数据推送,你想到哪些简单的方式快速实现?

二、方案对比

想到的部分实现方式有以下几种:

Web服务:使用Web服务(如RESTful API)可以使得第三方服务通过HTTP协议与你的程序通信。在WPF和WinForm中,可以使用ASP.NET Web API或ASP.NET Core Web API来实现接口逻辑。在Windows服务中,可以使用相应的框架(如Topshelf)来实现接口逻辑。

消息队列:使用消息队列(如RabbitMQ、Kafka)可以使得第三方服务通过异步消息传递与你的程序通信。这样可以提高程序的可靠性和扩展性,避免因为第三方服务的延迟或故障导致程序出现问题。

RPC(Remote Procedure Call):使用RPC可以使得第三方服务像调用本地函数一样调用你的程序提供的接口。常见的RPC框架包括gRPC、Apache Thrift等。

Socket编程:使用Socket编程可以使得第三方服务与你的程序建立长连接,进行实时通信。这种方式适合需要高频率交互的场景,但需要考虑网络稳定性和安全性等问题。

其他方式:根据具体业务需求,还可以使用其他方式来实现接口的提供,如使用FTP、SMTP等协议进行文件传输和邮件推送等。

三、方案择一

本文就是采用一种非常简单的方式来对外提供接口,代码很简单就是使用.net里的System.Net命名空间下的HttpListener就可以实现Http协议的Server端。

适用场景说明

HttpListener 是 .NET Framework 提供的一个类,用于创建基于 HTTP 协议的服务器。它可以在本地监听指定的 IP 地址和端口号,并接收来自客户端的 HTTP 请求。HttpListener 可以用于各种场景,包括但不限于以下几个方面:

Web API:可以使用 HttpListener 创建自己的 Web API 服务,接收客户端的 HTTP 请求,并根据请求内容进行相应的处理和响应。这对于需要轻量级的、自定义的 Web 服务非常有用,尤其是在没有使用 ASP.NET 或其他 Web 框架的情况下。

嵌入式 Web 服务器:如果应用程序需要内置一个简单的 Web 服务器,以提供静态文件或动态内容,那么可以使用 HttpListener。例如,你可以将 HTML、CSS、JavaScript 文件作为静态资源提供给客户端,或者根据客户端请求生成动态的 HTML 页面。

反向代理:HttpListener 还可以用于创建反向代理服务器。通过监听指定的端口,将客户端的请求转发到不同的后端服务器上,并将后端服务器的响应返回给客户端。这在构建高性能、负载均衡的 Web 服务器集群时非常有用。

测试和调试:在开发和调试阶段,可以使用 HttpListener 模拟一个简单的 HTTP 服务器,以接收和处理来自客户端的请求。这样可以方便地测试和调试应用程序,而无需依赖于外部的 Web 服务器。

注意事项:使用 HttpListener 创建的服务器通常是基于 HTTP 协议的,因此它适用于与客户端之间进行 HTTP 通信的场景。对于其他协议(如 TCP、UDP 等),可能需要使用不同的技术和类库来实现。此外,使用 HttpListener 创建的服务器通常是单线程的,因此在高并发的情况下,可能需要进行性能优化或考虑使用其他技术来提高并发处理能力。

官网的示例代码

下面是服务端一个实现代码:

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;

namespace CustomHttpServer
{
    public class HttpServerService
    {
        private static bool isExcute = true;
        private static HttpListener listener = new HttpListener();
        public static void Start()
        {
           //单独开启一个线程执行监听消息
            System.Threading.ThreadPool.QueueUserWorkItem(w => Excute());
        }

        private static void Excute()
        {
            if (HttpListener.IsSupported)
            {
                if (!listener.IsListening)
                {
                   //添加需要监听的url
                    listener.Prefixes.Add("http://127.0.0.1:8888/"); 
                    //开始监听端口,接收客户端请求
                    listener.Start(); 
                }
                while (isExcute)
                {
                    try
                    {
                        //阻塞主函数至接收到一个客户端请求为止  等待请求
                        HttpListenerContext context = listener.GetContext();
                        //解析请求
                        HttpListenerRequest request = context.Request;
                        //构造响应
                        HttpListenerResponse response = context.Response;
                        string httpMethod = request.HttpMethod?.ToLower();
                        string rawUrl = request.RawUrl;
                        var Url = request.Url;
                        if (httpMethod == "get")
                        {
                            //获取查询参数
                            var queryString = request.QueryString;
                            //TODO 其他操作
                        }
                        else if (httpMethod == "post")
                        {
                           // TODO 处理请求体数据 
                            var reader = new StreamReader(request.InputStream);
                            var questBody = reader.ReadToEnd();
                            if (!string.IsNullOrEmpty(rawUrl))
                            {
                               //TODO 反序列化RequestBody,调用其他业务
                            }
                        }

                        var responseString = string.Empty;
                        responseString = JsonConvert.SerializeObject(new { code = 1, msg = "发送成功" });
                        byte[] buffer = System.Text.Encoding.UTF8.GetBytes(responseString);
                        //对客户端输出相应信息.
                        response.ContentLength64 = buffer.Length;
                        //发送响应
                        using (System.IO.Stream output = response.OutputStream)
                        {
                            output.Write(buffer, 0, buffer.Length);
                        }
                    }
                    catch (Exception exceotion)
                    {
                        string str = exceotion.Message;
                    }
                }
            }
            else
            {
                // TODO  系统不支持HttpListener
            }
        }

        public static void Stop()
        {
            isExcute = false;
            if (listener.IsListening)
                listener.Stop();
        }
    }
}

WPF客户端调用:

/// <summary>
    /// App.xaml 的交互逻辑
    /// </summary>
    public partial class App : Application
    {
        public App()
        {
            HttpServerService.Start();
        }
    }

Windows服务调用:

protected override void OnStart(string[] args)
{
  HttpServerService.Start();
}

protected override void OnStop()
{
  //停止监听
  HttpServerService.Stop();
}

作为文件服务器的应用。

using System;
using System.IO;
using System.Net;

namespace FileServerDemo
{
    public class FileServer
    {
        private static FileServer _instance;
        private HttpListener _listener;
        private string _rootDirectory;

        private FileServer()
        {
            _rootDirectory = @"C:\Files\"; // 指定文件根目录
        }

        public static FileServer Instance
        {
            get
            {
                if (_instance == null)
                {
                    _instance = new FileServer();
                }
                return _instance;
            }
        }

        public void Start()
        {
            if (_listener != null && _listener.IsListening)
            {
                throw new InvalidOperationException("File server is already running.");
            }

            string url = "http://localhost:8080/";

            try
            {
                _listener = new HttpListener();
                _listener.Prefixes.Add(url);
                _listener.Start();

                Console.WriteLine($"File Server is running. Listening on {url}");

                while (true)
                {
                    HttpListenerContext context = _listener.GetContext();
                    HttpListenerRequest request = context.Request;
                    HttpListenerResponse response = context.Response;

                    string filePath = Path.Combine(_rootDirectory, request.Url.LocalPath.TrimStart('/'));

                    if (File.Exists(filePath))
                    {
                        byte[] buffer = File.ReadAllBytes(filePath);

                        response.ContentType = GetContentType(filePath);
                        response.ContentLength64 = buffer.Length;

                        response.OutputStream.Write(buffer, 0, buffer.Length);
                        response.OutputStream.Close();
                    }
                    else
                    {
                        response.StatusCode = (int)HttpStatusCode.NotFound;
                        response.Close();
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
            }
        }

        public void Stop()
        {
            if (_listener != null && _listener.IsListening)
            {
                _listener.Stop();
                _listener.Close();
                _listener = null;

                Console.WriteLine("File Server stopped.");
            }
        }

        private string GetContentType(string filePath)
        {
            string extension = Path.GetExtension(filePath).ToLower();

            switch (extension)
            {
                case ".txt":
                    return "text/plain";
                case ".html":
                    return "text/html";
                case ".css":
                    return "text/css";
                case ".js":
                    return "application/javascript";
                case ".jpg":
                case ".jpeg":
                    return "image/jpeg";
                case ".png":
                    return "image/png";
                default:
                    return "application/octet-stream";
            }
        }
    }
}

在上述示例代码中,我们展示了如何使用 HttpListener 类构建一个简单的文件服务器。通过监听指定的 URL,并在接收到请求时返回对应的文件内容,我们可以实现一个基本的文件服务功能。

社区也有很多案例介绍

总之,HttpListener是一个强大而灵活的类,可以用于创建基于HTTP协议的服务器应用程序。它提供了丰富的功能和灵活的配置选项,能够轻松地处理HTTP请求和响应。通过深入了解HttpListener的用法和特性,就可以更好地利用它的优势,来提供高效、可靠的网络服务。因此,如果您正在开发基于HTTP的应用程序,不妨考虑使用HttpListener来实现您的需求。

责任编辑:姜华 来源: 今日头条
相关推荐

2020-05-12 10:06:52

JavaScript开发框架

2024-01-02 00:18:56

Buffalo项目Go Web框架

2023-03-30 08:29:14

HTTP缓存Web应用

2009-01-19 11:07:42

C#Web.NET

2009-07-24 10:41:00

ASP.NET Web

2013-11-19 15:35:01

2011-05-11 10:12:05

Mobl

2009-09-03 17:36:13

C#创建Web应用程序

2009-07-17 16:09:29

Swing桌面应用程序

2015-11-20 17:09:36

jsWeb应用程序

2011-07-08 15:27:03

jQuery Mobi

2009-04-13 11:35:55

IBMdWEclipseJava

2013-06-24 10:21:47

面向对象Web应用JavaScript

2009-04-01 14:33:33

2009-07-09 16:47:26

Servlet的Web

2024-01-05 07:38:55

2009-06-14 18:06:06

ibmdwWebSphere

2010-05-20 09:48:36

2011-03-22 14:12:17

LAMP

2016-07-29 13:47:05

RethinkDBWeb
点赞
收藏

51CTO技术栈公众号