• Apache Nutch 1.3 学习笔记十（插件机制分析）

    1. 一些对象说明 

    1. PluginRepository:这是一个用于存储所有插件描述对象(PluginDescriptor)，插件扩展点(ExtensionPoint)和被激活的插件。
    2. PluginDescriptor:用于描述单个扩展插件的元信息，它的内容主要是从plugin.xml中得到。
    3. Plugin: 用于描述插件的一个抽象，其中包括了一个插件描述符，它们是一对一的关系。
    4. ExtensionPoint: 这个扩展点主要是一个面象对象中的接口的意思，就是说可以有多个扩展来实现这个接口，一个或者多个扩展点实际上就是一个插件，如nutch-extensionpoints.
    5. Extension: 扩展是对于扩展点的实现，一个插件可以包含多个扩展。
    6. PluginManifestParser: 主要是用于解析插件目录下的plugin.xml文件，生成相应的PluginDescriptor对象。
    7. PluginClassLoader: 它继承自URLClassLoader，用来根据urls动态生成相应的插件实现对象

    2. 插件仓库初始化流程

    PluginRepository的生成有两种方法，一个是直接new一个相应的对象，另一个是调用PluginRepository的静态的get方法，从Cache中得到相应的PluginRepository，在Nutch的流程中，一般是通用使用第二种方法来得到PluginRepository，这样可以保证资源在多个流程中得到共享。

    2.1 PluginRepostory的初始化在其ctr函数中进行

    源代码如下：

     

    1. fActivatedPlugins = new HashMap<String, Plugin>();  
    2.         fExtensionPoints = new HashMap<String, ExtensionPoint>();  
    3.         this.conf = conf;  
    4.         // 当被配置为过滤（即不加载），但是又被其他插件依赖的时候，是否自动启动，缺省为 true  
    5.         this.auto = conf.getBoolean("plugin.auto-activation", true);  
    6.         // 插件的目录名，可以是多个目录  
    7.         String[] pluginFolders = conf.getStrings("plugin.folders");  
    8.         PluginManifestParser manifestParser = new PluginManifestParser(conf, this);  
    9.         Map<String, PluginDescriptor> allPlugins = manifestParser.parsePluginFolder(pluginFolders);  
    10.         // 要排除的插件名称列表，支持正则表达式方式定义  
    11.         Pattern excludes = Pattern.compile(conf.get("plugin.excludes", ""));  
    12.         // 要包含的插件名称列表，支持正则表达式方式定义  
    13.         Pattern includes = Pattern.compile(conf.get("plugin.includes", ""));  
    14.         // 对不使用的插件进行过滤，返回过滤后的插件  
    15.         Map<String, PluginDescriptor> filterfilteredPlugins = filter(excludes, includes,allPlugins);  
    16.         // 对插件的依赖关系进行检查  
    17.         fRegisteredPlugins = getDependencyCheckedPlugins(filteredPlugins,this.auto ? allPlugins : filteredPlugins);  
    18.         // 安装扩展点，主要是针对nutch-extensionpoints这个插件的  
    19.         installExtensionPoints(fRegisteredPlugins);  
    20.         try {  
    21.             // 安装特定扩展点的相应扩展集  
    22.             // NOTE：其实这边的扩展点与扩展都是以插件的形式表现的  
    23.             installExtensions(fRegisteredPlugins);  
    24.         } catch (PluginRuntimeException e) {  
    25.             LOG.fatal(e.toString());  
    26.             throw new RuntimeException(e.getMessage());  
    27.         }  
    28.         displayStatus();  

       2.2 下面分析一个插件描述符的生成

    插件描述符的生成主要是通用调用PluginManifestParser这个对象的parsePluginFolder这个方法生成的，源代码如下：

     

    1. /**  
    2.               * Returns a list of all found plugin descriptors.  
    3.               *   
    4.               * @param pluginFolders  
    5.               *          folders to search plugins from  
    6.               * @return A {@link Map} of all found {@link PluginDescriptor}s.  
    7.               */  
    8.             public Map<String, PluginDescriptor> parsePluginFolder(String[] pluginFolders) {  
    9.         Map<String, PluginDescriptor> map = new HashMap<String, PluginDescriptor>();  
    10.     
    11.     
    12.         if (pluginFolders == null) {  
    13.                 throw new IllegalArgumentException("plugin.folders is not defined");  
    14.         }  
    15.     
    16.     
    17.         for (String name : pluginFolders) {  
    18.             // 遍历所有插件目录,这里的getPluginFolder方法解析一个资源的相对路径的问题  
    19.                 File directory = getPluginFolder(name);  
    20.                 if (directory == null) {  
    21.                 continue;  
    22.                 }  
    23.          
    24.             LOG.info("Plugins: looking in: " + directory.getAbsolutePath());  
    25.         // 遍历所有子插件目录中的插件  
    26.             for (File oneSubFolder : directory.listFiles()) {  
    27.             if (oneSubFolder.isDirectory()) {  
    28.                     String manifestPath = oneSubFolder.getAbsolutePath() + File.separator  
    29.                     + "plugin.xml";  
    30.                 try {  
    31.             LOG.debug("parsing: " + manifestPath);  
    32.             // 分析plugin.xml文件  
    33.             PluginDescriptor p = parseManifestFile(manifestPath);  
    34.             map.put(p.getPluginId(), p);  
    35.                 } catch (MalformedURLException e) {  
    36.             LOG.warn(e.toString());  
    37.             } catch (SAXException e) {  
    38.            LOG.warn(e.toString());  
    39.             } catch (IOException e) {  
    40.            LOG.warn(e.toString());  
    41.             } catch (ParserConfigurationException e) {  
    42.            LOG.warn(e.toString());  
    43.             }  
    44.         }  
    45.         }  
    46.     }  
    47.     return map;  
    48.     }  

     

    1. private PluginDescriptor parseManifestFile(String pManifestPath)  
    2.         throws MalformedURLException, SAXException, IOException,  
    3.         ParserConfigurationException {  
    4.     // 解析xml文件，生成Document对象  
    5.         Document document = parseXML(new File(pManifestPath).toURL());  
    6.         String pPath = new File(pManifestPath).getParent();  
    7. // 对xml进行分析  
    8.         return parsePlugin(document, pPath);  
    9.     }  

     

    1. private PluginDescriptor parsePlugin(Document pDocument, String pPath)  
    2.             throws MalformedURLException {  
    3.    Element rootElement = pDocument.getDocumentElement();  
    4. // 这里是解析xml中的如下信息  
    5. // <plugin id="index-anchor" name="Anchor Indexing Filter" version="1.0.0" provider-name="nutch.org">  
    6.    String id = rootElement.getAttribute(ATTR_ID);  
    7.    String name = rootElement.getAttribute(ATTR_NAME);  
    8.    String version = rootElement.getAttribute("version");  
    9.    String providerName = rootElement.getAttribute("provider-name");  
    10. // 插件类属性，不过这里好像没有用到过  
    11.    String pluginClazz = null;  
    12.    if (rootElement.getAttribute(ATTR_CLASS).trim().length() > 0) {  
    13.      pluginClazz = rootElement.getAttribute(ATTR_CLASS);  
    14.    }  
    15. // 生成插件描述符对象  
    16.    PluginDescriptor pluginDescriptor = new PluginDescriptor(id, version, name,  
    17.        providerName, pluginClazz, pPath, this.conf);  
    18.    LOG.debug("plugin: id=" + id + " name=" + name + " version=" + version  
    19.          + " provider=" + providerName + "class=" + pluginClazz);  
    20. // 这里是解析如下内容  
    21. //  <extension id="org.apache.nutch.indexer.anchor" name="Nutch Anchor Indexing Filter" point="org.apache.nutch.indexer.IndexingFilter">  
    22.    //   <implementation id="AnchorIndexingFilter"  
    23.    //       class="org.apache.nutch.indexer.anchor.AnchorIndexingFilter" />  
    24.     //  </extension>  
    25.    parseExtension(rootElement, pluginDescriptor);  
    26. // 这里主要是解析nutch-extensionPoints这个插件,xml内容如下  
    27. // <extension-point id="org.apache.nutch.indexer.IndexingFilter" name="Nutch Indexing Filter"/>  
    28.    // <extension-point id="org.apache.nutch.parse.Parser" name="Nutch Content Parser"/>  
    29.    // <extension-point id="org.apache.nutch.parse.HtmlParseFilter" name="HTML Parse Filter"/>  
    30.    parseExtensionPoints(rootElement, pluginDescriptor);  
    31. // 这里主要是解析插件的动态库与插件所使用的第三方库，xml内容如下  
    32. // <runtime>  
    33.    //  <library name="parse-tika.jar">  
    34.    //     <export name="*"/>  
    35.    //  </library>  
    36.    //  <library name="apache-mime4j-0.6.jar"/>  
    37.    //  <library name="asm-3.1.jar"/>  
    38.    //  <library name="bcmail-jdk15-1.45.jar"/>  
    39.    //  <library name="bcprov-jdk15-1.45.jar"/>  
    40. //  </runtime>  
    41.    parseLibraries(rootElement, pluginDescriptor);  
    42. // 这里解析插件依赖的插件库，xml内容如下  
    43. //  <requires>  
    44.    //   <import plugin="nutch-extensionpoints"/>  
    45.    //  <import plugin="lib-regex-filter"/>  
    46.    //  </requires>  
    47.    parseRequires(rootElement, pluginDescriptor);  
    48.    return pluginDescriptor;  
    49.  }  



          要注意的是这个PluginManifestParser就是用来解析相应的plugin.xml文件，生成PluginRepository对象的，这个有一个很奇怪的概念就是一个插件描述符(PluginDescriptor)可以包含多个可扩展点或者可扩展点的实现，这里为什么不把可扩展点分离出来，PluginDescriptor就只包含一个或者多个可扩展点的实现。而可扩展点就是插件的接口定义。

    2.3     插件依赖关系的检查
    这个依赖关系的检查很有趣，主要是根据plugin.auto-activation这个参数来定的，部分源代码如下：

     

    1. /**  
    2.   * @param filtered  
    3.   *          is the list of plugin filtred  
    4.   * @param all  
    5.   *          is the list of all plugins found.  
    6.   * @return List  
    7.   */  
    8.  private List<PluginDescriptor> getDependencyCheckedPlugins(  
    9.      Map<String, PluginDescriptor> filtered, Map<String, PluginDescriptor> all) {  
    10.    if (filtered == null) {  
    11.      return null;  
    12.    }  
    13.    Map<String, PluginDescriptor> checked = new HashMap<String, PluginDescriptor>();  
    14.     
    15.     
    16. // 遍历所有过滤后的插件  
    17.    for (PluginDescriptor plugin : filtered.values()) {  
    18.      try {  
    19.       // 保存当前插件的依赖插件描述符  
    20.        checked.putAll(getPluginCheckedDependencies(plugin, all));  
    21.     // 保存当前插件描述符  
    22.        checked.put(plugin.getPluginId(), plugin);  
    23.      } catch (MissingDependencyException mde) {  
    24.        // Log exception and ignore plugin  
    25.        LOG.warn(mde.getMessage());  
    26.      } catch (CircularDependencyException cde) {  
    27.       
    28.   // Simply ignore this plugin  
    29.        LOG.warn(cde.getMessage());  
    30.      }  
    31.    }  
    32.    return new ArrayList<PluginDescriptor>(checked.values());  
    33.  }  


    3.     插件调用流程
          插件调用流程主要分成如下几步：

    1. 根据扩展点ID号从插件仓库中得到相应的扩展点对象
    2. 根据扩展点对象得到相应的扩展集
    3. 遍历扩展集，从扩展对象中实例化出相应的扩展来，实例化的过滤就是调用PluginClassLoader

      下面是生成URLFilter插件的部分代码：

     

    1.    (1)  
    2. ExtensionPoint point = PluginRepository.get(conf).getExtensionPoint(URLFilter.X_POINT_ID);  
    3. if (point == null)  
    4.   throw new RuntimeException(URLFilter.X_POINT_ID + " not found.");  
    5.    (2)  
    6. Extension[] extensions = point.getExtensions();  
    7. Map<String, URLFilter> filterMap = new HashMap<String, URLFilter>();  
    8. for (int i = 0; i < extensions.length; i++) {  
    9.   Extension extension = extensions[i];  
    10.    (3)  
    11.   URLFilter filter = (URLFilter) extension.getExtensionInstance();  
    12.   if (!filterMap.containsKey(filter.getClass().getName())) {  
    13.     filterMap.put(filter.getClass().getName(), filter);  
    14.   }  
    15. }  

    4. 总结

    Nutch的插件机制还是比较经典的，上面只是做了一个简单的分析，要深入理解还是要多实践。

    作者：http://blog.csdn.net/amuseme_lu

    相关文章阅读及免费下载：

    《Apache Nutch 1.3 学习笔记目录》

    《Apache Nutch 1.3 学习笔记一》

    《Apache Nutch 1.3 学习笔记二》

    《Apache Nutch 1.3 学习笔记三（Inject）》

    《Apache Nutch 1.3 学习笔记三（Inject CrawlDB Reader）》

    《Apache Nutch 1.3 学习笔记四（Generate）》

    《Apache Nutch 1.3 学习笔记四（SegmentReader分析）》

    《Apache Nutch 1.3 学习笔记五（FetchThread）》

    《Apache Nutch 1.3 学习笔记五（Fetcher流程）》

    《Apache Nutch 1.3 学习笔记六（ParseSegment）》

    《Apache Nutch 1.3 学习笔记七（CrawlDb - updatedb）》

    《Apache Nutch 1.3 学习笔记八（LinkDb）》

    《Apache Nutch 1.3 学习笔记九（SolrIndexer）》

    《Apache Nutch 1.3 学习笔记十（Ntuch 插件机制简单介绍）》

    《Apache Nutch 1.3 学习笔记十（插件扩展）》

    《Apache Nutch 1.3 学习笔记十（插件机制分析）》

    《Apache Nutch 1.3 学习笔记十一（页面评分机制 OPIC）》

    《Apache Nutch 1.3 学习笔记十一（页面评分机制 LinkRank 介绍）》

    《Apache Nutch 1.3 学习笔记十二（Nutch 2.0 的主要变化）》

    更多《Apache Nutch文档》，尽在开卷有益360 http://www.docin.com/book_360
  • 相关阅读:
    PAT A1060——string的常见用法详解
    题解-ZJOI2015地震后的幻想乡
    题解-富有物理组的风采
    题解-概率计算器
    题解-CodeForces835F Roads in the Kingdom
    题解-hdu2866 Special Prime
    题解-poj3682King Arthur's Birthday Celebration
    题解-拉格朗日（bzoj3695变种）
    题解-ZeroJudge-c686 高斯符號
    其他-几道物理题
  • 原文地址：https://www.cnblogs.com/ibook360/p/2222179.html
Copyright © 2020-2023  润新知