lucene如何抽取html网页

最新推荐文章于 2019-09-10 03:08:08 发布
最新推荐文章于 2019-09-10 03:08:08 发布
阅读量210 收藏
点赞数
分类专栏： lucene 文章标签： HTML lucene
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wzh20099/article/details/83728934
版权
要解析html页面 就要对html中的标签做处理

先准备几个工具类 
package com.cs.parser.util;


import org.htmlparser.Node;

public class PageContent {

    private StringBuffer textBuffer;
    private int number;
    private Node node;

    public Node getNode() {
		return node;
	}

	public void setNode(Node node) {
		this.node = node;
	}

	public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public StringBuffer getTextBuffer() {
        return textBuffer;
    }

    public void setTextBuffer(StringBuffer textBuffer) {
        this.textBuffer = textBuffer;
    }
}


package com.cs.parser.util;


public class TableValid {
    private int trnum;
    private int tdnum;
    private int linknum;
    private int textnum;
    private int scriptnum;

    public int getScriptnum() {
        return scriptnum;
    }

    public void setScriptnum(int scriptnum) {
        this.scriptnum = scriptnum;
    }

    public int getLinknum() {
        return linknum;
    }

    public void setLinknum(int linknum) {
        this.linknum = linknum;
    }

    public int getTdnum() {
        return tdnum;
    }

    public void setTdnum(int tdnum) {
        this.tdnum = tdnum;
    }

    public int getTextnum() {
        return textnum;
    }

    public void setTextnum(int textnum) {
        this.textnum = textnum;
    }

    public int getTrnum() {
        return trnum;
    }

    public void setTrnum(int trnum) {
        this.trnum = trnum;
    }
}


package com.cs.parser.util;

public class TableColumnValid {
    int tdNum;
    boolean valid;
	public int getTdNum() {
		return tdNum;
	}
	public void setTdNum(int tdNum) {
		this.tdNum = tdNum;
	}
	public boolean isValid() {
		return valid;
	}
	public void setValid(boolean valid) {
		this.valid = valid;
	}


}


接下来看看如何解析html页面
加入htmlparser.jar包 
package com.cs;

public interface Parsable {

	public String getTitle() ;
	public String getContent()  ;
	public String getSummary()  ;
}

package com.cs;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.htmlparser.Node;
import org.htmlparser.NodeFilter;
import org.htmlparser.Parser;
import org.htmlparser.filters.NodeClassFilter;
import org.htmlparser.nodes.TagNode;
import org.htmlparser.nodes.TextNode;
import org.htmlparser.tags.Div;
import org.htmlparser.tags.ImageTag;
import org.htmlparser.tags.LinkTag;
import org.htmlparser.tags.ParagraphTag;
import org.htmlparser.tags.ScriptTag;
import org.htmlparser.tags.SelectTag;
import org.htmlparser.tags.Span;
import org.htmlparser.tags.StyleTag;
import org.htmlparser.tags.TableColumn;
import org.htmlparser.tags.TableHeader;
import org.htmlparser.tags.TableRow;
import org.htmlparser.tags.TableTag;
import org.htmlparser.tags.TitleTag;
import org.htmlparser.util.NodeIterator;
import org.htmlparser.util.NodeList;
import org.htmlparser.util.ParserException;

import com.cs.parser.util.PageContent;
import com.cs.parser.util.TableColumnValid;
import com.cs.parser.util.TableValid;


public class EasyHtmlParser implements Parsable {

	 protected static final String lineSign = System.getProperty(
     "line.separator");
	 protected static final int lineSign_size = lineSign.length();


	private File file ;

	private String content ;
	private String summary ;
	private String title ;


	public static void main(String[] args) {
		EasyHtmlParser eParser = new EasyHtmlParser(new File("E:\\EclipseStudyWorkspace\\LuceneParse\\fileSource\\www.htm")) ;
		System.out.println("html content : "+eParser.getContent()) ;
	}


	public EasyHtmlParser(File file) {
		this.file = file ;
	}

