jincm13
jincm13

nginx的filter的处理

nginx的filter的处理

文章分类:C++编程
随笔拿一个nginx的filter模块来看，gzip模块，来看它的初始化。

Java代码  
  1. static ngx_http_output_header_filter_pt  ngx_http_next_header_filter;   
  2. static ngx_http_output_body_filter_pt    ngx_http_next_body_filter;   
  3.   
  4. static ngx_int_t   
  5. ngx_http_gzip_filter_init(ngx_conf_t *cf)   
  6. {   
  7.     ngx_http_next_header_filter = ngx_http_top_header_filter;   
  8.     ngx_http_top_header_filter = ngx_http_gzip_header_filter;   
  9.   
  10.     ngx_http_next_body_filter = ngx_http_top_body_filter;   
  11.     ngx_http_top_body_filter = ngx_http_gzip_body_filter;   
  12.   
  13.     return NGX_OK;   
  14. }  



这里nginx处理filter将所有的过滤器做成一个类似链表的东东，每次声明一个ngx_http_next_header_filter以及ngx_http_next_body_filter来保存当前的最前面的filter，然后再将自己的filter处理函数赋值给ngx_http_top_header_filter以及ngx_http_top_body_filter ，这样也就是说最后面初始化的filter反而是最早处理。

而在模块本身的filter处理函数中会调用ngx_http_next_header_filter，也就是当前filter插入前的那个最top上的filter处理函数。

然后我们来看nginx如何启动filter的调用。

先来看head_filter的调用：

Java代码  
  1. ngx_int_t   
  2. ngx_http_send_header(ngx_http_request_t *r)   
  3. {   
  4.     if (r->err_status) {   
  5.         r->headers_out.status = r->err_status;   
  6.         r->headers_out.status_line.len = 0;   
  7.     }   
  8.   
  9.     return ngx_http_top_header_filter(r);   
  10. }  


可以看到当发送header的时候就是调用ngx_http_top_header_filter,nginx这里把status这些也作为一个filter模块来处理的。当启动ngx_http_top_header_filter之后所有的filter处理函数就会象链表一样被一个个的调用。


然后是body filter的调用，这个和header的类似，因此就不解释了。
Java代码  
  1. ngx_int_t   
  2. ngx_http_output_filter(ngx_http_request_t *r, ngx_chain_t *in)   
  3. {   
  4.     ngx_int_t          rc;   
  5.     ngx_connection_t  *c;   
  6.   
  7.     c = r->connection;   
  8.   
  9.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,   
  10.                    "http output filter \"%V?%V\"", &r->uri, &r->args);   
  11.   
  12. //启动body filter。   
  13.     rc = ngx_http_top_body_filter(r, in);   
  14. ..............................................................   
  15.   
  16.     return rc;   
  17. }  


这里还有一个问题，那就是最后一个ngx_http_top_header_filter和ngx_http_top_body_filter是什么呢？也就是第一个被插入的filter。

先来看filter被初始化的地方。这里filter的初始化是在ngx_http_block函数中：

Java代码  
  1. for (m = 0; ngx_modules[m]; m++) {   
  2.         if (ngx_modules[m]->type != NGX_HTTP_MODULE) {   
  3.             continue;   
  4.         }   
  5.   
  6.         module = ngx_modules[m]->ctx;   
  7.   
  8. //如果存在postconfiguratio则调用初始化。   
  9.         if (module->postconfiguration) {   
  10.             if (module->postconfiguration(cf) != NGX_OK) {   
  11.                 return NGX_CONF_ERROR;   
  12.             }   
  13.         }   
  14.     }  


代码很简单就是遍历ngx_modules然后调用初始化函数，而我们这里要找第一个filter，也就是ngx_modules中的第一个bodyfilter和header filter。

来看objs/ngx_modules.c中的ngx_module的定义：

Java代码  
  1. ngx_module_t *ngx_modules[] = {   
  2.  ..............................................................   
  3.     &ngx_http_write_filter_module,   
  4.     &ngx_http_header_filter_module,   
  5. ........................................................................   
  6.     NULL   
  7. };  


可以看到ngx_http_write_filter_module和ngx_http_header_filter_module分别是body filter和header filter的第一个初始化模块，也就是filter链中的最后一个模块。

接下来我们就来详细分析这两个模块，首先是ngx_http_write_filter_module模块。

这个模块的功能起始很简单，就是遍历chain，然后输出所有的数据，如果有设置flush的话刷新chain。

这里要注意ngx_http_request_t中有一个out的chain，这个chain保存的是上一次还没有被发完的buf，这样每次我们接收到新的chain的话，就需要将新的chain连接到老的out chain上，然后再发出去。

来看代码。

Java代码  
  1. ngx_int_t   
  2. ngx_http_write_filter(ngx_http_request_t *r, ngx_chain_t *in)  


第一个是request请求，第二个参数是输入的chain。

先来看初始化部分：


Java代码  
  1.      
  2.  off_t                      size, sent, nsent, limit;   
  3.     ngx_uint_t                 last, flush;   
  4.     ngx_msec_t                 delay;   
  5.     ngx_chain_t               *cl, *ln, **ll, *chain;   
  6.     ngx_connection_t          *c;   
  7.     ngx_http_core_loc_conf_t  *clcf;   
  8.   
  9. //得到当前所属的连接   
  10.     c = r->connection;   
  11.   
  12.     if (c->error) {   
  13.         return NGX_ERROR;   
  14.     }   
  15.   
  16.     size = 0;   
  17.     flush = 0;   
  18.     last = 0;   
  19. //得到上次没有发送完毕的chain   
  20.     ll = &r->out;  


然后接下来这部分是校验并统计out chain，也就是上次没有完成的chain buf。
 
Java代码  
  1.     
  2.  for (cl = r->out; cl; cl = cl->next) {   
  3.         ll = &cl->next;   
  4.   
  5. #if 1  
  6. //如果有0长度的buf则返回错误。   
  7.         if (ngx_buf_size(cl->buf) == 0 && !ngx_buf_special(cl->buf)) {   
  8.  ......................................................................   
  9.   
  10.             ngx_debug_point();   
  11.             return NGX_ERROR;   
  12.         }   
  13. #endif   
  14.   
  15. //得到buf的大小   
  16.         size += ngx_buf_size(cl->buf);   
  17. //看当传输完毕后是否要刷新buf。   
  18.         if (cl->buf->flush || cl->buf->recycled) {   
  19.             flush = 1;   
  20.         }   
  21. //看是否是最后一个buf   
  22.         if (cl->buf->last_buf) {   
  23.             last = 1;   
  24.         }   
  25.     }  


接下来这部分是用来链接新的chain到上面的out chain后面：

Java代码  
  1. for (ln = in; ln; ln = ln->next) {   
  2. //   
  3.         cl = ngx_alloc_chain_link(r->pool);   
  4.         if (cl == NULL) {   
  5.             return NGX_ERROR;   
  6.         }   
  7.   
  8.         cl->buf = ln->buf;   
  9. //前面的代码我们知道ll已经指向out chain的最后一个位置了，因此这里就是将新的chain链接到out chain的后面。   
  10.         *ll = cl;   
  11.         ll = &cl->next;   
  12. #if 1  
  13. //校验buf   
  14.         if (ngx_buf_size(cl->buf) == 0 && !ngx_buf_special(cl->buf)) {   
  15.   
  16.             ngx_debug_point();   
  17.             return NGX_ERROR;   
  18.         }   
  19. #endif   
  20.   
  21. //计算大小   
  22.         size += ngx_buf_size(cl->buf);   
  23.   
  24. //判断是否需要flush   
  25.         if (cl->buf->flush || cl->buf->recycled) {   
  26.             flush = 1;   
  27.         }   
  28.   
  29. //判断是否是最后一个buf   
  30.         if (cl->buf->last_buf) {   
  31.             last = 1;   
  32.         }   
  33.     }  


然后接下来的这段代码主要是对进行发送前buf的一些标记的处理。

在看代码之前先来解释下几个比较重要的标记。

第一个是ngx_http_core_module的conf的一个标记postpone_output(conf里面可以配置的)，这个表示延迟输出的阀，也就是说将要发送的字节数如果小于这个的话，并且还有另外几个条件的话(下面会解释),就会直接返回不发送当前的chain。

第二个是c->write->delayed,这个表示当前的连接的写必须要被delay了，也就是说现在不能发送了(原因下面会解释)，得等另外的地方取消了delayed才能发送，此时我们修改连接的buffered的标记，然后返回NGX_AGAIN.

第三个是c->buffered，因为有时buf并没有发完，因此我们有时就会设置buffed标记，而我们可能会在多个filter模块中被buffered，因此下面就是buffered的类型。

Java代码  
  1. //这个并没有用到   
  2. #define NGX_HTTP_LOWLEVEL_BUFFERED         0xf0  
  3. //主要是这个，这个表示在最终的write filter中被buffered   
  4. #define NGX_HTTP_WRITE_BUFFERED            0x10  
  5. //判断是否有被设置   
  6. #define NGX_LOWLEVEL_BUFFERED  0x0f  
  7.   
  8. //下面几个filter中被buffered   
  9. #define NGX_HTTP_GZIP_BUFFERED             0x20  
  10. #define NGX_HTTP_SSI_BUFFERED              0x01  
  11. #define NGX_HTTP_SUB_BUFFERED              0x02  
  12. #define NGX_HTTP_COPY_BUFFERED             0x04  


