文本检索系统-2B：文本处理器

问候，

介绍

欢迎回来。 是时候进行一些实际的设计了：我希望两个具有两个“事物”：

1）一个“ LibraryBuilder”，它逐渐构建处理后的文本，最后

自行构建“图书馆”。

2）一个“处理器”，用于处理输入文本并将其用勺子输入到第一个

宾语。

处理器

我希望这两个实体尽可能通用。 首先，我设计

所需的接口。 这是处理器接口：

 
public interface Processor { 
    public void process(String prefix) throws IOException; 
    public Library getLibrary();
} 

前缀字符串可以是任何字符串。 处理器知道如何处理。

前缀可以是uri或目录，也可以是到达目录所需的任何文件

原始文本。

process（）方法完成所有处理； 而且因为事情可能出错

在处理过程中，允许抛出一个IOException

可能引发的异常。 我会在何时设计其子类

需要。

第二种方法给我最终结果：库。 图书馆是普通的

可以为我检索文本的类。

我希望处理器实现尽可能通用，即我不

希望将任何特定的詹姆士国王圣经知识粘贴到我的处理器中。

Processor实现将是一个抽象类，可以完成所有

组织或“进行”的工作，并留下特定的国王詹姆斯圣经

知识到子类。 为此，它实现了抽象方法。

图书馆建设者

我对LibraryBuilder使用相同的方案：

 
public interface LibraryBuilder { 
    public void preProcess();
    public void postProcess(); 
    public void setTitle(String title); 
    public void buildGroup(String group);
    public void buildParagraph(String book, String chapter, 
                   int para, String text) throws IOException; 
    public Library build();
} 

接口无法强制执行，但目的是调用preProcess（）

方法，然后再进行其他操作。 所有处理结束并完成后

使用，应该调用postProcess（）方法。

最后，LibraryBuilder应该给我一个Library对象

当其build（）方法被调用时。

Library类本身不知道它处理哪个文本，即知道

没有关于詹姆士国王圣经的文字，也没有关于CD收藏品或其他任何东西的。

剩下的两个方法实现了文本“ spoonfeeding”：

1）buildGroup（）为调用者建立一个新的组。

2）buildParagraph（）在给定书，章，段落的情况下构建新段落

和原始段落文本。 如果需要，它可能会引发IOException。

如已经看到的，当调用Processor.getLibrary（）方法时，它

将作业委托给LibraryBuilder.build（）方法。

在这里，我也希望LibraryBuilder尽可能通用，所以我实现了

实现LibraryBuilder接口的抽象类。 这堂课

所有不需要任何有关King James知识的工作

圣经文字。

一个特殊的子类应实现抽象中定义的抽象方法

它可以粘贴其特定的詹姆士国王圣经文字的超级类。

类结构

这是顶层的类结构：

 
// interfaces:
interface Processor { ... }
interface LibraryBuilder { ... }
// implementing classes:
abstract class AbstractProcessor() implements Processor { ... }
abstract class AbstractBuilder() implements LibraryBuilder { ... } 

对于这个特定的示例项目，我必须实现两个特定的类：

 
class KJProcessor extends AbstractProcessor { ... }
class KJBuilder extends AbstractBuillder { ... } 

这两节课包含有关圣经的特定国王詹姆斯圣经知识

正在被处理，并且构建器从中构造了一个库。

抽象处理器

AbstractProcessor完成原始文本处理的所有“执行”工作

工作。 需要为实际工作将其分类。 这是其第一部分：

 
public abstract class AbstractProcessor implements Processor { 
    protected LibraryBuilder builder;
    protected String title; 
    public AbstractProcessor(String title, LibraryBuilder builder) { 
        this.builder= builder;
        this.title= title;
    }
    ... 

给定库的名称，可以构造一个AbstractProcessor，并且

LibraryBuilder。 KJProcessor为它的超类提供KBBuilder

以及标题字符串。

此类中定义的抽象方法是：

 
    ...
    protected abstract void preProcess();
    protected abstract void postProcess(); 
    protected abstract int getNofBooks();
    protected abstract String getBookTitle(String prefix, int book); 
    protected abstract Reader getBookReader(String prefix, int book) 
                throws IOException; 
    protected abstract void processBook(String title, BufferedReader br) 
                throws IOException;
    ... 

与LibraryBuilder相似，此对象在调用preProcess（）方法之前

处理开始。 处理完成后，postProcess（）方法为

调用。 KJProcessor为这两个抽象方法实现空方法

因为它不需要进行任何特殊的预处理或后期处理。

AbstractProcessor需要知道要处理多少本书，

需要每本书的标题。 这就是接下来的两种方法的用途

它们需要在AbstractProcessor类的子类中实现。

getBookReader（）方法需要返回一个可以读取的Java Reader对象。

从一本书。 最后一种方法必须处理整本书，给定读者

那本书。

最后两个方法会抛出IOException，因为任何输入/输出

相关动作可能会出错。

请注意，子类可以调用方法并读取或更改成员变量

直接在建筑商中，即两者之间的耦合紧密。

这是需要Library对象时的委托方法：

 
    ...
    public Library getLibrary() { return builder.build(); }
    ... 

另请参见上文：AbstractProcessor只需调用builder.build（）方法

为图书馆。

现在进行一些实质性的工作。 AbstractProcessor中的下一个方法

类是在Processor中定义的process（）方法的实现

接口：

 
    ...
    public void process(String prefix) throws IOException { 
        builder.preProcess();
        builder.setTitle(title); 
        this.preProcess(); 
        for (int i= 0, n= getNofBooks(); i < n; i++)
            processBook(prefix, i); 
        this.postProcess(); 
        builder.postProcess();
    }
    ... 

它在生成器和子类上调用preProcess（）方法，

将标题传递给建造者。

接下来，它确定要处理的书的数量并处理每本

通过调用processBook（）方法预订书籍（请参见下文）。

当一切都成功后，将在两者上调用postProcess（）方法。

子类和生成器。

这是processBook（）方法的实现：

 
    ...
    public void processBook(String prefix, int book) throws IOException { 
        BufferedReader br= null; 
        try {
            br= new BufferedReader(getBookReader(prefix, book));
            processBook(getBookTitle(prefix, book), br);
        }
        finally {
            try { br.close(); } catch (IOException ioe) { }
        }
    } 

此方法要求子类返回给定书籍的Reader。 它包裹

Reader周围的BufferedReader，并再次要求子类进行处理

当前的书。 最后，缓冲的读取器再次关闭，然后关闭

包装的阅读器本身。

我认为这是本周足够的设计和实现。 下礼拜

显示LibraryBuilder是如何设计和实现的。 比工作还多

此处理器实现。

之后，我将展示KJProcessor和KJBuilder类。 他们处理

nitty-gritty字符串处理工作，基本上是实现

在其父类中定义的抽象方法以及一些丑陋的方法

必须提供一致的文字（请参阅上周的文章部分）。

我将把所有代码作为附件添加到以下一些文章部分中，以便

您可以使用它，或者实际上可以以有用的方式应用它。 不是

实际阅读源代码有害。 如果您发现错误，请随时纠正我。

下周见

亲切的问候，

乔斯

From: https://bytes.com/topic/java/insights/739668-text-retrieval-systems-2b-text-processors