2
回答
关于Heritrix的处理器链和Processor的疑问
终于搞明白,存储TCO原来是这样算的>>>   

在ToeThread的processCrawlUri()方法中

private void processCrawlUri() throws InterruptedException { 
   
// 设定当前线程的编号 
   currentCuri.setThreadNumber(this.serialNumber); 
   
// 为当前处理的URI设定下一个ProcessorChain 
   
currentCuri.setNextProcessorChain(controller.getFirstProcessorChain()); 
    
   
// 设定开始时间 
   lastStartTime = System.currentTimeMillis(); 
   
try { 
    
      
// 如果还有一个处理链没处理完 
      while (currentCuri.nextProcessorChain() != null
      { 
         setStep(STEP_ABOUT_TO_BEGIN_CHAIN); 
          
         
// 将下个处理链中的第一个处理器设定为 
         
// 下一个处理当前链接的处理器 
         currentCuri.setNextProcessor(currentCuri 
                                      .nextProcessorChain().getFirstProcessor()
); 
         
// 将再下一个处理器链设定为当前链接的 
         
// 下一个处理器链,因为此时已经相当于 
         
// 把下一个处理器链置为当前处理器链了 
         currentCuri.setNextProcessorChain(currentCuri 
                                      .nextProcessorChain().getNextProcessorCha
in()); 
                                       
         
// 开始循环处理当前处理器链中的每一个Processor 
         while (currentCuri.nextProcessor() != null
         { 
            setStep(STEP_ABOUT_TO_BEGIN_PROCESSOR); 
            Processor currentProcessor 
= 
getProcessor(currentCuri.nextProcessor()); 
            currentProcessorName 
= currentProcessor.getName(); 
            continueCheck(); 
            
// 调用Process方法 
            currentProcessor.process(currentCuri); 
         } 
      } 
      setStep(STEP_DONE_WITH_PROCESSORS); 
      currentProcessorName 
= ""
   } 
   
catch (RuntimeExceptionWrapper e) { 
       
// 如果是Berkeley DB的异常 
       if(e.getCause() == null) { 
           e.initCause(e.getDetail()); 
       } 
       recoverableProblem(e); 
   } 
catch (AssertionError ae) { 
       recoverableProblem(ae); 
   } 
catch (RuntimeException e) { 
       recoverableProblem(e); 
   } 
catch (StackOverflowError err) { 
       recoverableProblem(err); 
   } 
catch (Error err) { 
       seriousError(err);  
   } 

代码中使用了双重循环来遍历整个处理器链的结构,第一重循环首先遍历所有的处理器链,第二重循环则在链内部遍历每个Processor,然后调用它的process()方法来执行处理逻辑。


蓝色代码里是第二重循环,它是怎么遍历每个Processor的,毕竟没有设置currentCuri.setNextProcessor()


举报
wy65
发帖于3年前 2回/186阅
顶部