然后我们来看第二个的意思，这个表示当前的chain已经被buffered了，


第四个是r->limit_rate，这个表示当前的request的发送限制速率，这个也是在nginx.conf中配置的，而一般就是通过这个值来设置c->write->delayed的。也就是说如果发送速率大于这个limit了的话，就设置delayed，然后这边的request就会延迟发送，下面我们的代码会看到nginx如何处理。

  
Java代码  
  1.   
  2.  clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);   
  3.   
  4. //也就是说将要发送的字节数小于postpone_output并且不是最后一个buf，并且不需要刷新chain的话，就直接返回。   
  5.     if (!last && !flush && in && size < (off_t) clcf->postpone_output) {   
  6.         return NGX_OK;   
  7.     }   
  8.   
  9. ///如果设置了write的delayed,则设置标记。   
  10.     if (c->write->delayed) {   
  11.         c->buffered |= NGX_HTTP_WRITE_BUFFERED;   
  12.         return NGX_AGAIN;   
  13.     }   
  14.   
  15. //如果size为0,并且没有设置buffered标记，则进入清理工作。   
  16.     if (size == 0 && !(c->buffered & NGX_LOWLEVEL_BUFFERED)) {   
  17. //如果是最后一个buf，则清理buffered标记然后清理out chain   
  18.         if (last) {   
  19.             r->out = NULL;   
  20.             c->buffered &= ~NGX_HTTP_WRITE_BUFFERED;   
  21.   
  22.             return NGX_OK;   
  23.         }   
  24.   
  25. //如果有设置flush的话，则会强行传输当前buf之前的所有buf，因此这里就需要清理out chain。   
  26.         if (flush) {   
  27.             do {   
  28.                 r->out = r->out->next;   
  29.             } while (r->out);   
  30.   
  31. //清理buf 标记   
  32.             c->buffered &= ~NGX_HTTP_WRITE_BUFFERED;   
  33.   
  34.             return NGX_OK;   
  35.         }   
  36.   
  37.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,   
  38.                       "the http output chain is empty");   
  39.   
  40.         ngx_debug_point();   
  41.   
  42.         return NGX_ERROR;   
  43.     }   
  44.   
  45. //如果有发送速率限制。   
  46.     if (r->limit_rate) {   
  47. //计算是否有超过速率限制   
  48.         limit = r->limit_rate * (ngx_time() - r->start_sec + 1)   
  49.                 - (c->sent - clcf->limit_rate_after);   
  50. //如果有   
  51.         if (limit <= 0) {   
  52. //设置delayed标记   
  53.             c->write->delayed = 1;   
  54. //设置定时器   
  55.             ngx_add_timer(c->write,   
  56.                           (ngx_msec_t) (- limit * 1000 / r->limit_rate + 1));   
  57.   
  58. //设置buffered。   
  59.             c->buffered |= NGX_HTTP_WRITE_BUFFERED;   
  60.   
  61.             return NGX_AGAIN;   
  62.         }   
  63.   
  64.     } else if (clcf->sendfile_max_chunk) {   
  65. //sendfile所用到的limit。   
  66.         limit = clcf->sendfile_max_chunk;   
  67.   
  68.     } else {   
  69.         limit = 0;   
  70.     }   
  71.   
  72.     sent = c->sent;  


然后接下来这段就是发送buf，以及发送完的处理部分。这里要注意send_chain返回值为还没有发送完的chain，这个函数我后面的blog会详细的分析的。

Java代码  
  1.   
  2. //调用发送函数。   
  3. chain = c->send_chain(c, r->out, limit);   
  4.   
  5.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,   
  6.                    "http write filter %p", chain);   
  7.   
  8.     if (chain == NGX_CHAIN_ERROR) {   
  9.         c->error = 1;   
  10.         return NGX_ERROR;   
  11.     }   
  12.   
  13. //控制imit_rate,这个值一般是在nginx.conf中配置的。   
  14.     if (r->limit_rate) {   
  15.   
  16.         nsent = c->sent;   
  17.   
  18.         if (clcf->limit_rate_after) {   
  19.   
  20.             sent -= clcf->limit_rate_after;   
  21.             if (sent < 0) {   
  22.                 sent = 0;   
  23.             }   
  24.   
  25.             nsent -= clcf->limit_rate_after;   
  26.             if (nsent < 0) {   
  27.                 nsent = 0;   
  28.             }   
  29.         }   
  30.   
  31.         delay = (ngx_msec_t) ((nsent - sent) * 1000 / r->limit_rate + 1);   
  32.   
  33.         if (delay > 0) {   
  34.             c->write->delayed = 1;   
  35.             ngx_add_timer(c->write, delay);   
  36.         }   
  37.   
  38.     } else if (c->write->ready   
  39.                && clcf->sendfile_max_chunk   
  40.                && (size_t) (c->sent - sent)   
  41.                       >= clcf->sendfile_max_chunk - 2 * ngx_pagesize)   
  42.     {   
  43.         c->write->delayed = 1;   
  44.         ngx_add_timer(c->write, 1);   
  45.     }   
  46.   
  47. //开始遍历上一次还没有传输完毕的chain，如果这次没有传完的里面还有的话，就跳出循环，否则free这个chain   
  48.     for (cl = r->out; cl && cl != chain; /* void */) {   
  49.         ln = cl;   
  50.         cl = cl->next;   
  51.         ngx_free_chain(r->pool, ln);   
  52.     }   
  53.   
  54. ///out chain赋值   
  55.     r->out = chain;   
  56.   
  57. //如果chain存在，则设置buffered并且返回again。   
  58.     if (chain) {   
  59.         c->buffered |= NGX_HTTP_WRITE_BUFFERED;   
  60.         return NGX_AGAIN;   
  61.     }   
  62.   
  63. //否则清理buffered   
  64.     c->buffered &= ~NGX_HTTP_WRITE_BUFFERED;   
  65.   
  66. //如果有其他的filter buffered并且postponed被设置了，则我们返回again，也就是还有buf要处理。   
  67.     if ((c->buffered & NGX_LOWLEVEL_BUFFERED) && r->postponed == NULL) {   
  68.         return NGX_AGAIN;   
  69.     }   
  70.   
  71. //否则返回ok   
  72.     return NGX_OK;  



然后我们来看ngx_http_header_filter_module模块，这个模块的处理函数是ngx_http_header_filter。这个函数最终还是会调用ngx_http_write_filter来将head输出。

这个函数主要就是处理http的头域，然后设置对应的reponse值，最终输出。

这里header filter比较简单，这里没有什么复杂的东西，主要就是设置一些status。然后拷贝，最后通过ngx_http_write_filter进行发送
 
 
 

1.为什么需要内存池

    为什么需要内存池？

a. 在大量的小块内存的申请和释放的时候，能更快地进行内存分配（对比malloc和free）

b.减少内存碎片，防止内存泄露。

2.内存池的原理

    内存池的原理非常简单，用申请一块较大的内存来代替N多的小内存块，当有需要malloc一块

比较小的内存是，直接拿这块大的内存中的地址来用即可。

    当然，这样处理的缺点也是很明显的，申请一块大的内存必然会导致内存空间的浪费，但是

比起频繁地malloc和free，这样做的代价是非常小的，这是典型的以空间换时间。

    一个典型的内存池如下图所示：

nginx的filter的处理_第1张图片

 

 

 

 

 

 

 

                 图一：一个典型的内存池。

 

    首先定义这样一个结构体：

 typedef struct MemoryBlock
{
  char *Data ;			//数据
  std::size_t DataSize ;	//总的大小
  std::size_t UsedSize ;	//已经用了的大小
  MemoryBlock*Next ;		
} MemoryBlock;

    一个内存池就是这样一连串的内存块组成。当需要用到内存的时候，调用此内存池定义好的接口

GetMemory(),而需要删除的时候FreeMemory（）。

    而GetMemory和FreeMemory干了什么呢？GetMemory只是简单返回内存池中可用空间的地址。

而FreeMemory干了两件事情：一： 改变UsedSize 的值，二：重新初始化这一内存区域。

 

3.nginx中的内存池

3.1 nginx内存池的结构表示

    首先我们看一下nginx内存池的定义：

 

代码 
struct ngx_pool_s {
    ngx_pool_data_t       d;//表示数据区域
    size_t                       max;//内存池能容纳数据的大小
    ngx_pool_t *             current;//当前内存池块（nginx中的内存池是又一连串的内存池链表组成的）
    ngx_chain_t*             chain;//主要为了将内存池连接起来
    ngx_pool_large_t*      large;//大块的数据
    ngx_pool_cleanup_t*  cleanup;//清理函数
    ngx_log_t*                 log;//写log
};

 

nginx中的内存池和普通的有比较大的不同。nginx中的内存池是由N个内存池链表

组成的，当一个内存池满了以后，就会从下一个内存池中提取空间来使用。 

  

对于ngx_pool_data_t的定义非常简单：

 

typedef struct {
    u_char               *last;
    u_char               *end;
    ngx_pool_t         *next;
    ngx_uint_t          failed;
} ngx_pool_data_t;

 

其中last表示当前数据区域的已经使用的数据的结尾。

end表示当前内存池的结尾。

next表示下一个内存池，前面已经说过，再nignx中，当一个内存池空间

不足的时候，它不会扩大其空间，而是再新建一个内存池，组成一个内存池链表。

