larbin之哈希之谈
由于工作原因，打算对larbin的源码进行分析一番
用的是2.6.3版本的larbin源码，由于这是业余，会断断续续的分析上传，已做记录笔记
今天我们分析一下larbin的哈希表
这个哈希表结构比较简单，因为它的主要用处是排重，因此只给出了用于排重的简单函数，
我们来看一下头文件怎么定义的：
// Larbin // Sebastien Ailleret // 23-11-99 -> 14-01-00 /* class hashTable * This class is in charge of making sure we don't crawl twice the same url */ #ifndef HASHTABLE_H #define HASHTABLE_H #include "types.h" #include "utils/url.h" class hashTable { private: ssize_t size; char *table; public: /* constructor */ hashTable (bool create); /* destructor */ ~hashTable (); /* save the hashTable in a file */ void save(); /* test if this url is allready in the hashtable * return true if it has been added * return false if it has allready been seen */ bool test (url *U); /* set a url as present in the hashtable */ void set (url *U); /* add a new url in the hashtable * return true if it has been added * return false if it has allready been seen */ bool testSet (url *U); }; #endif // HASHTABLE_H
由头文件我们可以看出，这个哈希表仅仅有四个成员函数（除了构造和析构）
save 函数是用于保存哈希表内部的数据，用于防止程序异常退出而造成数据丢失，因此把哈希内数据保存到一个文件中
test 函数用于测试参数指定的URL是否在哈希表内存在，只要是排重
set 函数就是判断出需要设置哈希表内值得时候设置该位置的URL对应的值，表示该URL从此开始存在于哈希表中
testset 是一个辅助函数，先判断，然后设置该位置的值，并且返回设置前的判断结果
下面我们就仔细来看一看各个函数的实现，比较简单，我就在程序中做了简单注释，就不再多余的文字解释了
构造函数：
hashTable::hashTable (bool create) { //构造函数，申请哈希需求的空间并初始化 ssize_t total = hashSize/8; //因为是位集合判断，所以每个字节8位，对于哈希的总成都除以8 table = new char[total]; //申请哈希空间，其实这个地方主要是以数组巧妙勾勒哈希功能 if (create) { //是一个标志，也就是说哈希内部的数据是从文件内读取还是初始化位0 for (ssize_t i=0; i<hashSize/8; i++) { table[i] = 0; } } else { int fds = open("hashtable.bak", O_RDONLY); //从bak备份文件读取数据 if (fds < 0) { cerr << "Cannot find hashtable.bak, restart from scratch\n"; for (ssize_t i=0; i<hashSize/8; i++) { //如果打开备份文件失败，就重新赋值位0，当做第一次看待 table[i] = 0; } } else { ssize_t sr = 0; while (sr < total) { ssize_t tmp = read(fds, table+sr, total-sr); //然后循环读取文件，直到成功读取所有数据 if (tmp <= 0) { cerr << "Cannot read hashtable.bak : " << strerror(errno) << endl; exit(1); } else { sr += tmp; //增加每次读取的数据 } } close(fds); //关闭文件描述符 } } }
析构函数：
hashTable::~hashTable () { //析构函数，释放哈希申请的空间
delete [] table;
}
测试函数test:
bool hashTable::test (url *U) { //判断该url对应的是否存在哈希中，如果存在返回true，否则false unsigned int code = U->hashCode(); //根据hashCode函数求散列值 unsigned int pos = code / 8; unsigned int bits = 1 << (code % 8); return table[pos] & bits; }
设置函数：
void hashTable::set (url *U) { //设置url对应哈希值 unsigned int code = U->hashCode(); unsigned int pos = code / 8; unsigned int bits = 1 << (code % 8); table[pos] |= bits; }
测试设置函数：
bool hashTable::testSet (url *U) { //返回测试结果，并且设置url对应的值 unsigned int code = U->hashCode(); unsigned int pos = code / 8; unsigned int bits = 1 << (code % 8); int res = table[pos] & bits; table[pos] |= bits; return !res; }
保存文件函数：
void hashTable::save() { //把哈希内部数据存到文件，该过程是循序渐进的，防止时间间隔过程造成数据大量失真 rename("hashtable.bak", "hashtable.old"); //先把先前备份文件保存，直到最后本次成功备份后删除 int fds = creat("hashtable.bak", 00600); if (fds >= 0) { ecrireBuff(fds, table, hashSize/8); //辅助函数，把哈希数据存到备份文件 close(fds); } unlink("hashtable.old"); }
该哈希的处理部分就这么多，下面重点来看看我们两个知识点
1，散列函数 hashCode：
uint url::hashCode () { unsigned int h=port; unsigned int i=0; while (host[i] != 0) { h = 31*h + host[i]; i++; } i=0; while (file[i] != 0) { h = 31*h + file[i]; i++; } return h % hashSize; }
说起来散列函数，要求很有艺术的，而且散列函数也不可能有百分百的通用性。
一般都要自己根据哈希设置自己的散列函数。最起码要设置某些数值，用同一个散列方法和框架
该散列函数比较简单，就是把host和file（URL类中的两个字段，表示主机和文件路径）依次乘以31
然后对哈希最大值求余数，最大值这样定义的：
#define hashSize 64000000
另外对于host和file的先后哈希顺序也是设计的，先host而后file是为了让同一host对应的file的差异更大，减缓相似冲突
2，下面我们就来谈谈URL这个类，上面那个哈希散列函数就是这个类中的一个成员函数，之所以单独摘出去说，是因为散列函数也是重大的一块
我们先来看一下URL类的定义：
class url { private: char *host; char *file; uint16_t port; // the order of variables is important for physical size int8_t depth; /* parse the url */ void parse (char *s); /** parse a file with base */ void parseWithBase (char *u, url *base); /* normalize file name */ bool normalize (char *file); /* Does this url starts with a protocol name */ bool isProtocol (char *s); /* constructor used by giveBase */ url (char *host, uint port, char *file); public: /* Constructor : Parses an url (u is deleted) */ url (char *u, int8_t depth, url *base); /* constructor used by input */ url (char *line, int8_t depth); /* Constructor : read the url from a file (cf serialize) */ url (char *line); /* Destructor */ ~url (); /* inet addr (once calculated) */ struct in_addr addr; /* Is it a valid url ? */ bool isValid (); /* print an URL */ void print (); /* return the host */ inline char *getHost () { return host; } /* return the port */ inline uint getPort () { return port; } /* return the file */ inline char *getFile () { return file; } /** Depth in the Site */ inline int8_t getDepth () { return depth; } /* Set depth to max if we are at an entry point in the site * try to find the ip addr * answer false if forbidden by robots.txt, true otherwise */ bool initOK (url *from); /** return the base of the url * give means that you have to delete the string yourself */ url *giveBase (); /** return a char * representation of the url * give means that you have to delete the string yourself */ char *giveUrl (); /** write the url in a buffer * buf must be at least of size maxUrlSize * returns the size of what has been written (not including '\0') */ int writeUrl (char *buf); /* serialize the url for the Persistent Fifo */ char *serialize (); /* very thread unsafe serialisation in a static buffer */ char *getUrl(); /* return a hashcode for the host of this url */ uint hostHashCode (); /* return a hashcode for this url */ uint hashCode (); #ifdef URL_TAGS /* tag associated to this url */ uint tag; #endif // URL_TAGS #ifdef COOKIES /* cookies associated with this page */ char *cookie; void addCookie(char *header); #else // COOKIES inline void addCookie(char *header) {} #endif // COOKIES };
URL这个类的声明比较复杂，因为它把设计URL的部分集中在这一块
我们分开来分析它的实现：
先看一个构造函数
url::url (char *u, int8_t depth, url *base) { newUrl(); this->depth = depth; host = NULL; port = 80; file = NULL; initCookie(); #ifdef URL_TAGS tag = 0; #endif // URL_TAGS if (startWith("http://", u)) { // absolute url parse (u + 7); // normalize file name if (file != NULL && !normalize(file)) { delete [] file; file = NULL; delete [] host; host = NULL; } } else if (base != NULL) { if (startWith("http:", u)) { parseWithBase(u+5, base); } else if (isProtocol(u)) { // Unknown protocol (mailto, ftp, news, file, gopher...) } else { parseWithBase(u, base); } } }
这是其中一个url类的构造函数，它接受3个参数
第一个参数 u 是URL字符串
第二个参数 depth 是爬虫深度
第三个参数 base 是基类URL，也就是要解析需要用的上一个URL，相当于referer
它虽然只是一个构造函数，但是设计中为了更方便的使用该类，在其构造函数中进行了一系列的处理，相当于我们只要构造这个对象，就获取了相应的转化处理
newUrl() 是一个宏定义，调试用的：
#define newUrl() debUrl++ #define delUrl() debUrl--
然后就是一些初始化变量
下面调用了一个 initCookie函数，该函数是宏条件控制的宏：
#ifdef COOKIES #define initCookie() cookie=NULL #else // COOKIES #define initCookie() ((void) 0) #endif // COOKIES
其实就是对cookie变量赋值为NULL，或者一个空语句
接着，如果使用tag，用宏开关设置tag为0
然后根据url字符串判断是否是http://开始的标准绝对路径URL
如果是绝对路径URL 就从后面开始解析这个url字符串。
parse是URL解析函数，随后分析
调用parse，可以分析出 host和file，然后下一步，如果file不为空，就对file就行序列化调整
也就是把file中不合适的路径修改合适标准，此处调用的事normalize
相反，如果不是url绝对路径，如果base为NULL，则无法判断决定这个url因此就不处理，返回
否则表示可以组建url
如果是以http：开始的，就调用parseWithBase函数解析url
否则，如果使用了不识别的协议，就无法解析
其他情况调用 parseWithBase函数解析
这样这个URL构造函数就结束了，我们对处理的流程清楚，但是其中有几个重点函数要具体分析一下
1，file序列化函数 normalize函数
bool fileNormalize (char *file) { int i=0; while (file[i] != 0 && file[i] != '#') { if (file[i] == '/') { //如果当前字符是/， 我们分情况处理下一个字符是什么 if (file[i+1] == '.' && file[i+2] == '/') { //如果接下来的字符是./也就是出现/./的情况，我们把这个路径 // suppress /./ //规范化，去掉这三个字符，过程就是从后向前覆盖 int j=i+3; while (file[j] != 0) { file[j-2] = file[j]; j++; } file[j-2] = 0; } else if (file[i+1] == '/') { //如果下一个是/，也就是出现 // 的情况我们把它替换为 一个 / // replace // by / int j=i+2; while (file[j] != 0) { file[j-1] = file[j]; j++; } file[j-1] = 0; } else if (file[i+1] == '.' && file[i+2] == '.' && file[i+3] == '/') { //如果出现 /../的情况，相当于 // suppress /../ //回到父目录，因此我们回朔到父目录，覆盖回朔过程中无用的路径 if (i == 0) { // the file name starts with /../ : error //如果是刚开始出现这种情况，视为错误 return false; } else { int j = i+4, dec; i--; while (file[i] != '/') { i--; } dec = i+1-j; // dec < 0 while (file[j] != 0) { file[j+dec] = file[j]; j++; } file[j+dec] = 0; } } else if (file[i+1] == '.' && file[i+2] == 0) { //如果为 /.0 这种情况，则表示当前路径，直接赋值结束 // suppress /. file[i+1] = 0; return true; } else if (file[i+1] == '.' && file[i+2] == '.' && file[i+3] == 0) { // suppress /.. //如果是 /..0 这样情况 if (i == 0) { // the file name starts with /.. : error //如果在开始，则按错误处理 return false; } else { //如果出现在路径中间，则表示上级目录，回朔覆盖 i--; while (file[i] != '/') { i--; } file[i+1] = 0; return true; } } else { // nothing special, go forward //如果是其他正常情况，继续处理 i++; } } else if (file[i] == '%') { //因为url中一个字符不能出现就需要转义，转义是以%开始，加两个十六进制数字 int v1 = int_of_hexa(file[i+1]); int v2 = int_of_hexa(file[i+2]); if (v1 < 0 || v2 < 0) return false; char c = 16 * v1 + v2; //解析转义字符 if (isgraph(c)) { //如果是可视字符，把它转为可视字符，然后多余字符覆盖移动 file[i] = c; int j = i+3; while (file[j] != 0) { file[j-2] = file[j]; j++; } file[j-2] = 0; i++; } else if (c == ' ' || c == '/') { // keep it with the % notation //如果是空格或者／ 则不处理，跳过 i += 3; } else { // bad url //其他情况则视为错误 return false; } } else { // nothing special, go forward //正常的流程，继续执行 i++; } } file[i] = 0; return true; }
这是一个辅助函数，主要用于纠正分析文件路径的错误不识别情况，上面代码已经注释的很清楚
其中用到的一个辅助函数为：
static int int_of_hexa (char c) { //十六进制数字转化为10进制 if (c >= '0' && c <= '9') return (c - '0'); else if (c >= 'a' && c <= 'f') return (c - 'a' + 10); else if (c >= 'A' && c <= 'F') return (c - 'A' + 10); else return -1; }
这个就是16进制字符串转化为10进制，很简单易懂
2，小的辅助函数，不多做解释：
bool startWith (char *a, char *b) { int i=0; while (a[i] != 0) { if (a[i] != b[i]) return false; i++; } return true; }
3，url构造函数还有两个重量级的函数 parse 和 parseWithBase两个
我们先来分析一下parse函数：
void url::parse (char *arg) { int deb = 0, fin = deb; // Find the end of host name (put it into lowerCase) while (arg[fin] != '/' && arg[fin] != ':' && arg[fin] != 0) { fin++; } if (fin == 0) return; // get host name host = new char[fin+1]; for (int i=0; i<fin; i++) { host[i] = lowerCase(arg[i]); } host[fin] = 0; // get port number if (arg[fin] == ':') { port = 0; fin++; while (arg[fin] >= '0' && arg[fin] <= '9') { port = port*10 + arg[fin]-'0'; fin++; } } // get file name if (arg[fin] != '/') { // www.inria.fr => add the final / file = newString("/"); } else { file = newString(arg + fin); } }
这个代码写的太有爱了，一目了然，我们很容易明白，这就是一个字符串解析
然后分析出 host，port，和file。
4，然后下一个解析函数 parseWithBase函数：
void url::parseWithBase (char *u, url *base) { // cat filebase and file if (u[0] == '/') { file = newString(u); } else { uint lenb = strlen(base->file); char *tmp = new char[lenb + strlen(u) + 1]; memcpy(tmp, base->file, lenb); strcpy(tmp + lenb, u); file = tmp; } if (!normalize(file)) { delete [] file; file = NULL; return; } host = newString(base->host); port = base->port; }
这个函数主要是使用了已知URL类来构造新的URL，主机和端口都不会变
相当于相对路径的基准路径，然后根据URL路径+现在路径 然后序列化位标准路经
就是相对路径转化为绝对路径，这个相对比较简单
这样这个url的构造就结束了，
有一种落差是，你配不上自己的野心，也辜负了所受的苦难
