金沙国际官网_金沙国际平台登录

因为这个金沙国际官网_金沙国际平台登录网站与很多的大型澳门赌场都有合作,金沙国际官网_金沙国际平台登录尽职尽责,高效执行,保持好奇心,不断学习,追求卓越,点击进入金沙国际官网_金沙国际平台登录马上体验吧,所以现在也正式地开始了营业。

您的位置:金沙国际官网 > 编程 > 爬虫学习笔记,物联网框架ServerSuperIO教程

爬虫学习笔记,物联网框架ServerSuperIO教程

发布时间:2019-11-05 17:06编辑:编程浏览(190)

            Internet上的一些站点常常存在着镜像网站(mirror),即两个网站的内容一样但网页对应的域名不同。这样会导致对同一份网页爬虫重复抓取多次。为了避免这种情况,对于每一份抓取到的网页,它首先需要进入ContentSeen模块。该模块会判断网页的内容是否和已下载过的某个网页的内容一致,如果一致,则该网页不会再被送去进行下一步的处理。这样的做法能够显著的降低爬虫需要下载的网页数。至于如果判断两个网页的内容是否一致,一般的思路是这样的:并不会去直接比较两个网页的内容,而是将网页的内容经过计算生成FingerPrint(指纹),通常FingerPrint是一个固定长度的字符串,要比网页的正文短很多。如果两个网页的FingerPrint一样,则认为它们内容完全相同。

            为了完成这一模块,首先我们需要一个强大的指纹算法,将我们的网页内容计算成指纹存入数据库,下次直接判断指纹在保存前通过指纹的对比即可成功完成去重复操作。

            首先来看一下大名鼎鼎的Google公司使用的网页去重复算法SimHash吧:

            GoogleMoses Charikar发表的一篇论文“detecting near-duplicates for web crawling”中提出了simhash算法,专门用来解决亿万级别的网页的去重任务。

            SimHash作为locality sensitive hash(局部敏感哈希)的一种:

            其主要思想是降维,将高维的特征向量映射成低维的特征向量,通过两个向量的Hamming Distance来确定文章是否重复或者高度近似。

            其中,Hamming Distance,又称汉明距离,在信息论中,两个等长字符串之间的汉明距离是两个字符串对应位置的不同字符的个数。也就是说,它就是将一个字符串变换成 另外一个字符串所需要替换的字符个数。例如:1011101 与 1001001 之间的汉明距离是 2。至于我们常说的字符串编辑距离则是一般形式的汉明距离。

            如此,通过比较多个文档的SimHash值的海明距离,可以获取它们的相似度。

            详情可以看这里SimHash算法

    ____________________________________________________________________________________________________________

    下面我们来进行代码实现:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    


    namespace Crawler.Common { public class SimHashAnalyser {
    private const int HashSize = 32;
    public static float GetLikenessValue(string needle, string haystack, TokeniserType type = TokeniserType.Overlapping) { var needleSimHash = GetSimHash(needle, type); var hayStackSimHash = GetSimHash(haystack, type); return GetLikenessValue(needleSimHash, hayStackSimHash); }
    public static float GetLikenessValue(int needleSimHash, int hayStackSimHash) { return (HashSize - GetHammingDistance(needleSimHash, hayStackSimHash)) / (float)HashSize; }
    private static IEnumerable DoHashTokens(IEnumerable tokens) { return tokens.Select(token => token.GetHashCode()).ToList(); }
    private static int GetHammingDistance(int firstValue, int secondValue) { var hammingBits = firstValue ^ secondValue; var hammingValue = 0; for (var i = 0; i < 32; i++) if (IsBitSet(hammingBits, i)) hammingValue += 1; return hammingValue; }
    private static bool IsBitSet(int b, int pos) { return (b & (1 << pos)) != 0; }

    public static int GetSimHash(string input) { return GetSimHash(input, TokeniserType.Overlapping); }
    public static int GetSimHash(string input, TokeniserType tokeniserType) { ITokeniser tokeniser; if (tokeniserType == TokeniserType.Overlapping) tokeniser = new OverlappingStringTokeniser(); else tokeniser = new FixedSizeStringTokeniser();
    var hashedtokens = DoHashTokens(tokeniser.Tokenise(input)); var vector = new int[HashSize]; for (var i = 0; i < HashSize; i++) vector[i] = 0;
    foreach (var value in hashedtokens) for (var j = 0; j < HashSize; j++) if (IsBitSet(value, j)) vector[j] += 1; else vector[j] -= 1; var fingerprint = 0; for (var i = 0; i < HashSize; i++) if (vector[i] > 0) fingerprint += 1 << i; return fingerprint; }
    }
    public interface ITokeniser { IEnumerable Tokenise(string input); }
    public class FixedSizeStringTokeniser : ITokeniser { private readonly ushort _tokensize; public FixedSizeStringTokeniser(ushort tokenSize = 5) { if (tokenSize < 2) throw new ArgumentException("Token 不能超出范围"); if (tokenSize > 127) throw new ArgumentException("Token 不能超出范围"); _tokensize = tokenSize; }
    public IEnumerable Tokenise(string input) { var chunks = new List(); var offset = 0; while (offset < input.Length) { chunks.Add(new string(input.Skip(offset).Take(_tokensize).ToArray())); offset += _tokensize; } return chunks; }
    }
    public class OverlappingStringTokeniser : ITokeniser {
    private readonly ushort _chunkSize; private readonly ushort _overlapSize;
    public OverlappingStringTokeniser(ushort chunkSize = 4, ushort overlapSize = 3) { if (chunkSize <= overlapSize) throw new ArgumentException("Chunck 必须大于 overlap"); _overlapSize = overlapSize; _chunkSize = chunkSize; }
    public IEnumerable Tokenise(string input) { var result = new List(); var position = 0; while (position < input.Length - _chunkSize) { result.Add(input.Substring(position, _chunkSize)); position += _chunkSize - _overlapSize; } return result; }

    }
    public enum TokeniserType { Overlapping, FixedSize } }

     

    调用方法如下:

    var s1 = "the cat sat on the mat.";
    var s2 = "the cat sat on a mat.";
    


    var similarity = SimHashAnalyser.GetLikenessValue(s1, s2);
    Console.Clear(); Console.WriteLine("相似度: {0}%", similarity * 100); Console.ReadKey();

     

    输出为:

    相似度: 78.125%
    
    接下来就是对ContentSeen模块的简单封装:
    
    using Crawler.Common;
    


    namespace Crawler.Processing { ///

    /// 对于每一份抓取到的网页,它首先需要进入Content Seen模块。该模块会判断网页的内容是否和已下载过的某个网页的内容一致,如果一致,则该网页不会再被送去进行下一步的处理。 /// public class ContentSeen { public static int GetFingerPrint(string html) { return SimHashAnalyser.GetSimHash(html); }
    public static float Similarity(int print1, int print2) { return SimHashAnalyser.GetLikenessValue(print1, print2); }
    } }

    参考文章:

    好久没输出了,知识还是要写下总结才能让思路更加清晰。最近在学习计算机网络相关的知识,来聊聊如何编写一个建议的HTTP服务器。

    1.SuperIO通讯框架介绍,含通信本质

    这个http server的实现源代码我放在了我的github上,有兴趣的话可以点击查看哦。

    2.C#跨平台物联网通讯框架ServerSuperIO(SSIO)

    HTTP 服务器

    HTTP服务器,就是一个运行在主机上的程序。程序启动了之后,会一直在等待其他所有客户端的请求,接收到请求之后,处理请求,然后发送响应给客户端。客户端和服务器之间使用HTTP协议进行通信,所有遵循HTTP协议的程序都可以作为客户端。

    先直接上代码,然后再详细说明实现细节。

    #include <stdio.h>
    #include <ctype.h>
    #include <sys/types.h>
    #include <netinet/in.h>
    #include <sys/socket.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <string.h>
    #include <sys/stat.h>
    
    #define PORT 9001
    #define QUEUE_MAX_COUNT 5
    #define BUFF_SIZE 1024
    
    #define SERVER_STRING "Server: hoohackhttpd/0.1.0rn"
    
    int main()
    {
        /* 定义server和client的文件描述符 */
        int server_fd = -1;
        int client_fd = -1;
    
        u_short port = PORT;
        struct sockaddr_in client_addr;
        struct sockaddr_in server_addr;
        socklen_t client_addr_len = sizeof(client_addr);
    
        char buf[BUFF_SIZE];
        char recv_buf[BUFF_SIZE];
        char hello_str[] = "Hello world!";
    
        int hello_len = 0;
    
        /* 创建一个socket */
        server_fd = socket(AF_INET, SOCK_STREAM, 0);
        if (server_fd == -1) {
            perror("socket");
            exit(-1);
        }
        memset(&server_addr, 0, sizeof(server_addr));
        /* 设置端口,IP,和TCP/IP协议族 */
        server_addr.sin_family = AF_INET;
        server_addr.sin_port = htons(PORT);
        server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    
        /* 绑定套接字到端口 */
        if (bind(server_fd, (struct sockaddr *)&server_addr,
             sizeof(server_addr)) < 0) {
            perror("bind");
            exit(-1);
        }
    
        /* 启动socket监听请求,开始等待客户端发来的请求 */
        if (listen(server_fd, QUEUE_MAX_COUNT) < 0) {
            perror("listen");
            exit(-1);
        }
    
        printf("http server running on port %dn", port);
    
        while (1) {
            /* 调用了accept函数,阻塞了程序,直到接收到客户端的请求 */
            client_fd = accept(server_fd, (struct sockaddr *)&client_addr,
                       &client_addr_len);
            if (client_fd < 0) {
                perror("accept");
                exit(-1);
            }
            printf("accept a clientn");
    
            printf("client socket fd: %dn", client_fd);
            /* 调用recv函数接收客户端发来的请求信息 */
            hello_len = recv(client_fd, recv_buf, BUFF_SIZE, 0);
    
            printf("receive %dn", hello_len);
    
            /* 发送响应给客户端 */
            sprintf(buf, "HTTP/1.0 200 OKrn");
            send(client_fd, buf, strlen(buf), 0);
            strcpy(buf, SERVER_STRING);
            send(client_fd, buf, strlen(buf), 0);
            sprintf(buf, "Content-Type: text/htmlrn");
            send(client_fd, buf, strlen(buf), 0);
            strcpy(buf, "rn");
            send(client_fd, buf, strlen(buf), 0);
            sprintf(buf, "Hello Worldrn");
            send(client_fd, buf, strlen(buf), 0);
    
            /* 关闭客户端套接字 */
            close(client_fd);
        }
    
        close(server_fd);
    
        return 0;
    }
    

     

    测试运行

    代码写好之后,运行测试一下,将上面代码保存到server.c,然后编译程序:

    gcc server.c -o server
    

    ./server运行

    图片 1

    服务器运行,监听9001端口。再用netstat命令查看:
    图片 2

    server程序在监听9001端口,运行正确。接着用浏览器访问

    图片 3

    成功输出了Hello World

    再尝试用telnet去模拟HTTP请求:

    图片 4

    • 1、成功连接
    • 2、发送HTTP请求
    • 3、HTTP响应结果

    上面是一个最简单的server程序,代码比较简单,省去一些细节,下面通过代码来学习一下socket的编程细节。

    一、感慨

    启动server的流程

    图片 5

          上大学的时候,没有学过C#,花了5块钱在地坛书市买了一本教程,也就算是正式入行了。后来深造,学过JAVA,后来迫于生计,打算转JAVA了。后来考虑考虑,自己写的框架还是有很大发展余地,后来还是在C#的阵地上坚持了下来。从一开始的雏形,到SuperIO的产品化,再到服务器端的ServerSuperIO,也是慢慢演化而来。后期打算把ServerSuperIO移植到嵌入式设备上,以及完善开发文档。本来不想提这些,但是今天打算招一个C#开发人员(B/S方面),是群友,可是人家要转JAVA开发了,也只能说缘分不到,无法在一起做事,后面附一些聊天记录,供大家职业发展参考。

    socket 函数

    创建一个套接字,通过各参数指定套接字的类型。

    int socket(int family, int type, int protocol);
    
    • family:协议族。AF_INET:IPV4协议;AF_INET6:IPv6协议;AF_LOCAL:Unix域协议;AF_ROUTE:路由套接字;AF_KEY:密钥套接字
    • type:套接字类型。SOCK_STREAM : 字节流套接字;SOCK_DGRAM:数据包套接字;SOCK_SEGPACKET:有序分组套接字;SOCK_RAW:原始套接字
    • protocol:某个协议类型常量。TCP:0,UDP :1, SCTP :2

     

    套接字地址结构

    在socket编程中,大部分函数都用到一个指向套接字地址结构的指针作为参数。针对不同的协议类型,会有不同的结构体定义格式,对于ipv4,结构如下所示:

    struct sockaddr_in {
         uint8_t            sin_len;        /* 结构体的长度 */
         sa_family_t        sin_family;     /* IP协议族,IPV4是AF_INET */
         in_port_t          sin_port;       /* 一个16比特的TCP/UDP端口地址 */
         struct in_addr     sin_addr;       /* 32比特的IPV4地址,网络字节序 */
         char               sin_zero[8];    /* 未使用字段 */
    };
    

    注:sockaddr_in是Internet socket address structure的缩写。

    二、答疑

    ip地址结构

    struct in_addr {
         in_addr_t      s_addr;
    };
    

    套接字地址结构的作用是为了将ip地址和端口号传递到socket函数,写成结构体的方式是为了抽象。当作为一个参数传递进任何套接字函数时,套接字地址结构总是以引用方式传递。然而,协议族有很多,因此以这样的指针作为参数之一的任何套接字函数必须处理来自所有支持的任何协议族的套接字地址结构。使用void *作为通用的指针类型,因此,套接字函数被定义为以指向某个通用套接字结构的一个指针作为其参数之一,正如下面的bind函数原型一样。

    int bind(int, struct sockaddr *, socklen_t);
    

    这就要求,对这些函数的任何调用都必须要将指向特定于协议的套接字地址结构的指针进行强制类型转换,变成某个通用套接字地址结构的指针。例如:

    struct sockaddr_in addr;
    bind(sockfd, (struct sockaddr *)&addr , sizeof(addr));
    

    对于所有socket函数而言,sockaddr的唯一用途就是对指向特定协议的套接字地址结构的指针执行强制类型转换,指向要绑定给sockfd的协议地址。

            有人问,你这个框架和SuperSocket、netty......有什么区别?ServerSuperIO是通讯框架不?是;ServerSuperIO支持高并发不?理论上支持;ServerSuperIO支持跨平台不?在Ubuntu上跑过。但是这些并不是ServerSuperIO起初设计的初发点,它继承了SuperIO的设计思想,后期才逐步的向服务端发展,加强通讯能力、跨平台等等。

    bind函数

    将套接字地址结构绑定到套接字

    int bind(sockfd, (struct sockaddr *)&addr, sizeof(addr));
    
    • sockfd:socket描述符,唯一标识一个socket。bind函数就是将这个描述字绑定一个名字。
    • addr:一个sockaddr指针,指向要绑定给sockfd的协议地址。一个socket由ip和端口号唯一确定,而sockaddr就包含了ip和端口的信息
      地址的长度

    绑定了socket之后,就可以使用该socket开始监听请求了。

            ServerSuperIO是一个物联网框架,首先是以设备(传感器)为核心构建的框架,设备(传感器)的协议无关性,可以随意挂载设备驱动在框架下运行。所以ServerSuperIO本质上协调设备驱动(协议)、IO通道(COM和NET)、运行机制(模式)之间的关系,使之无缝结合、运行。

    listen函数

    将sockfd从未连接的套接字转换成一个被动套接字,指示内核应接受指向该套接字的连接请求。

    int listen(int sockfd, int backlog);
    

    listen函数会将套接字从CLOSED状态转换到LISTEN状态,第二个参数规定内核应该为相应套接字排队的最大连接个数。

    关于backlog参数,内核为任何一个给定的监听套接字维护两个队列:

    • 1、未完成连接队列,在队列里面的套接字处于SYN_RCVD状态
    • 2、已完成队列,处于ESTABLISHED状态

    两个队列之和不超过backlog的大小。

    listen完成之后,socket就处于LISTEN状态,此时的socket调用accept函数就可以接受客户端发来的请求了。

            一直在工业领域混,做集成系统、远程监测监控等等,所以ServerSuperIO不仅仅是一个通讯框架,更多的是结合了工作实践经验,本着能够解决实质问题。

    accept函数

    int accept(int sockfd, struct sockaddr *cliaddr, socklen_t *addrlen);
    

    用于从已完成连接队列头返回下一个已完成连接,如果已完成连接队列为空,那么进程就会被阻塞。因此调用了accept函数之后,进程就会被阻塞,直到有新的请求到来。

    第一个参数sockfd是客户端的套接字描述符,第二个是客户端的套接字地址结构,第三个是套接字地址结构的长度。

    如果accept成功,那么返回值是由内核自动生成的全新描述符,代表所返回的客户端的TCP连接。

    对于accept函数,第一个参数称为监听套接字描述符,返回值称为已连接套接字。服务器仅创建监听套接字,它一直存在。已连接套接字由服务器进程接受的客户连接创建,当服务器完成某个连接的响应后,相应的已连接套接字就被关闭了。

    accept函数返回时,会返回套接字描述符或出错指示的整数,以及引用参数中的套接字地址和该地址的大小。如果对返回值不感兴趣,可以把两个引用参数设为空。

    accept之后,一个TCP连接就建立起来了,接着,服务器就接受客户端的请求信息,然后做出响应。

     

    recv和send函数

    ssize_t recv(int sockfd, void *buff, size_t nbytes, int flags);
    ssize_t send(int sockfd, const void *buff, size_t nbytes, int flags);
    

    分别用于从客户端读取信息和发送信息到客户端。在此不做过多的解释。

    三、运行控制模式

    套接字地址结构大小和值-结果参数

    可以看到,在bind函数和accept函数里面,都有一个套接字地址结构长度的参数,区别在于一个是值形式,另一个是引用形式。套接字地址结构的传递方式取决于该结构的传递方向:是从进程到内核,还是从内核到进程。

    1、从进程到内核:bind、connect、sendto。
    函数将指针和指针所指内容的大小都传给了内核,于是内核知道到底需要从进程复制多少数据进来。

    2、从内核到进程:
    accept、recvfrom、getsockname、getperrname。
    这四个函数的结构大小是以只引用的方式传递。
    因为当函数被调用时,结构大小是一个值,它告诉内核该结构的大小,这样内核在写该结构时不至于越界;当函数返回时,结构大小又是一个结果,它告诉内核在该结构中究竟存储了多少信息。

    1、轮询模式

    HTTP响应报文

    发送响应给客户端时,发送的报文要遵循HTTP协议,HTTP的响应报文格式如下:

    <status-line>
    <headers>
    <blank line>
    [<response-body>]
    

    第一行status-line,状态栏,格式:HTTP版本 状态码 状态码代表文字headers是返回报文的类型,长度等信息,接着是一个空行,然后是响应报文的实体。

    一个HTTP响应报文例子:

    HTTP/1.1 200 OK
    Content-Type: text/html;charset=utf-8
    Content-Length: 122
    
    <html>
    <head>
    <title>Hello Server</title>
    </head>
    <body>
    Hello Server
    </body>
    </html>
    

    最后close函数关闭套接字,时刻保持关闭文件描述符是一个很好的编程习惯。

        这是框架最早的运行模式,串口和网络通讯时都可以使用这种控制模式。当有多个设备 连接到通讯平台时,通讯平台会轮询调度设备进行通讯任务。某一时刻只能有一个设备发送请求命令、等待接收返回数据,这个设备完成发送、接收(如果遇到超时 情况,则自动返回)后,下一个设备才进行通讯任务,依次轮询设备。

    总结

    虽然很多东西看起来很简单,但只有自己真正动手做一遍,才发现其中的简单,之后才能说这些基础是最简单的。要更好和更深入地理解系统的知识,你必须重新一点一点地重新构建一次。

    这个http server的实现源代码我放在了我的github上,有兴趣的话可以点击查看哦。

        应用场景是这样的,服务端与设备进行通讯遵循呼叫应答的方式,也就是IO可用的情况下,服务端先发起通讯命令请求,设备根据命令信息,检验通过后返回数据给服务端。这种通讯模式很好理解,每个设备的通讯都遵循排队的原则。但是如果某个设备的命令需要及时发送,怎么办?ServerSuperIO框架是支持设备优先级别调度的,例如:对某个设备要进行实时的检测,需要连续发送命令,那么就需要对设备进行高级别设置,发送请求数据命令。

    本文由金沙国际官网发布于编程,转载请注明出处:爬虫学习笔记,物联网框架ServerSuperIO教程

    关键词:

上一篇:没有了

下一篇:没有了