failed标志申请内存的时候失败的次数。

 

在理解了这个结构体后面的就非常简单了。

 

current 表示当前的内存池。

 

chain表示内存池链表。

 

large表示大块的数据。

对于ngx_pool_large_t定义如下：

 

struct ngx_pool_large_s {
    ngx_pool_large_t*        next;
    void*                alloc;
};

 

此结构体的定义也是非常简单的。一个内存地址的指针已经指向下一个地址的指针。

这里再解释下为什么需要有large数据块。当一个申请的内存空间大小比内存池的大小还要大的时候，

malloc一块大的空间，再内存池用保留这个地址的指针。


Cleanup保持存着内存池被销毁的时候的清理函数。

              
              
              
              

               
               
               
               typedef void (*ngx_pool_cleanup_pt)(void *data);
              
              
              
              

              
              
              
              

               
               
               
               struct
               
               
               
                ngx_pool_cleanup_s { ngx_pool_cleanup_pt handler; void*
               
               
               
                data; ngx_pool_cleanup_t*
               
               
               
                next; };

 

ngx_pool_cleanup_pt 是一个函数指针的典型用法，

在这个结果中保存这需要清理的数据指针以及相应的清理函数， 让内存池销毁

或其他需要清理内存池的时候，可以调用此结构体中的handler。

    下面是我画的一张nginx的内存池的结构图。

                        nginx的filter的处理_第2张图片
                                                        <图1. ngx_pool 结构体>

3.2 nginx内存池源代码分析

    要大体了解一个内存池，只需要了解其池子的创建，内存的分配以及池子的销毁即可。下面就分析下

ngx_pool_t的这个3个方面。注：其中有些代码可能与ngx_pool中的源代码有所差异，但是整体意思

绝对是一样的，本人的修改，只是为了更好的分析,比如 我就把所有写log的过程都去掉了。

3.2.1 ngx_create_pool