	private String getString() {
		try {
			BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(file))) ;
			String html = "" ;
			String str = null ;
			while ((str = br.readLine())!= null ) {
				html += str ;
			}
			return html ;
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null ;
	}


	public synchronized   String getContent() {
		if (content != null ) {
			return content ;
		}
		String html = this.getString() ;
		Parser parser = new Parser() ;

		try {
			 parser.setInputHTML(html) ;
			 for (NodeIterator e = parser.elements(); e.hasMoreNodes();){
				       Node node = (Node) e.nextNode();


	                	PageContent context = new PageContent();
	                    context.setNumber(0);
	                    context.setTextBuffer(new StringBuffer());
	                    //抓取出内容
	                    extractHtml(node, context, "");

	                    StringBuffer testContext = context.getTextBuffer();
	   //System.out.println(testContext);
	                    content = testContext.toString() ;

			 }

					if (content == null ) {
			        	content = "" ;
			        }

	                if (content.length() < 200) {
	        			summary = content ;
	        		}else {
	        			summary = content.substring(0,200) ;
	        		}  

	                NodeFilter filter = new NodeClassFilter(TitleTag.class) ;
	                parser.reset() ;
	                NodeList titleNodes = parser.extractAllNodesThatMatch(filter) ;
	                if (titleNodes != null && titleNodes.elementAt(0) != null){
	                	title = titleNodes.elementAt(0).toPlainTextString() ;
	                }else{
	                	title = "" ;
	                }

	              /*  System.out.println(file.getAbsolutePath()+"   "+"title:"+title);
	        		System.out.println(file.getAbsolutePath()+"   "+"content:"+content);
	        		System.out.println(file.getAbsolutePath()+"   "+"summary:"+summary); 
					*/
		} catch (ParserException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}


		return content;
	}

	public String getSummary() {
		if (summary != null) {
			return summary ;
		}
		if (content == null ) {
			getContent() ; 			
		}
		return summary;
	}

	public String getTitle() {
		if (title != null) {
			return title ;
		}
		if (content == null ) {
			getContent() ; 			
		}


		return "";
	}

    protected List extractHtml(Node nodeP, PageContent pageContent, String siteUrl) throws Exception {
	    NodeList nodeList = nodeP.getChildren();
	    boolean bl = false;

	    if ((nodeList == null) || (nodeList.size() == 0)) {
	        if (nodeP instanceof ParagraphTag) {
	            ArrayList tableList = new ArrayList();
	            StringBuffer temp = new StringBuffer();
	            temp.append("<p style=\"TEXT-INDENT: 2em\">");
	            tableList.add(temp);
	            temp = new StringBuffer();
	            temp.append("</p>").append(lineSign);
	            tableList.add(temp);

	            return tableList;
	        }

	        return null;
	    }

	    if ((nodeP instanceof TableTag) || (nodeP instanceof Div)) {
	        bl = true;
	    }

	    if (nodeP instanceof ParagraphTag) {
	        ArrayList tableList = new ArrayList();
	        StringBuffer temp = new StringBuffer();
	        temp.append("<p style=\"TEXT-INDENT: 2em\">");
	        tableList.add(temp);
	        extractParagraph(nodeP, siteUrl, tableList);

	        temp = new StringBuffer();
	        temp.append("</p>").append(lineSign);

	        tableList.add(temp);

	        return tableList;
	    }

	    ArrayList tableList = new ArrayList();

	    try {
	        for (NodeIterator e = nodeList.elements(); e.hasMoreNodes();) {
	            Node node = (Node) e.nextNode();

	            if (node instanceof LinkTag) {
	                tableList.add(node);
	                setLinkImg(node, siteUrl);
	            } else if (node instanceof ImageTag) {
	                ImageTag img = (ImageTag) node;

	                if (img.getImageURL().toLowerCase().indexOf("http://") < 0) {
	                    img.setImageURL(siteUrl + img.getImageURL());
	                } else {
	                    img.setImageURL(img.getImageURL());
	                }

	                tableList.add(node);
	            } else if (node instanceof ScriptTag ||
	                    node instanceof StyleTag || node instanceof SelectTag) {
	            } else if (node instanceof TextNode) {
	                if (node.getText().length() > 0) {
	                    StringBuffer temp = new StringBuffer();
	                    String text = collapse(node.getText()
	                                               .replaceAll(" ", "")
	                                               .replaceAll("　", ""));

	                    temp.append(text.trim());

	                    tableList.add(temp);
	                }
	            } else {
	                if (node instanceof TableTag || node instanceof Div) {
	                    TableValid tableValid = new TableValid();
	                    isValidTable(node, tableValid);

	                    if (tableValid.getTrnum() > 2) {
	                        tableList.add(node);

	                        continue;
	                    }
	                }

	                List tempList = extractHtml(node, pageContent, siteUrl);

	                if ((tempList != null) && (tempList.size() > 0)) {
	                    Iterator ti = tempList.iterator();

	                    while (ti.hasNext()) {
	                        tableList.add(ti.next());
	                    }
	                }
	            }
	        }
	    } catch (Exception e) {
	        return null;
	    }

	    if ((tableList != null) && (tableList.size() > 0)) {
	        if (bl) {
	            StringBuffer temp = new StringBuffer();
	            Iterator ti = tableList.iterator();
	            int wordSize = 0;
	            StringBuffer node;
	            int status = 0;
	            StringBuffer lineStart = new StringBuffer(
	                    "<p style=\"TEXT-INDENT: 2em\">");
	            StringBuffer lineEnd = new StringBuffer("</p>" + lineSign);

	            while (ti.hasNext()) {
	                Object k = ti.next();

	                if (k instanceof LinkTag) {
	                    if (status == 0) {
	                        temp.append(lineStart);
	                        status = 1;
	                    }

	                    node = new StringBuffer(((LinkTag) k).toHtml());
	                    temp.append(node);
	                } else if (k instanceof ImageTag) {
	                    if (status == 0) {
	                        temp.append(lineStart);
	                        status = 1;
	                    }

	                    node = new StringBuffer(((ImageTag) k).toHtml());
	                    temp.append(node);
	                } else if (k instanceof TableTag) {
	                    if (status == 0) {
	                        temp.append(lineStart);
	                        status = 1;
	                    }

	                    node = new StringBuffer(((TableTag) k).toHtml());
	                    temp.append(node);
	                } else if (k instanceof Div) {
	                    if (status == 0) {
	                        temp.append(lineStart);
	                        status = 1;
	                    }

	                    node = new StringBuffer(((Div) k).toHtml());
	                    temp.append(node);
	                } else {
	                    node = (StringBuffer) k;

	                    if (status == 0) {
	                        if (node.indexOf("<p") < 0) {
	                            temp.append(lineStart);
	                            temp.append(node);
	                            wordSize = wordSize + node.length();
	                            status = 1;
	                        } else {
	                            temp.append(node);
	                            status = 1;
	                        }
	                    } else if (status == 1) {
	                        if (node.indexOf("</p") < 0) {
	                            if (node.indexOf("<p") < 0) {
	                                temp.append(node);
	                                wordSize = wordSize + node.length();
	                            } else {
	                                temp.append(lineEnd);
	                                temp.append(node);
	                                status = 1;
	                            }
	                        } else {
	                            temp.append(node);
	                            status = 0;
	                        }
	                    }
	                }
	            }

	            if (status == 1) {
	                temp.append(lineEnd);
	            }

	            if (wordSize > pageContent.getNumber()) {
	                pageContent.setNumber(wordSize);
	                pageContent.setTextBuffer(temp);
	            }

	            return null;
	        } else {
	            return tableList;
	        }
	    }

	    return null;
}


	/**
	    * 提取段落中的内容
	    * @param nodeP
	    * @param siteUrl
	    * @param tableList
	    * @return
	    */
	    private List extractParagraph(Node nodeP, String siteUrl, List tableList) {
	        NodeList nodeList = nodeP.getChildren();

	        if ((nodeList == null) || (nodeList.size() == 0)) {
	            if (nodeP instanceof ParagraphTag) {
	                StringBuffer temp = new StringBuffer();
	                temp.append("<p style=\"TEXT-INDENT: 2em\">");
	                tableList.add(temp);
	                temp = new StringBuffer();
	                temp.append("</p>").append(lineSign);
	                tableList.add(temp);

	                return tableList;
	            }

	            return null;
	        }

	        try {
	            for (NodeIterator e = nodeList.elements(); e.hasMoreNodes();) {
	                Node node = (Node) e.nextNode();

	                if (node instanceof ScriptTag || node instanceof StyleTag ||
	                        node instanceof SelectTag) {
	                } else if (node instanceof LinkTag) {
	                    tableList.add(node);
	                    setLinkImg(node, siteUrl);
	                } else if (node instanceof ImageTag) {
	                    ImageTag img = (ImageTag) node;

	                    if (img.getImageURL().toLowerCase().indexOf("http://") < 0) {
	                        img.setImageURL(siteUrl + img.getImageURL());
	                    } else {
	                        img.setImageURL(img.getImageURL());
	                    }

	                    tableList.add(node);
	                } else if (node instanceof TextNode) {
	                    if (node.getText().trim().length() > 0) {
	                        String text = collapse(node.getText()
	                                                   .replaceAll(" ", "")
	                                                   .replaceAll("　", ""));
	                        StringBuffer temp = new StringBuffer();
	                        temp.append(text);
	                        tableList.add(temp);
	                    }
	                } else if (node instanceof Span) {
	                    StringBuffer spanWord = new StringBuffer();
	                    getSpanWord(node, spanWord);

	                    if ((spanWord != null) && (spanWord.length() > 0)) {
	                        String text = collapse(spanWord.toString()
	                                                       .replaceAll(" ", "")
	                                                       .replaceAll("　", ""));

	                        StringBuffer temp = new StringBuffer();
	                        temp.append(text);
	                        tableList.add(temp);
	                    }
	                } else if (node instanceof TagNode) {
	                    String tag = node.toHtml();

	                    if (tag.length() <= 10) {
	                        tag = tag.toLowerCase();

	                        if ((tag.indexOf("strong") >= 0) ||
	                                (tag.indexOf("b") >= 0)) {
	                            StringBuffer temp = new StringBuffer();
	                            temp.append(tag);
	                            tableList.add(temp);
	                        }
	                    } else {
	                        if (node instanceof TableTag || node instanceof Div) {
	                            TableValid tableValid = new TableValid();
	                            isValidTable(node, tableValid);

	                            if (tableValid.getTrnum() > 2) {
	                                tableList.add(node);

	                                continue;
	                            }
	                        }

	                        extractParagraph(node, siteUrl, tableList);
	                    }
	                }
	            }
	        } catch (Exception e) {
	            return null;
	        }

	        return tableList;
	    }


	    protected void getSpanWord(Node nodeP, StringBuffer spanWord) {
	        NodeList nodeList = nodeP.getChildren();

	        try {
	            for (NodeIterator e = nodeList.elements(); e.hasMoreNodes();) {
	                Node node = (Node) e.nextNode();

	                if (node instanceof ScriptTag || node instanceof StyleTag ||
	                        node instanceof SelectTag) {
	                } else if (node instanceof TextNode) {
	                    spanWord.append(node.getText());
	                } else if (node instanceof Span) {
	                    getSpanWord(node, spanWord);
	                } else if (node instanceof ParagraphTag) {
	                    getSpanWord(node, spanWord);
	                } else if (node instanceof TagNode) {
	                    String tag = node.toHtml().toLowerCase();

	                    if (tag.length() <= 10) {
	                        if ((tag.indexOf("strong") >= 0) ||
	                                (tag.indexOf("b") >= 0)) {
	                            spanWord.append(tag);
	                        }
	                    }
	                }
	            }
	        } catch (Exception e) {
	        }

	        return;
	    }

	    /**
	    * 判断TABLE是否是表单
	    * @param nodeP
	    * @return
	    */
	    private void isValidTable(Node nodeP, TableValid tableValid) {
	        NodeList nodeList = nodeP.getChildren();

	        /**如果该表单没有子节点则返回**/
	        if ((nodeList == null) || (nodeList.size() == 0)) {
	            return;
	        }

	        try {
	            for (NodeIterator e = nodeList.elements(); e.hasMoreNodes();) {
	                Node node = (Node) e.nextNode();

	                /**如果子节点本身也是表单则返回**/
	                if (node instanceof TableTag || node instanceof Div) {
	                    return;
	                } else if (node instanceof ScriptTag ||
	                        node instanceof StyleTag || node instanceof SelectTag) {
	                    return;
	                } else if (node instanceof TableColumn) {
	                    return;
	                } else if (node instanceof TableRow) {
	                    TableColumnValid tcValid = new TableColumnValid();
	                    tcValid.setValid(true);
	                    findTD(node, tcValid);

	                    if (tcValid.isValid()) {
	                        if (tcValid.getTdNum() < 2) {
	                            if (tableValid.getTdnum() > 0) {
	                                return;
	                            } else {
	                                continue;
	                            }
	                        } else {
	                            if (tableValid.getTdnum() == 0) {
	                                tableValid.setTdnum(tcValid.getTdNum());
	                                tableValid.setTrnum(tableValid.getTrnum() + 1);
	                            } else {
	                                if (tableValid.getTdnum() == tcValid.getTdNum()) {
	                                    tableValid.setTrnum(tableValid.getTrnum() +
	                                        1);
	                                } else {
	                                    return;
	                                }
	                            }
	                        }
	                    }
	                } else {
	                    isValidTable(node, tableValid);
	                }
	            }
	        } catch (Exception e) {
	            return;
	        }

	        return;
	    }

	    /**
	    * 判断是否有效TR
	    * @param nodeP
	    * @param TcValid
	    * @return
	    */
	    private void findTD(Node nodeP, TableColumnValid tcValid) {
	        NodeList nodeList = nodeP.getChildren();

	        /**如果该表单没有子节点则返回**/
	        if ((nodeList == null) || (nodeList.size() == 0)) {
	            return;
	        }

	        try {
	            for (NodeIterator e = nodeList.elements(); e.hasMoreNodes();) {
	                Node node = (Node) e.nextNode();

	                /**如果有嵌套表单**/
	                if (node instanceof TableTag || node instanceof Div ||
	                        node instanceof TableRow ||
	                        node instanceof TableHeader) {
	                    tcValid.setValid(false);

	                    return;
	                } else if (node instanceof ScriptTag ||
	                        node instanceof StyleTag || node instanceof SelectTag) {
	                    tcValid.setValid(false);

	                    return;
	                } else if (node instanceof TableColumn) {
	                    tcValid.setTdNum(tcValid.getTdNum() + 1);
	                } else {
	                    findTD(node, tcValid);
	                }
	            }
	        } catch (Exception e) {
	            tcValid.setValid(false);

	            return;
	        }

	        return;
	    }

	    protected String collapse(String string) {
	        int chars;
	        int length;
	        int state;
	        char character;
	        StringBuffer buffer = new StringBuffer();
	        chars = string.length();

	        if (0 != chars) {
	            length = buffer.length();
	            state = ((0 == length) || (buffer.charAt(length - 1) == ' ') ||
	                ((lineSign_size <= length) &&
	                buffer.substring(length - lineSign_size, length).equals(lineSign)))
	                ? 0 : 1;

	            for (int i = 0; i < chars; i++) {
	                character = string.charAt(i);

	                switch (character) {
	                case '\u0020':
	                case '\u0009':
	                case '\u000C':
	                case '\u200B':
	                case '\u00a0':
	                case '\r':
	                case '\n':

	                    if (0 != state) {
	                        state = 1;
	                    }

	                    break;

	                default:

	                    if (1 == state) {
	                        buffer.append(' ');
	                    }

	                    state = 2;
	                    buffer.append(character);
	                }
	            }
	        }

	        return buffer.toString();
	    }


	    /**
	     * 设置图象连接
	     * @param nodeP
	     * @param siteUrl
	     */
	     private void setLinkImg(Node nodeP, String siteUrl) {
	         NodeList nodeList = nodeP.getChildren();

	         try {
	             for (NodeIterator e = nodeList.elements(); e.hasMoreNodes();) {
	                 Node node = (Node) e.nextNode();

	                 if (node instanceof ImageTag) {
	                     ImageTag img = (ImageTag) node;

	                     if (img.getImageURL().toLowerCase().indexOf("http://") < 0) {
	                         img.setImageURL(siteUrl + img.getImageURL());
	                     } else {
	                         img.setImageURL(img.getImageURL());
	                     }
	                 }
	             }
	         } catch (Exception e) {
	             return;
	         }

	         return;
	     }

}


