nutch系统是如何加载和管理URLFilter插件的

    根据Injector中的URLFilter插件加载为例进行分析。

    （1）首先在Crawl中创建了一个Configration实例，并将它传递给了Injector

    （2）Injector的构造函数中，根据该配置信息类JobConf调用URLFilter获得所有的url过滤插件：filters = new URLFilters(jobConf);

    （3）在URLFilter中，代码如下：

 

  public URLFilters(Configuration conf) {
    String order = conf.get(URLFILTER_ORDER);
    ObjectCache objectCache = ObjectCache.get(conf);//首先他要到缓存中查看是否存在对应该配置类conf的缓存，因为现在是第一次对该conf进行调用，所以没有缓存，所以ObjectCache会创建一个空的ObjectCache实例返回。                                                   

    this.filters = (URLFilter[]) objectCache.getObject(URLFilter.class.getName());//因为第一次调用没有缓存任何内容，所以该步返回结果为null

    if (this.filters == null) {//当没有从缓存中获得结果时，执行下面代码加载对应该配置类conf的配置信息，并进行缓存

      String[] orderedFilters = null;
      if (order != null && !order.trim().equals("")) {//该部分为配置文件nutch-default.xml属性urlfilter.order中规定的过滤类，程序配置文件中该部分值为空，所以没有加载

        orderedFilters = order.split("\\s+");
//        System.out.println("order != null && !order.trim().equals(\"\")运行到了这里");
      }
//      System.err.println("inside the if");

      try {
        ExtensionPoint point = PluginRepository.get(conf).getExtensionPoint(
            URLFilter.X_POINT_ID);//通过插件仓库类PluginRepository，获得对应 URLFilter.X_POINT_ID 的扩展点，该仓库类具体如何加载管理插件将在下一步中进行介绍。

        if (point == null)
          throw new RuntimeException(URLFilter.X_POINT_ID + " not found.");
        Extension[] extensions = point.getExtensions();//获得url过滤插件扩展点对应的扩展

        Map<String, URLFilter> filterMap = new HashMap<String, URLFilter>();
        for (int i = 0; i < extensions.length; i++) {
          Extension extension = extensions[i];
//          System.out.println("url过滤的扩展类为："+extension.getClazz());
          URLFilter filter = (URLFilter) extension.getExtensionInstance();//实例化扩展
          if (!filterMap.containsKey(filter.getClass().getName())) {
            filterMap.put(filter.getClass().getName(), filter);
          }
        }
        if (orderedFilters == null) {
          objectCache.setObject(URLFilter.class.getName(), filterMap.values().toArray(
              new URLFilter[0]));//将插件进行缓存

        } else {
          ArrayList<URLFilter> filters = new ArrayList<URLFilter>();
          for (int i = 0; i < orderedFilters.length; i++) {
            URLFilter filter = filterMap.get(orderedFilters[i]);
            if (filter != null) {
              filters.add(filter);
            }
          }
          objectCache.setObject(URLFilter.class.getName(), filters
              .toArray(new URLFilter[filters.size()]));
        }
      } catch (PluginRuntimeException e) {
        throw new RuntimeException(e);
      }
      this.filters = (URLFilter[]) objectCache.getObject(URLFilter.class.getName());
    }
  }

    URLFilter类具体工作就是，先从ObjectCache缓存中查找对应conf的url过滤类，如果没有被缓存，则程序调用插件仓库管理类PluginRepository获得url过滤类的扩展点，然后通过扩展点获得扩展，对扩展利用java的反射机制获得该扩展的实例，最后对获得的扩展实例缓存到ObjectCache中。

    （4）插件仓库类PluginRepository工作过程介绍，代码和介绍如下：

      A：调用PluginRepository的程序一般通过该类的静态方法调用插件仓库类，代码如下：

  public static synchronized PluginRepository get(Configuration conf) {
    String uuid = NutchConfiguration.getUUID(conf);//获得配置类的标示信息uuid
    if (uuid == null) {
      uuid = "nonNutchConf@" + conf.hashCode(); // fallback
    }
    PluginRepository result = CACHE.get(uuid);//从仓库缓存CACHE中获得对应该uuid的插件仓库类
    if (result == null) {//结果为空说明缓存中没有对应该配置类的插件仓库类
      result = new PluginRepository(conf);//创建对应该配置类的插件仓库类
      CACHE.put(uuid, result);//对该仓库类进行缓存
    }
    return result;//返回结果
  }

    每个配置信息类conf对应一个插件仓库类，如果需要会被缓存到CACHE中，如果CACHE中没有对该conf的插件仓库类进行缓存，在程序会创建对应该conf的插件仓库类，然后进行缓存。插件仓库类具体如何加载和管理插件，要看他的构造函数如下：

    B：插件仓库类的构造函数代码如下，他包含了如何对插件进行管理：

 

  public PluginRepository(Configuration conf) throws RuntimeException {
    fActivatedPlugins = new HashMap<String, Plugin>();
    fExtensionPoints = new HashMap<String, ExtensionPoint>();//存储扩展点
    this.conf = conf;
    this.auto = conf.getBoolean("plugin.auto-activation", true);
    String[] pluginFolders = conf.getStrings("plugin.folders");//获得插件包的路径
    PluginManifestParser manifestParser = new PluginManifestParser(conf, this);//创建插件包加载分析类
    Map<String, PluginDescriptor> allPlugins = manifestParser
        .parsePluginFolder(pluginFolders);//分析插件包，他会分析所有插件包，然后获得插件包中所有的扩展点和扩展，以及他们的依赖包等信息
    Pattern excludes = Pattern.compile(conf.get("plugin.excludes", ""));//过滤条件
    Pattern includes = Pattern.compile(conf.get("plugin.includes", ""));//包含条件
    Map<String, PluginDescriptor> filteredPlugins = filter(excludes, includes,
        allPlugins);//根据上面两个条件对，解析到的插件包进行过滤
    fRegisteredPlugins = getDependencyCheckedPlugins(filteredPlugins,
        this.auto ? allPlugins : filteredPlugins);
    installExtensionPoints(fRegisteredPlugins);//获得所有插件包中的扩展点，存储到fExtensionPoints中
    try {
      installExtensions(fRegisteredPlugins);//将所有的扩展，根据扩展关系，存储到相应的扩展点下（扩展点管理自己的扩展）
    } catch (PluginRuntimeException e) {
        LOG.error(e.toString());
      throw new RuntimeException(e.getMessage());
    }
    displayStatus();
  }

    （5）通过以上四步就实现了所有插件的加载，现在所有插件的信息都在缓存中，下次想调用对应该conf的插件就可以从缓存中直接获得。