创建一个内存池

 ngx_pool_t* ngx_create_poo(size_t size) { ngx_pool_t* p; p = (ngx_pool_t*)malloc(size); if (!p){ return NULL; } //计算内存池的数据区域 p->d->last = (u_char*)p + sizeof(ngx_pool_t); p->d->end = (u_char*)p + size; p->d->next = NULL;//下个内存池 p->d->failed = 0; size = size - sizeof(ngx_pool_t);; p->max = size;//最大数据 //我现在还是是一个单一的内存池 p->current = p; p->chain = NULL; //只有在需要的时候才分配大的内存区域 p->large = NULL; p->cleanup = NULL; return p; }


    nginx内存池的创建非常简单，申请一开size大小的内存，把它分配给 ngx_poo_t。

3.2.2 ngx_palloc

从内存池中分配内存.

 void* ngx_palloc(ngx_pool_t* pool, size_t size) { u_char* m; ngx_pool_t* p; //遍历内存池，拿出可用的内存区域 if (size <= pool->max){ p = pool->current; do { m = p->d->last; if ((size_t)(p->d->end - m) >= size) { p->d->last = m + size;//用掉了当然要改变*last了 return m; } p = p->d->next; } while (p); return ngx_palloc_block(pool, size); //所有的内存池都已经满了，我要再增加一个 } //申请的内存超过了内存池的大小，所以用 return ngx_palloc_large(pool, size); }

 

 

    这个函数从内存池用拿出内存，如果当前内存池已满，到下一个内存池，如果所有的内存池已满，

增加一个新的内存池，如果申请的内存超过了内存池的最大值，从*large中分配

3.3.3  ngx_destroy_pool

内存池的销毁

 void ngx_destroy_pool(ngx_pool_t* pool) { ngx_pool_t *p, *n; ngx_pool_large_t *l; ngx_pool_cleanup_t *c; //调用清理函数 for (c = pool->cleanup; c; c = c->next) { if (c->handler) { c->handler(c->data); } } //释放大块的内存 for (l = pool->large; l; l = l->next) { if (l->alloc) { free(l->alloc); } } //小块的内存，真正意义上的内存池 for (p = pool, n = pool->d->next; /* void */; p = n, n = n->d->next) { free(p); //如果当前内存池为空，之后的毕为空 if (n == NULL) { break; } } }

 

 

    销毁一个内存池其实就是干了三件事， 调用清理韩式， 释放大块的内存，释放内存池，需要注意的

一点是在nginx中， 小块内存除了在内存池被销毁的时候都是不能被释放的。

 

3.3.4 ngx_palloc_block

    前面说过，在nginx中，当内存池满了以后，会增加一个新的内存池。这个动作就是靠ngx_palloc_block

函数实现的。

 static void* ngx_palloc_block(ngx_pool_t* pool, size_t size) { u_char *m; size_t psize; ngx_pool_t *p, *pnew, *current; psize = (size_t) (pool->d->end - (u_char *) pool); m = (u_char*)malloc(psize); if (!m){ return NULL; } //一个新的内存池 pnew = (ngx_pool_t*) m; pnew->d->end = m +psize; pnew->d->next = NULL; pnew->d->failed = 0; //是不是和ngx_palloc很相似啊 m += sizeof(ngx_pool_data_t); pnew->d->last = m + size; current = pool->current; //遍历到内存池链表的末尾 for (p = current; p->d->next; p = p->d->next) { if (p->d->failed++ > 4) {//为什么4？推测是个经验值 current = p->d->next; } } p->d->next = pnew; pool->current = current ? current : pnew; return m; }

 

    这个函数就是申请了一块内存区域，变为一个内存池，然后把它连接到原来内存池的末尾。

3.3.5 ngx_palloc_large 和ngx_pfree

    在nginx中，小块内存除了在内存池销毁之外是不能释放的，但是大块内存却可以，这两个

函数就是用来控制大块内存的申请和释放， 代码也非常简单，调用malloc申请内存，连接到

ngx_pool_large_t中 和 调用free释放内存。这里就不贴上代码了。

 

4. 小结

    不知不觉，写了快一个下午的时间了，真快啊。

     nginx的内存池的代码也先介绍到这里，其实nginx内存池功能强大，所以代码也比较复杂，

这里只

 

 

 

1顶
1踩
nginx中锁的设计以及惊群的处理 | nginx的filter的处理
2010 - 04 - 24

nginx中的output chain的处理(一)

文章分类:C++编程
这里我们详细来看ngx_linux_sendfile_chain方法，这个函数也就是nginx的发送函数。

一般来说，我们最终都会调用这个函数来发送最终的数据，因此我们来着重分析这个函数，这里主要就是对buf的一些参数的理解。

来看函数原型：
Java代码  
  1. ngx_chain_t *   
  2. ngx_linux_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)  

第一个参数是当前的连接，第二个参数是所需要发送的chain，第三个参数是所能发送的最大值。

然后来看这里的几个重要的变量：

Java代码  
  1.   
  2. send 表示将要发送的buf已经已经发送的大小。   
  3. sent表示已经发送的buf的大小   
  4. prev_send 表示上一次发送的大小，也就是已经发送的buf的大小。   
  5. fprev 和prev-send类似，只不过是file类型的。   
  6.   
  7. complete表示是否buf被完全发送了，也就是sent是否等于send - prev_send.   
  8.   
  9. header表示需要是用writev来发送的buf。也就是only in memory的buf。   
  10.   
  11. struct iovec  *iov, headers[NGX_HEADERS] 这个主要是用于sendfile和writev的参数，这里注意上面header数组保存的就是iovec。  


然后我们来看初始化

   
Java代码  
  1. wev = c->write;   
  2.   
  3.     if (!wev->ready) {   
  4.         return in;   
  5.     }   
  6.   
  7.     if (limit == 0 || limit > (off_t) (NGX_SENDFILE_LIMIT - ngx_pagesize)) {   
  8.         limit = NGX_SENDFILE_LIMIT - ngx_pagesize;   
  9.     }   
  10.   
  11.   
  12.     send = 0;   
  13. //设置header，也就是in memory的数组   
  14.     header.elts = headers;   
  15.     header.size = sizeof(struct iovec);   
  16.     header.nalloc = NGX_HEADERS;   
  17.     header.pool = c->pool;  


这里nginx的处理核心思想就是合并内存连续并相邻的buf(不管是in memory还是in file)

下面这段代码就是处理in memory的部分，然后将buf放入对应的iovec数组。

Java代码  
  1.   
  2. //开始遍历   
  3. for (cl = in;   
  4.              cl && header.nelts < IOV_MAX && send < limit;   
  5.              cl = cl->next)   
  6.         {   
  7.             if (ngx_buf_special(cl->buf)) {   
  8.                 continue;   
  9.             }   
  10. //如果不止是在buf中，这是因为有时in file的文件我们可能需要内存中也有拷贝，所以如果一个buf同时in memoey和in file的话，nginx会认为它是in file的来处理。   
  11.             if (!ngx_buf_in_memory_only(cl->buf)) {   
  12.                 break;   
  13.             }   
  14.   
  15. //得到buf的大小   
  16.             size = cl->buf->last - cl->buf->pos;   
  17.   
  18. //大于limit的话修改为size   
  19.             if (send + size > limit) {   
  20.                 size = limit - send;   
  21.             }   
  22. //如果prev等于pos，则说明当前的buf的数据和前一个buf的数据是连续的。   
  23.             if (prev == cl->buf->pos) {   
  24.                 iov->iov_len += (size_t) size;   
  25.   
  26.             } else {   
  27. //否则说明是不同的buf，因此add一个iovc。   
  28.                 iov = ngx_array_push(&header);   
  29.                 if (iov == NULL) {   
  30.                     return NGX_CHAIN_ERROR;   
  31.                 }   
  32.   
  33.                 iov->iov_base = (void *) cl->buf->pos;   
  34.                 iov->iov_len = (size_t) size;   
  35.             }   
  36.   
  37. //这里可以看到prev保存了当前buf的结尾。   
  38.             prev = cl->buf->pos + (size_t) size;   
  39. //更新发送的大小   
  40.             send += size;   
  41.         }  


然后是in file的处理这里比较核心的一个判断就是fprev == cl->buf->file_pos，和上面的in memory类似，fprev保存的就是上一次处理的buf的尾部。这里如果这两个相等，那就说明当前的两个buf是连续的(文件连续).

ok.来看代码。

Java代码  
  1.   
  2. //可以看到如果header的大小不为0则说明前面有需要发送的buf，因此我们就跳过in file处理   
  3. if (header.nelts == 0 && cl && cl->buf->in_file && send < limit) {   
  4. //得到file   
  5.             file = cl->buf;   
  6.   
  7. //开始合并。   
  8.             do {   
  9. //得到大小   
  10.                 size = cl->buf->file_last - cl->buf->file_pos;   
  11.   
  12. //如果太大则进行对齐处理。   
  13.                 if (send + size > limit) {   
  14.                     size = limit - send;   
  15.   
  16.                     aligned = (cl->buf->file_pos + size + ngx_pagesize - 1)   
  17.                                & ~((off_t) ngx_pagesize - 1);   
  18.   
  19.                     if (aligned <= cl->buf->file_last) {   
  20.                         size = aligned - cl->buf->file_pos;   
  21.                     }   
  22.                 }   
  23.   
  24. //设置file_size.   
  25.                 file_size += (size_t) size;   
  26. //设置需要发送的大小   
  27.                 send += size;   
  28. //和上面的in memory处理一样就是保存这次的last   
  29.                 fprev = cl->buf->file_pos + size;   
  30.                 cl = cl->next;   
  31.   
  32.             } while (cl   
  33.                      && cl->buf->in_file   
  34.                      && send < limit   
  35.                      && file->file->fd == cl->buf->file->fd   
  36.                      && fprev == cl->buf->file_pos);   
  37.         }  


然后就是发送部分，这里in file使用sendfile,in memory使用writev.这里处理比较简单，就是发送然后判断发送的大小

Java代码  
  1. if (file) {   
  2. #if 1  
  3.             if (file_size == 0) {   
  4.                 ngx_debug_point();   
  5.                 return NGX_CHAIN_ERROR;   
  6.             }   
  7. #endif   
  8. #if (NGX_HAVE_SENDFILE64)   
  9.             offset = file->file_pos;   
  10. #else  
  11.             offset = (int32_t) file->file_pos;   
  12. #endif   
  13.   
  14. //发送数据   
  15.             rc = sendfile(c->fd, file->file->fd, &offset, file_size);   
  16. ......................................................   
  17. //得到发送的字节数   
  18.             sent = rc > 0 ? rc : 0;   
  19.   
  20.         } else {   
  21.             rc = writev(c->fd, header.elts, header.nelts);   
  22. .......................................................................   
  23.   
  24.             sent = rc > 0 ? rc : 0;   
  25. }   
  26.           


接下来这部分就是更新标记的部分，主要是buf的标记。

这里要注意一个地方，那就是ngx_buf_size部分，这个宏很简单就是判断buf是不是在memory中，如果是的话，就用pos和last计算，否则认为是在file中。

可是这里就有个问题了，如果一个buf本来是在file中的，我们由于某种原因，在内存中也有一份拷贝，可是我们并没有修改内存中的副本，于是如果我们还需要切割这个buf，这个时候，如果last和pos也就是buf对应的指针没有设置正确的话，这里就会出现问题了。

这里我觉得应该还有个标记，那就是如果内存中的副本我只是只读的话，发送的时候不应该算它在memory中。

Java代码  
  1.   
  2. //如果send - prev_send == sent则说明该发送的都发完了。   
  3. if (send - prev_send == sent) {   
  4.             complete = 1;   
  5.         }   
  6. //更新congnect的sent域。   
  7.         c->sent += sent;   
  8.   
  9. //开始重新遍历chain，这里是为了防止没有发送完全的情况，此时我们就需要切割buf了。   
  10.         for (cl = in; cl; cl = cl->next) {   
  11.   
  12.             if (ngx_buf_special(cl->buf)) {   
  13.                 continue;   
  14.             }   
  15.   
  16.             if (sent == 0) {   
  17.                 break;   
  18.             }   
  19. //得到buf size   
  20.             size = ngx_buf_size(cl->buf);   
  21.   
  22. //如果大于当前的size，则说明这个buf的数据已经被完全发送完毕了。，因此更新它的域。   
  23.             if (sent >= size){   
  24. //更新sent域   
  25.                 sent -= size;   
  26. //如果在内存则更新pos   
  27.                 if (ngx_buf_in_memory(cl->buf)) {   
  28.                     cl->buf->pos = cl->buf->last;   
  29.                 }   
  30. //如果在file   
  31.                 if (cl->buf->in_file) {   
  32.                     cl->buf->file_pos = cl->buf->file_last;   
  33.                 }   
  34.   
  35.                 continue;   
  36.             }   
  37.   
  38. //到这里说明当前的buf只有一部分被发送出去了，因此这里我们只需要修改指针。以便于下次发送。   
  39.             if (ngx_buf_in_memory(cl->buf)) {   
  40.                 cl->buf->pos += (size_t) sent;   
  41.             }   
  42. //同上。   
  43.             if (cl->buf->in_file) {   
  44.                 cl->buf->file_pos += sent;   
  45.             }   
  46.   
  47.             break;   
  48.         }  


最后一部分就是一些是否退出循环的操作。这里要注意，nginx中如果发送未完全的话，将会直接返回的，返回的就是没有发送完毕的chain，它的buf也已经被更新。这是因为nginx是单线程的，不能有任何意义的空跑和阻塞，因此当complete为0,nginx就认为是系统负载过大，此时直接返回，然后处理其他的事情，等待和下次的chain一起发送。

Java代码   
  1.   
  2. if (eintr) {   
  3.             continue;   
  4.         }   
  5. //如果未完成，则返回。   
  6.         if (!complete) {   
  7.             wev->ready = 0;   
  8.             return cl;   
  9.         }   
  10.   
  11.         if (send >= limit || cl == NULL) {   
  12.             return cl;   
  13.         }   
  14. //更新in，也就是开始处理下一个chain   
  15.         in = cl;
  25. 是列出了内存池的大体流程，还有很到一部分代码未列出来
 
 
着上次的分析继续，这次我们来看filter链中最关键的一个模块，那就是ngx_http_copy_filter_module模块，这个filter主要是用来将一些需要复制的buf(文件或者内存)重新复制一份然后发送给剩余的body filter，这里有个很重要的部分，那就是在这里nginx的剩余的body filter有可能会被调用多次，这个接下来我会一一阐述的。先来看它的初始化函数：

Java代码  
  1. static ngx_int_t   
  2. ngx_http_copy_filter_init(ngx_conf_t *cf)   
  3. {   
  4.     ngx_http_next_filter = ngx_http_top_body_filter;   
  5.     ngx_http_top_body_filter = ngx_http_copy_filter;   
  6.   
  7.     return NGX_OK;   
  8. }  


可以看到，它只有body filter，而没有header filter，也就是说只有body filter才会使用这个filter。

然后这个模块对应也有一个命令，那就是output_buffers，这个命令保存值在它的conf的bufs中：

Java代码  
  1. typedef struct {   
  2.     ngx_bufs_t  bufs;   
  3. } ngx_http_copy_filter_conf_t;  


这里要知道在nginx的配置文件中所有的bufs的格式都是一样，个数+每个的大小。这个值我们接下来分析filter代码的时候会再次看到。

然后来看对应的merge方法，来看这个bufs的默认值是多少。

Java代码  
  1. static char *   
  2. ngx_http_copy_filter_merge_conf(ngx_conf_t *cf, void *parent, void *child)   
  3. {   
  4.     ngx_http_copy_filter_conf_t *prev = parent;   
  5.     ngx_http_copy_filter_conf_t *conf = child;   
  6.   
  7. //默认是1个buf，大小为32768字节   
  8.     ngx_conf_merge_bufs_value(conf->bufs, prev->bufs, 1, 32768);   
  9.   
  10.     return NULL;   
  11. }  


由于copy filter没有header filter，因此它的context的初始化也是放在body filter中的，而它的ctx就是ngx_output_chain_ctx_t，为什么名字是output_chain呢，这是因为copy filter的主要逻辑的处理都是放在ngx_output_chain中的，这个模块我们可以看到它是保存在core目录下的，而不是属于http目录的。

接下来我们就来看这个context的结构。

Java代码  
  1. typedef struct {   
  2. //保存临时的buf   
  3.     ngx_buf_t                   *buf;   
  4. //保存了将要发送的chain   
  5.     ngx_chain_t                 *in;   
  6. //保存了已经发送完毕的chain，以便于重复利用   
  7.     ngx_chain_t                 *free;   
  8. //保存了还未发送的chain   
  9.     ngx_chain_t                 *busy;   
  10.   
  11. //sendfile标记   
  12.     unsigned                     sendfile:1;   
  13. //directio标记   
  14.     unsigned                     directio:1;   
  15. #if (NGX_HAVE_ALIGNED_DIRECTIO)   
  16.     unsigned                     unaligned:1;   
  17. #endif   
  18. //是否需要在内存中保存一份(使用sendfile的话，内存中没有文件的拷贝的，而我们有时需要处理文件，此时就需要设置这个标记)   
  19.     unsigned                     need_in_memory:1;   
  20. //是否存在的buf复制一份，这里不管是存在在内存还是文件，后面会看到这两个标记的区别。   
  21.     unsigned                     need_in_temp:1;   
  22.   
  23.     ngx_pool_t                  *pool;   
  24. //已经allocated的大小   
  25.     ngx_int_t                    allocated;   
  26. //对应的bufs的大小，这个值就是我们loc conf中设置的bufs   
  27.     ngx_bufs_t                   bufs;   
  28. //表示现在处于那个模块（因为upstream也会调用output_chain)   
  29.     ngx_buf_tag_t                tag;   
  30.   
  31. //这个值一般是ngx_http_next_filter,也就是继续调用filter链   
  32.     ngx_output_chain_filter_pt   output_filter;   
  33. //当前filter的上下文，这里也是由于upstream也会调用output_chain   
  34.     void                        *filter_ctx;   
  35. } ngx_output_chain_ctx_t;  



接下来我们来看具体函数的实现，就能更好的理解context中的这些域的意思。

来看copy_filter的body filter。

Java代码  
  1. static ngx_int_t   
  2. ngx_http_copy_filter(ngx_http_request_t *r, ngx_chain_t *in)   
  3. {   
  4.     ngx_int_t                     rc;   
  5.     ngx_connection_t             *c;   
  6.     ngx_output_chain_ctx_t       *ctx;   
  7.     ngx_http_copy_filter_conf_t  *conf;   
  8.   
  9.     c = r->connection;   
  10.   
  11. //获取ctx   
  12.     ctx = ngx_http_get_module_ctx(r, ngx_http_copy_filter_module);   
  13.   
  14. //如果为空，则说明需要初始化ctx   
  15.     if (ctx == NULL) {   
  16.         conf = ngx_http_get_module_loc_conf(r, ngx_http_copy_filter_module);   
  17.   
  18.         ctx = ngx_pcalloc(r->pool, sizeof(ngx_output_chain_ctx_t));   
  19.         if (ctx == NULL) {   
  20.             return NGX_ERROR;   
  21.         }   
  22.   
  23.         ngx_http_set_ctx(r, ctx, ngx_http_copy_filter_module);   
  24.   
  25. //设置对应的域   
  26.         ctx->sendfile = c->sendfile;   
  27. //可以看到如果我们给request设置filter_need_in_memory的话，ctx的这个域就会被设置   
  28.         ctx->need_in_memory = r->main_filter_need_in_memory   
  29.                               || r->filter_need_in_memory;   
  30. //和上面类似   
  31.         ctx->need_in_temp = r->filter_need_temporary;   
  32.   
  33.         ctx->pool = r->pool;   
  34.         ctx->bufs = conf->bufs;   
  35.         ctx->tag = (ngx_buf_tag_t) &ngx_http_copy_filter_module;   
  36. //可以看到output_filter就是body filter的next   
  37.         ctx->output_filter = (ngx_output_chain_filter_pt) ngx_http_next_filter;   
  38. //此时filter ctx为当前的请求   
  39.         ctx->filter_ctx = r;   
  40.   
  41.         r->request_output = 1;   
  42.     }   
  43. //最关键的函数，下面会详细分析。   
  44.     rc = ngx_output_chain(ctx, in);   
  45. ......................................................   
  46.   
  47.     return rc;   
  48. }  


然后就是ngx_output_chain这个函数了，这里nginx filter的主要逻辑都在这个函数里面。下面就是这个函数的原型。

Java代码  
  1. ngx_int_t   
  2. ngx_output_chain(ngx_output_chain_ctx_t *ctx, ngx_chain_t *in)  


然后我们来分段看它的代码，下面这段代码可以说是一个short path，也就是说我们能直接确定所有的in chain都不需要复制的时候，我们就可以直接调用output_filter来交给剩下的filter去处理。

  
Java代码  
  1.  if (ctx->in == NULL && ctx->busy == NULL) {   
  2.   
  3. //下面的注释解释的很详细   
  4.         /*  
  5.          * the short path for the case when the ctx->in and ctx->busy chains  
  6.          * are empty, the incoming chain is empty too or has the single buf  
  7.          * that does not require the copy  
  8.          */  
  9.   
  10.         if (in == NULL) {   
  11.             return ctx->output_filter(ctx->filter_ctx, in);   
  12.         }   
  13.   
  14. //这里说明只有一个chain，并且它的buf不需要复制   
  15.         if (in->next == NULL   
  16. #if (NGX_SENDFILE_LIMIT)   
  17.             && !(in->buf->in_file && in->buf->file_last > NGX_SENDFILE_LIMIT)   
  18. #endif   
  19.             && ngx_output_chain_as_is(ctx, in->buf))   
  20.         {   
  21.             return ctx->output_filter(ctx->filter_ctx, in);   
  22.         }   
  23.     }  


上面我们看到了一个函数 ngx_output_chain_as_is，这个函数很关键，下面还会再次被调用，这个函数主要用来判断是否需要复制buf。返回1,表示不需要拷贝，否则为需要拷贝
Java代码  
  1. static ngx_inline ngx_int_t   
  2. ngx_output_chain_as_is(ngx_output_chain_ctx_t *ctx, ngx_buf_t *buf)   
  3. {   
  4.     ngx_uint_t  sendfile;   
  5.   
  6. //是否为specialbuf，是的话返回1,也就是不用拷贝   
  7.     if (ngx_buf_special(buf)) {   
  8.         return 1;   
  9.     }   
  10.   
  11. //如果buf在文件中，并且使用了directio的话，需要拷贝buf   
  12.     if (buf->in_file && buf->file->directio) {   
  13.         return 0;   
  14.     }   
  15.   
  16. //sendfile标记   
  17.     sendfile = ctx->sendfile;   
  18.   
  19. #if (NGX_SENDFILE_LIMIT)   
  20. //如果pos大于sendfile的限制，设置标记为0   
  21.     if (buf->in_file && buf->file_pos >= NGX_SENDFILE_LIMIT) {   
  22.         sendfile = 0;   
  23.     }   
  24.   
  25. #endif   
  26.   
  27.     if (!sendfile) {   
  28. //此时如果buf不在内存中，则我们就需要复制到内存一份。   
  29.         if (!ngx_buf_in_memory(buf)) {   
  30.             return 0;   
  31.         }   
  32. //否则设置in_file为0.   
  33.         buf->in_file = 0;   
  34.     }   
  35.   
  36. //如果需要内存中有一份拷贝，而并不在内存中，此时返回0，表示需要拷贝   
  37.     if (ctx->need_in_memory && !ngx_buf_in_memory(buf)) {   
  38.         return 0;   
  39.     }   
  40.   
  41. //如果需要内存中有拷贝,并且存在于内存中或者mmap中，则返回0.   
  42.     if (ctx->need_in_temp && (buf->memory || buf->mmap)) {   
  43.         return 0;   
  44.     }   
  45.   
  46.     return 1;   
  47. }  


上面有两个标记要注意，一个是need_in_memory ，这个主要是用于当我们使用sendfile的时候，nginx并不会将请求文件拷贝到内存中，而有时我们需要操作文件的内容，此时我们就需要设置这个标记(设置方法前面初始化有介绍).然后我们在body filter就能操作内容了。

第二个是need_in_temp，这个主要是用于把本来就存在于内存中的buf复制一份拷贝出来，这里有用到的模块有charset,也就是编解码 filter.

然后接下来这段是复制in chain到ctx->in的结尾.它是通过调用ngx_output_chain_add_copy来进行add copy的，这个函数比较简单，这里就不分析了，不过只有一个要注意的，那就是如果buf是存在于文件中，并且file_pos超过了sendfile limit，此时就会切割buf为两个buf，然后保存在两个chain中，最终连接起来.

Java代码  
  1. if (in) {   
  2. //复制到ctx->in中.   
  3.         if (ngx_output_chain_add_copy(ctx->pool, &ctx->in, in) == NGX_ERROR) {   
  4.             return NGX_ERROR;   
  5.         }   
  6.     }  


然后就是主要的逻辑处理阶段。这里nginx做的非常巧妙也非常复杂，首先是chain的重用，然后是buf的重用。

先来看chain的重用。关键的几个结构以及域，ctx的free,busy以及ctx->pool的chain域。
其中每次发送没有发完的chain就放到busy中，而已经发送完毕的就放到free中，而最后会调用  ngx_free_chain来将free的chain放入到pool->chain中,而在ngx_alloc_chain_link中，如果pool->chain中存在chain的话，就不用malloc了，而是直接返回pool->chain,我们来看相关的代码。

Java代码  
  1. //链接cl到pool->chain中   
  2. #define ngx_free_chain(pool, cl)                                             \   
  3.     cl->next = pool->chain;                                                  \   
  4.     pool->chain = cl   
  5.   
  6. ngx_chain_t *   
  7. ngx_alloc_chain_link(ngx_pool_t *pool)   
  8. {   
  9.     ngx_chain_t  *cl;   
  10.   
  11.     cl = pool->chain;   
  12. //如果cl存在，则直接返回cl   
  13.     if (cl) {   
  14.         pool->chain = cl->next;   
  15.         return cl;   
  16.     }   
  17. //否则才会malloc chain   
  18.     cl = ngx_palloc(pool, sizeof(ngx_chain_t));   
  19.     if (cl == NULL) {   
  20.         return NULL;   
  21.     }   
  22.   
  23.     return cl;   
  24. }  


然后是buf的重用，严格意义上来说buf的重用是从free中的chain中取得的，当free中的buf被重用，则这个buf对应的chain就会被链接到ctx->pool中，从而这个chain就会被重用.

也就是说buf的重用是第一被考虑的，只有当这个chain的buf确定不需要被重用(或者说已经被重用)的时候，chain才会被链接到ctx->pool中被重用。

还有一个就是ctx的allocated域，这个域表示了当前的上下文中已经分配了多少个buf，blog一开始我们有提到有个output_buffer命令用来设置output的buf大小以及buf的个数。而allocated如果比output_buffer大的话，我们就需要先发送完已经存在的buf，然后才能再次重新分配buf。

来看代码，上面所说的重用以及buf的控制，代码里面都可以看的比较清晰。这里代码我们分段来看，下面这段主要是拷贝buf前所做的一些工作，比如判断是否拷贝，以及给buf分贝内存等。

Java代码  
  1. //out为我们最终需要传输的chain，也就是交给剩下的filter处理的chain   
  2.  out = NULL;   
  3. //last_out为out的最后一个chain   
  4.     last_out = &out;   
  5.     last = NGX_NONE;   
  6.   
  7. for ( ;; ) {   
  8.   
  9. //开始遍历chain   
  10.         while (ctx->in) {   
  11.   
  12. //取得当前chain的buf大小   
  13.             bsize = ngx_buf_size(ctx->in->buf);   
  14.   
  15. //跳过bsize为0的buf   
  16.             if (bsize == 0 && !ngx_buf_special(ctx->in->buf)) {   
  17.                 ngx_debug_point();   
  18.   
  19.                 ctx->in = ctx->in->next;   
  20.   
  21.                 continue;   
  22.             }   
  23.   
  24. //判断是否需要复制buf   
  25.             if (ngx_output_chain_as_is(ctx, ctx->in->buf)) {   
  26.   
  27.                 /* move the chain link to the output chain */  
  28. //如果不需要复制，则直接链接chain到out，然后继续循环   
  29.                 cl = ctx->in;   
  30.                 ctx->in = cl->next;   
  31.   
  32.                 *last_out = cl;   
  33.                 last_out = &cl->next;   
  34.                 cl->next = NULL;   
  35.   
  36.                 continue;   
  37.             }   
  38.   
  39. //到达这里，说明我们需要拷贝buf，这里buf最终都会被拷贝进ctx->buf中，因此这里先判断ctx->buf是否为空   
  40.             if (ctx->buf == NULL) {   
  41.   
  42. //如果为空，则取得buf，这里要注意，一般来说如果没有开启directio的话，这个函数都会返回NGX_DECLINED的(具体实现可以去看这个函数的代码)。   
  43.                 rc = ngx_output_chain_align_file_buf(ctx, bsize);   
  44.   
  45.                 if (rc == NGX_ERROR) {   
  46.                     return NGX_ERROR;   
  47.                 }   
  48.   
  49. //大部分情况下，都会落入这个分支   
  50.                 if (rc != NGX_OK) {   
  51.   
  52. //准备分配buf，首先在free中寻找可以重用的buf   
  53.                     if (ctx->free) {   
  54.   
  55.                         /* get the free buf */  
  56. //得到free buf   
  57.                         cl = ctx->free;   
  58.                         ctx->buf = cl->buf;   
  59.                         ctx->free = cl->next;   
  60. //将要重用的chain链接到ctx->poll中，以便于chain的重用.   
  61.                         ngx_free_chain(ctx->pool, cl);   
  62.   
  63.                     } else if (out || ctx->allocated == ctx->bufs.num) {   
  64. //如果已经等于buf的个数限制，则跳出循环，发送已经存在的buf.这里可以看到如果out存在的话，nginx会跳出循环，然后发送out，等发送完会再次处理，这里很好的体现了nginx的流式处理   
  65.                         break;   
  66.   
  67.                     } else if (ngx_output_chain_get_buf(ctx, bsize) != NGX_OK) {   
  68. //这个函数也比较关键，它用来取得buf.我们接下来会详细看这个函数   
  69.                         return NGX_ERROR;   
  70.                     }   
  71.                 }   
  72.             }   
  73. ............................................................   
  74.     }  


上面的代码分析的时候有个很关键的函数，那就是ngx_output_chain_get_buf,这个函数是当没有可重用的buf的时候，用来分配buf的。

这里只有一个要注意的，那就是如果当前的buf是位于最后一个chain的话，会有特殊处理。这里特殊处理有两个地方，一个是buf的recycled域，一个是将要分配的buf的大小。

先来说recycled域，这个域表示我们当前的buf是需要被回收的。而我们知道nginx一般情况下(比如非last buf)是会缓存一部分buf，然后再发送的(默认是1460字节)，而设置了recycled的话，我们就不会让它缓存buf，也就是尽量发送出去，然后以供我们回收使用。

因此如果是最后一个buf的话，一般来说我们是不需要设置recycled域的，否则的话，需要设置recycled域。因为不是最后一个buf的话，我们可能还会需要重用一些buf，而buf只有被发送出去的话，我们才能重用。

然后就是size的大小。这里会有两个大小，一个是我们需要复制的buf的大小，一个是nginx.conf中设置的size。如果不是最后一个buf，则我们只需要分配我们设置的buf的size大小就行了。如果是最后一个buf，则就处理不太一样，下面的代码会看到。

Java代码  
  1. static ngx_int_t   
  2. ngx_output_chain_get_buf(ngx_output_chain_ctx_t *ctx, off_t bsize)   
  3. {   
  4.     size_t       size;   
  5.     ngx_buf_t   *b, *in;   
  6.     ngx_uint_t   recycled;   
  7.   
  8.     in = ctx->in->buf;   
  9. //可以看到这里分配的buf，每个的大小都是我们在nginx.conf中设置的size   
  10.     size = ctx->bufs.size;   
  11. //默认有设置recycled域.   
  12.     recycled = 1;   
  13. //如果当前的buf是属于最后一个chain的时候。这里我们要特殊处理。   
  14.     if (in->last_in_chain) {   
  15. //这边注释很详细，我就不解释了.   
  16.         if (bsize < (off_t) size) {   
  17.   
  18.             /*  
  19.              * allocate a small temp buf for a small last buf  
  20.              * or its small last part  
  21.              */  
  22.             size = (size_t) bsize;   
  23.             recycled = 0;   
  24.   
  25.         } else if (!ctx->directio   
  26.                    && ctx->bufs.num == 1  
  27.                    && (bsize < (off_t) (size + size / 4)))   
  28.         {   
  29.             /*  
  30.              * allocate a temp buf that equals to a last buf,  
  31.              * if there is no directio, the last buf size is lesser  
  32.              * than 1.25 of bufs.size and the temp buf is single  
  33.              */  
  34.   
  35.             size = (size_t) bsize;   
  36.             recycled = 0;   
  37.         }   
  38.     }   
  39. //开始分配buf内存.   
  40.     b = ngx_calloc_buf(ctx->pool);   
  41.     if (b == NULL) {   
  42.         return NGX_ERROR;   
  43.     }   
  44.   
  45.     if (ctx->directio) {   
  46. //directio需要对齐   
  47.   
  48.         b->start = ngx_pmemalign(ctx->pool, size, NGX_DIRECTIO_BLOCK);   
  49.         if (b->start == NULL) {   
  50.             return NGX_ERROR;   
  51.         }   
  52.   
  53.     } else {   
  54. //大部分情况会走到这里.   
  55.         b->start = ngx_palloc(ctx->pool, size);   
  56.         if (b->start == NULL) {   
  57.             return NGX_ERROR;   
  58.         }   
  59.     }   
  60.   
  61.     b->pos = b->start;   
  62.     b->last = b->start;   
  63.     b->end = b->last + size;   
  64. //设置temporary.   
  65.     b->temporary = 1;   
  66.     b->tag = ctx->tag;   
  67.     b->recycled = recycled;   
  68.   
  69.     ctx->buf = b;   
  70. //更新allocated,可以看到每分配一个就加1.   
  71.     ctx->allocated++;   
  72.   
  73.     return NGX_OK;   
  74. }  


然后接下来这部分就是复制buf，然后调用filter链进行发送。

Java代码  
  1. //复制buf.   
  2. rc = ngx_output_chain_copy_buf(ctx);   
  3.   
  4.             if (rc == NGX_ERROR) {   
  5.                 return rc;   
  6.             }   
  7. //如果返回AGAIn，一般来说不会返回这个值的.   
  8.             if (rc == NGX_AGAIN) {   
  9.                 if (out) {   
  10.                     break;   
  11.                 }   
  12.   
  13.                 return rc;   
  14.             }   
  15.   
  16.             /* delete the completed buf from the ctx->in chain */  
  17. //如果ctx->in中处理完毕的buf则删除当前的buf   
  18.             if (ngx_buf_size(ctx->in->buf) == 0) {   
  19.                 ctx->in = ctx->in->next;   
  20.             }   
  21.   
  22.             cl = ngx_alloc_chain_link(ctx->pool);   
  23.             if (cl == NULL) {   
  24.                 return NGX_ERROR;   
  25.             }   
  26. //链接chain到out.   
  27.             cl->buf = ctx->buf;   
  28.             cl->next = NULL;   
  29.             *last_out = cl;   
  30.             last_out = &cl->next;   
  31.             ctx->buf = NULL;   
  32.         }   
  33.   
  34.         if (out == NULL && last != NGX_NONE) {   
  35.   
  36.             if (ctx->in) {   
  37.                 return NGX_AGAIN;   
  38.             }   
  39.   
  40.             return last;   
  41.         }   
  42. //调用filter链   
  43.         last = ctx->output_filter(ctx->filter_ctx, out);   
  44.   
  45.         if (last == NGX_ERROR || last == NGX_DONE) {   
  46.             return last;   
  47.         }   
  48. //update chain，这里主要是将处理完毕的chain放入到free，没有处理完毕的放到busy中.   
  49.         ngx_chain_update_chains(&ctx->free, &ctx->busy, &out, ctx->tag);   
  50.         last_out = &out;  


ngx_chain_update_chains这个函数我以前的blog有分析过，想了解的，可以看我前面的blog 
 
        
 
       
 
      
 
     
 
    
 
   
 
  
 
 
 


                            

                        

                    

                    
                    

                    
                    
                    

                

                

                    
                

            

        

    

    

        
你可能感兴趣的:(nginx的filter的处理)

        

            

                
    
                    
  • 斤斤计较的婚姻到底有多难？
                        白心之岂必有为

                        
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
    
                    
    • 
                    
  • 情绪觉察日记第37天
                        露露_e800

                        
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
    
                    
    • 
                    
  • 芦花鞋一四
                        许叶晗

                        
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
    
                    
    • 
                    
  • QQ群采集助手，精准引流必备神器
                        2401_87347160
其他经验分享
                        
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
    
                    
    • 
                    
  • 关于沟通这件事，项目经理不需要每次都面对面进行
                        流程大师兄

                        
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
    
                    
    • 
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • 铭刻于星（四十二）
                        随风至

                        
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
    
                    
    • 
                    
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说
                        造命者说

                        
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
    
                    
    • 
                    
  • 2020-01-25
                        晴岚85

                        
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
    
                    
    • 
                    
  • 随笔 | 仙一般的灵气
                        海思沧海

                        
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
    
                    
    • 
                    
  • 想家
                        爆米花机

                        
    也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
    
                    
    • 
                    
  • 【iOS】MVC设计模式
                        Magnetic_h
iosmvc设计模式objective-c学习ui
                        
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
    
                    
    • 
                    
  • OC语言多界面传值五大方式
                        Magnetic_h
iosui学习objective-c开发语言
                        
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
    
                    
    • 
                    
  • 一百九十四章. 自相矛盾
                        巨木擎天

                        
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
    
                    
    • 
                    
  • UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
    
                    
    • 
                    
  • element实现动态路由+面包屑
                        软件技术NINI
vue案例vue.js前端
                        
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
    
                    
    • 
                    
  • 10月|愿你的青春不负梦想-读书笔记-01
                        Tracy的小书斋

                        
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
    
                    
    • 
                    
  • C语言宏函数
                        南林yan
C语言c语言
                        
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
                    
    • 
                    
  • 地推话术，如何应对地推过程中家长的拒绝
                        校师学

                        
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
    
                    
    • 
                    
  • 谢谢你们，爱你们！
                        鹿游儿

                        
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
    
                    
    • 
                    
  • C语言如何定义宏函数？
                        小九格物
c语言
                        
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
    
                    
    • 
                    
  • 微服务下功能权限与数据权限的设计与实现
                        nbsaas-boot
微服务java架构
                        
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    
                    
    • 
                    
  • 理解Gunicorn：Python WSGI服务器的基石
                        范范0825
ipythonlinux运维
                        
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
    
                    
    • 
                    
  • 小丽成长记（四十三）
                        玲玲54321

                        
    小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
    
                    
    • 
                    
  • 学点心理知识，呵护孩子健康
                        静候花开_7090

                        
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
    
                    
    • 
                    
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹
                        黄错错加油

                        
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
    
                    
    • 
                    
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断
                        尐尐呅

                        
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
    
                    
    • 
                    
  • c++ 的iostream 和 c++的stdio的区别和联系
                        黄卷青灯77
c++算法开发语言iostreamstdio
                        
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
    
                    
    • 
                    
  • 瑶池防线
                        谜影梦蝶

                        
    冥华虽然逃过了影梦的军队，但他是一个忠臣，他选择上报战况。败给影梦后成逃兵，高层亡尔还活着，七重天失守......随便一条，即可处死冥华。冥华自然是知道以仙界高层的习性此信一发自己必死无疑，但他还选择上报实情，因为责任。同样此信送到仙宫后，知道此事的人，大多数人都认定冥华要完了，所以上到仙界高层，下到扫大街的，包括冥华自己，全都准备好迎接冥华之死。如果仙界现在还属于两方之争的话，冥华必死无疑。然而
    
                    
    • 
                    
  • 爬山后遗症
                        璃绛

                        
    爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
    
                    
    • 
                                
  • 分享100个最新免费的高匿HTTP代理IP
                                    mcj8089
代理IP代理服务器匿名代理免费代理IP最新代理IP
                                    
      
推荐两个代理IP网站： 
  
1. 全网代理IP：http://proxy.goubanjia.com/ 
  
2. 敲代码免费IP：http://ip.qiaodm.com/ 
  
  
120.198.243.130:80,中国/广东省
58.251.78.71:8088,中国/广东省
183.207.228.22:83,中国/
    
                                
    • 
                                
  • mysql高级特性之数据分区
                                    annan211
java数据结构mongodb分区mysql
                                    
    


mysql高级特性
  1 以存储引擎的角度分析，分区表和物理表没有区别。是按照一定的规则将数据分别存储的逻辑设计。器底层是由多个物理字表组成。
  
  2 分区的原理
     分区表由多个相关的底层表实现，这些底层表也是由句柄对象表示，所以我们可以直接访问各个分区。存储引擎管理分区的各个底层
	 表和管理普通表一样(所有底层表都必须使用相同的存储引擎)，分区表的索引只是
    
                                
    • 
                                
  • JS采用正则表达式简单获取URL地址栏参数
                                    chiangfai
js地址栏参数获取
                                    
    GetUrlParam:function GetUrlParam(param){
		var reg = new RegExp("(^|&)"+ param +"=([^&]*)(&|$)");
		var r = window.location.search.substr(1).match(reg);
		if(r!=null
    
                                
    • 
                                
  • 怎样将数据表拷贝到powerdesigner (本地数据库表)
                                    Array_06
powerDesigner
                                    
    ================================================== 
 
1、打开PowerDesigner12，在菜单中按照如下方式进行操作 
file->Reverse Engineer->DataBase 
点击后，弹出 New Physical Data Model 的对话框 
2、在General选项卡中 
Model name:模板名字，自
    
                                
    • 
                                
  • logbackのhelloworld
                                    飞翔的马甲
日志logback
                                    
    一、概述 
 
1.日志是啥？ 
当我是个逗比的时候我是这么理解的：log.debug()代替了system.out.print(); 
当我项目工作时，以为是一堆得.log文件。 
这两天项目发布新版本，比较轻松，决定好好地研究下日志以及logback。 
传送门1：日志的作用与方法： 
http://www.infoq.com/cn/articles/why-and-how-log 
上面的作
    
                                
    • 
                                
  • 新浪微博爬虫模拟登陆
                                    随意而生
新浪微博
                                    
    转载自：http://hi.baidu.com/erliang20088/item/251db4b040b8ce58ba0e1235 
  
  
近来由于毕设需要，重新修改了新浪微博爬虫废了不少劲，希望下边的总结能够帮助后来的同学们。 
     现行版的模拟登陆与以前相比，最大的改动在于cookie获取时候的模拟url的请求
    
                                
    • 
                                
  • synchronized
                                    香水浓
javathread
                                    
        Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍然
    
                                
    • 
                                
  • maven 简单实用教程
                                    AdyZhang
maven
                                    
    1. Maven介绍  1.1. 简介 java编写的用于构建系统的自动化工具。目前版本是2.0.9，注意maven2和maven1有很大区别，阅读第三方文档时需要区分版本。 1.2. Maven资源 见官方网站；The 5 minute test，官方简易入门文档；Getting Started Tutorial，官方入门文档；Build Coo
    
                                
    • 
                                
  • Android 通过 intent传值获得null
                                    aijuans
android
                                    
    我在通过intent 获得传递兑现过的时候报错，空指针,我是getMap方法进行传值，代码如下        1   2   3   4   5   6   7   8   9      
public 
void 
getMap(View view){       
         
Intent i =
    
                                
    • 
                                
  • apache 做代理 报如下错误：The proxy server received an invalid response from an upstream
                                    baalwolf
response
                                    
    网站配置是apache＋tomcat,tomcat没有报错，apache报错是： 
The proxy server received an invalid response from an upstream server. The proxy server could not handle the request GET /. Reason: Error reading fr
    
                                
    • 
                                
  • Tomcat6 内存和线程配置
                                    BigBird2012
tomcat6
                                    
    1、修改启动时内存参数、并指定JVM时区 （在windows server 2008 下时间少了8个小时） 
在Tomcat上运行j2ee项目代码时，经常会出现内存溢出的情况，解决办法是在系统参数中增加系统参数：  
window下， 在catalina.bat最前面 
  set JAVA_OPTS=-XX:PermSize=64M -XX:MaxPermSize=128m -Xms5
    
                                
    • 
                                
  • Karam与TDD
                                    bijian1013
KaramTDD
                                    
    一.TDD 
        测试驱动开发（Test-Driven Development,TDD）是一种敏捷（AGILE）开发方法论，它把开发流程倒转了过来，在进行代码实现之前，首先保证编写测试用例，从而用测试来驱动开发（而不是把测试作为一项验证工具来使用）。 
        TDD的原则很简单： 
a.只有当某个
    
                                
    • 
                                
  • [Zookeeper学习笔记之七]Zookeeper源代码分析之Zookeeper.States
                                    bit1129
zookeeper
                                    
        public enum States {
        CONNECTING, //Zookeeper服务器不可用，客户端处于尝试链接状态
        ASSOCIATING, //？？？
        CONNECTED, //链接建立，可以与Zookeeper服务器正常通信
        CONNECTEDREADONLY, //处于只读状态的链接状态，只读模式可以在
    
                                
    • 
                                
  • 【Scala十四】Scala核心八：闭包
                                    bit1129
scala
                                    
    Free variable A free variable of an expression is a variable that’s used inside the expression but not defined inside the expression. For instance, in the function literal expression (x: Int) => (x
    
                                
    • 
                                
  • android发送json并解析返回json
                                    ronin47
android
                                    
    package com.http.test; 
 
 
import org.apache.http.HttpResponse; 
import org.apache.http.HttpStatus; 
import org.apache.http.client.HttpClient; 
import org.apache.http.client.methods.HttpGet; 
import 
    
                                
    • 
                                
  • 一份IT实习生的总结
                                    brotherlamp
PHPphp资料php教程php培训php视频
                                    
    今天突然发现在不知不觉中自己已经实习了 3 个月了，现在可能不算是真正意义上的实习吧，因为现在自己才大三，在这边撸代码的同时还要考虑到学校的功课跟期末考试。让我震惊的是，我完全想不到在这 3 个月里我到底学到了什么，这是一件多么悲催的事情啊。同时我对我应该 get 到什么新技能也很迷茫。所以今晚还是总结下把，让自己在接下来的实习生活有更加明确的方向。最后感谢工作室给我们几个人这个机会让我们提前出来
    
                                
    • 
                                
  • 据说是2012年10月人人网校招的一道笔试题-给出一个重物重量为X,另外提供的小砝码重量分别为1，3，9。。。3^N。 将重物放到天平左侧，问在两边如何添加砝码
                                    bylijinnan
java
                                    
    
public class ScalesBalance {

	/**
	 * 题目：
	 * 给出一个重物重量为X,另外提供的小砝码重量分别为1，3，9。。。3^N。 （假设N无限大，但一种重量的砝码只有一个）
	 * 将重物放到天平左侧，问在两边如何添加砝码使两边平衡
	 * 
	 * 分析：
	 * 三进制
	 * 我们约定括号表示里面的数是三进制，例如 47=(1202
    
                                
    • 
                                
  • dom4j最常用最简单的方法
                                    chiangfai
dom4j
                                    
    要使用dom4j读写XML文档,需要先下载dom4j包,dom4j官方网站在 http://www.dom4j.org/目前最新dom4j包下载地址:http://nchc.dl.sourceforge.net/sourceforge/dom4j/dom4j-1.6.1.zip 
解开后有两个包,仅操作XML文档的话把dom4j-1.6.1.jar加入工程就可以了,如果需要使用XPath的话还需要
    
                                
    • 
                                
  • 简单HBase笔记
                                    chenchao051
hbase
                                    
     一、Client-side write buffer 客户端缓存请求   描述：可以缓存客户端的请求，以此来减少RPC的次数，但是缓存只是被存在一个ArrayList中，所以多线程访问时不安全的。   可以使用getWriteBuffer()方法来取得客户端缓存中的数据。 默认关闭。      二、Scan的Caching   描述： next( )方法请求一行就要使用一次RPC,即使
    
                                
    • 
                                
  • mysqldump导出时出现when doing LOCK TABLES
                                    daizj
mysqlmysqdump导数据
                                    
    　　执行　mysqldump -uxxx -pxxx -hxxx -Pxxxx database tablename > tablename.sql　 
导出表时，会报 
 
mysqldump: Got error: 1044: Access denied for user 'xxx'@'xxx' to database 'xxx' when doing LOCK TABLES 
 
解决
    
                                
    • 
                                
  • CSS渲染原理
                                    dcj3sjt126com
Web
                                    
       从事Web前端开发的人都与CSS打交道很多，有的人也许不知道css是怎么去工作的，写出来的css浏览器是怎么样去解析的呢？当这个成为我们提高css水平的一个瓶颈时，是否应该多了解一下呢？   
  
       一、浏览器的发展与CSS      
  
   
    
                                
    • 
                                
  • 《阿甘正传》台词
                                    dcj3sjt126com

                                    
    Part Ⅰ: 
《阿甘正传》Forrest Gump经典中英文对白 
Forrest: Hello! My names Forrest. Forrest Gump. You wanna Chocolate? I could eat about a million and a half othese. My momma always said life was like a box ochocol
    
                                
    • 
                                
  • Java处理JSON
                                    dyy_gusi
json
                                    
    Json在数据传输中很好用，原因是JSON 比 XML 更小、更快，更易解析。 
在Java程序中，如何使用处理JSON，现在有很多工具可以处理，比较流行常用的是google的gson和alibaba的fastjson，具体使用如下： 
1、读取json然后处理 
class ReadJSON
{
    public static void main(String[] args)
    
    
                                
    • 
                                
  • win7下nginx和php的配置
                                    geeksun
nginx
                                    
    1.  安装包准备 
nginx :  从nginx.org下载nginx-1.8.0.zip 
php： 从php.net下载php-5.6.10-Win32-VC11-x64.zip， php是免安装文件。 
RunHiddenConsole: 用于隐藏命令行窗口 
  
2. 配置 
# java用8080端口做应用服务器，nginx反向代理到这个端口即可 
p
    
                                
    • 
                                
  • 基于2.8版本redis配置文件中文解释
                                    hongtoushizi
redis
                                    
    转载自： http://wangwei007.blog.51cto.com/68019/1548167 
       在Redis中直接启动redis-server服务时, 采用的是默认的配置文件。采用redis-server   xxx.conf 这样的方式可以按照指定的配置文件来运行Redis服务。下面是Redis2.8.9的配置文
    
                                
    • 
                                
  • 第五章 常用Lua开发库3-模板渲染
                                    jinnianshilongnian
nginxlua
                                    
    动态web网页开发是Web开发中一个常见的场景，比如像京东商品详情页，其页面逻辑是非常复杂的，需要使用模板技术来实现。而Lua中也有许多模板引擎，如目前我在使用的lua-resty-template，可以渲染很复杂的页面，借助LuaJIT其性能也是可以接受的。 
  
如果学习过JavaEE中的servlet和JSP的话，应该知道JSP模板最终会被翻译成Servlet来执行；而lua-r
    
                                
    • 
                                
  • JZSearch大数据搜索引擎
                                    颠覆者
JavaScript
                                    
    系统简介： 
 
 大数据的特点有四个层面：第一，数据体量巨大。从TB级别，跃升到PB级别；第二，数据类型繁多。网络日志、视频、图片、地理位置信息等等。第三，价值密度低。以视频为例，连续不间断监控过程中，可能有用的数据仅仅有一两秒。第四，处理速度快。最后这一点也是和传统的数据挖掘技术有着本质的不同。业界将其归纳为4个“V”——Volume，Variety，Value，Velocity。大数据搜索引
    
                                
    • 
                                
  • 10招让你成为杰出的Java程序员
                                    pda158
java编程框架
                                    
    如果你是一个热衷于技术的  
Java 程序员， 那么下面的 10 个要点可以让你在众多 Java 开发人员中脱颖而出。   　　 
1. 拥有扎实的基础和深刻理解 OO 原则   　　对于 Java 程序员，深刻理解 Object Oriented Programming（面向对象编程）这一概念是必须的。没有 OOPS 的坚实基础，就领会不了像 Java 这些面向对象编程语言
    
                                
    • 
                                
  • tomcat之oracle连接池配置
                                    小网客
oracle
                                    
    tomcat版本7.0 
配置oracle连接池方式： 
修改tomcat的server.xml配置文件： 
 <GlobalNamingResources>
 
			  <Resource name="utermdatasource" auth="Container"  
 type="javax.sql.DataSou
    
                                
    • 
                                
  • Oracle 分页算法汇总
                                    vipbooks
oraclesql算法.net
                                    
        这是我找到的一些关于Oracle分页的算法，大家那里还有没有其他好的算法没？我们大家一起分享一下！ 
 
 

-- Oracle 分页算法一
select * from (
       select page.*,rownum rn from (select * from help) page 
       -- 20 = (currentPag
    
                                
    • 
                

            

        

    




    

        

            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他