现在可以成功的把html解析为纯文本了
wzh20099
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
lucene-索引HTML文档
深未来技术
12-24 1173
1、大部分WEB文档采用HTML格式。2、本例用如下HTML文档                  Laptop power supplies are avaliable in First class only                     code,write,fly   3、使用JTidyJTidy由Andy Quick编写的T
基于lucene新闻搜索毕业论文
06-09
接下来，系统对这些网页进行信息抽取，这个过程通常包括HTML解析、文本提取和去噪等步骤，目的是将非结构化的网页内容转化为适合索引的结构化数据。然后，Lucene的索引机制被用来构建倒排索引，这个索引结构使得基于...
html抽取文本信息-java版（适合lucene建立索引）
落叶翩翩的CSDN博客
06-25 1881
import org.htmlparser.NodeFilter; import org.htmlparser.Parser; import org.htmlparser.beans.StringBean; import org.htmlparser.filters.CssSelectorNodeFilter; import org.htmlparser.util.NodeList; publi
lucene和网页静态化整合（crud）
阳某的博客
09-10 348
目录总结lucene代码网页静态化代码 总结 lucene 更新索引：先把原来所有的删除，然后再新建全部索引文件 增加和删除索引：都是根据doc对象来增加或删除指定的索引文件 网页静态化 新增静态页面：根据已有的模板文件，把前台传入的值依次获取，然后把前台传入的id当成html名称 最终实现：新增加一条博客，它内容对应的索引文件也会自动生成，并且会自动生成静态页面，删除了这条博客，它的博客索引文件...
lucene 网页抓取，模拟搜索引擎
12-20
lucene 网页抓取，模拟搜索引擎。web开发项目，部署即可，运行
Homework-4 作业补充1
08-03
它可以方便地从HTML文档中抽取正文内容。虽然Boilerpipe在这里被使用，但在实际应用中，如果需要更精确的内容抽取，如特定元素的选择，推荐使用jsoup库，它的CSS选择器功能更强大。对于jsoup无法处理的情况，可以...
网络爬虫系统
05-15
开发Java网络爬虫时，可以利用Lucene进行网页内容的索引和快速检索： - Lucene的使用：理解索引的构建过程，包括分析文本、创建倒排索引等。 - 查询解析：学习如何将用户输入的查询字符串转化为Lucene可以识别的...
毕业设计-旅游系统源码-trip-search:solr构建景点搜索引擎
06-06
本repository中的代码主要是爬虫模块、网页抽取模块、搜索服务、客户端的代码。 . ├── ExtractHtml ├── README.md ├── SearchApp ├── SearchService ├── SightSpider └── SolrHome ExtractHtml ...
JAVA上百实例源码以及开源项目源代码
09-17
利用随机函数抽取幸运数字 简单 EJB的真实世界模型（源代码） 15个目标文件 摘要:Java源码,初学实例,基于EJB的真实世界模型 　基于EJB的真实世界模型，附源代码，部分功能需JSP配合完成。 J2ME优化压缩PNG文件 4个...
java实现lucene高亮显示Html,直接测试就可以用
06-23
java实现lucene高亮显示Html,直接测试就可以用；java实现的对html进行高亮显示，
使用lucene生成html文件索引
tyrone的专栏
07-28 3385
我修改了lucene的demo包的IndexHTML类，使其可以被其他Java类调用。import org.apache.lucene.analysis.standard.StandardAnalyzer;import org.apache.lucene.document.Document;import org.apache.lucene.index.IndexReader;import org.
Lucene对pdf、word、html等文件的处理
aitcax的专栏
10-09 3479
Lucene在创建索引的过程中，yuanc PDFBox是一个在java环境中对pdf文件进行解析处理的开源软件，同时它也提供了一个丰富的类库支持对pdf文件的操作。PDFBox为使 用Lucene的开发者专门提供了LucenePDFDocument类，它的static方法getDocument（ps:该方法被重载三次）能够直 接返回一个Lucene的Document类型结果。所以在为一
Lucene 2.2.0发布自带的HTMLParser的使用
pavel0的专栏
02-06 455
Lucene 2.2.0发行包中自带的org.apache.lucene.demo包中，有一个为HTML和TXT文件建立索引、删除索引以及实现检索的实例，其中在org.apache.lucene.demo.html包中的一些类，是真正解析HTML文件的工具类，包括解析类、预定义类、异常处理类。 这个例子的命令提示为： IndexHTML [-create] [-index &lt;index&g...
Java Lucene(8)：解析html页面
wpkk66的专栏
03-05 2680
Java lucene 技术(8): 解析html页面可能Html页面是目前数量最多的数据存储格式，因此，lucene内置了html解析器，用以提供对html页面的解析，解析器对内部细节进行了较好的封装，我们所需做的，只是根据它提供的API，进行相应的程序编写。程序8.1提供了一个解析html页面的方式。 BufferedReader br =            new BufferedRea
lucene 关键词高亮显示
lycos的六度空间
10-10 1380
 使用Lucene自带的Highlighter就可以实现对原始文件摘要的提取工作。Highlighter类有一个getBestFragment方法，这个方法有多个重载的方法，其中，使用：public final String getBestFragment(Analyzer analyzer, String fieldName,String text)就可以提取摘要，它实现了从指定的原
常用正则表达式爬取网页信息及分析HTML标签总结
极客神殿
09-05 4196
这篇文章主要是介绍Python爬取网页信息时，经常使用的正则表达式及方法。它是一篇总结性文章，实用性比较大，主要解决自己遇到的爬虫问题，也希望对你有所帮助~ 当然如果会Selenium基于自动化测试爬虫、BeautifulSoup分析网页DOM节点，这就更方便了，但本文更多的是介绍基于正则的底层爬取分析。 涉及内容如下： 常用正则表达式爬取网页信息及HTML分析总结 1.获取&amp;amp;amp;lt;...
Lucene索引前对doc pdf html文件的预处理
伏龙的专栏
12-06 2798
初学Lucene，写下点小小的心得：Lucene提供的API能够方便地对文本文档创建索引，但当需要为像.doc 、.pdf 这样的非文本文档创建索引时就必须先把文档转换为纯文本。对.pdf文件的处理lib：PDFBoxPDFBox是一个在java环境中对pdf文件进行解析处理的开源软件，同时它也提供了一个丰富的类库支持对pdf文件的操作。PDFBox为使用Lucene的开发者专
lucene-使用htmlparser提取网页普通链接
深未来技术
12-23 813
1、提取普通链接以http://www.qunar.com/site/zh/Cooperate_4.shtml为例，只能提取普通链接，如EMAIL链接就无法提取代码:package extract;import java.net.URL;import org.htmlparser.beans.LinkBean;public class extracthtmllinksimp
lucene7与lucene8
最新发布
07-12
lucene7与lucene8是Apache Lucene搜索引擎的两个主要版本。Lucene是一个开源的全文搜索引擎库，用于构建强大的搜索功能。 Lucene7是在2017年发布的一个重要版本，它引入了许多新功能和改进。其中一些改进包括更快的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值