`
lzj0470
  • 浏览: 1276932 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

htmlparser 编码问题

QQHTML 
阅读更多

     有时候，在抓取网站的时候，网站的编码方式可能不统一，这样的情况，可能有些网页编码不成功，而htmlparser报了错，不能正常的读取。抛出来的异常为：org.htmlparser.util.EncodingChangeException: character mismatch (new: 中 [0x4e2d] != old:  [0xd6?]) for encoding change from ISO-8859-1 to GB2312 at character offset 23

为了解决不管它是用何种编码方式，都能够正常读取数据。我在htmlparser的Page类中加了一个字段，之所以要在Page类中加，那是因为它历遍所有的标签过程中，把meta标签属性content捕获到了，并已经传值到setEncoding(String charset)办法中。

          代码如下:

 

// Decompiled by Jad v1.5.8f. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   Page.java

package org.htmlparser.lexer;

import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.*;
import java.util.zip.*;
import org.htmlparser.http.ConnectionManager;
import org.htmlparser.util.ParserException;

// Referenced classes of package org.htmlparser.lexer:
//            InputStreamSource, PageIndex, StringSource, Cursor, 
//            Stream, Source

public class Page
    implements Serializable
{

    public Page()
    {
        this("");
    }

    public Page(URLConnection connection)
        throws ParserException
    {
        if(null == connection)
        {
            throw new IllegalArgumentException("connection cannot be null");
        } else
        {
            setConnection(connection);
            mBaseUrl = null;
            return;
        }
    }

    public Page(InputStream stream, String charset)
        throws UnsupportedEncodingException
    {
        if(null == stream)
            throw new IllegalArgumentException("stream cannot be null");
        if(null == charset)
            charset = "ISO-8859-1";
        mSource = new InputStreamSource(stream, charset);
        mIndex = new PageIndex(this);
        mConnection = null;
        mUrl = null;
        mBaseUrl = null;
    }

    public Page(String text, String charset)
    {
        if(null == text)
            throw new IllegalArgumentException("text cannot be null");
        if(null == charset)
            charset = "ISO-8859-1";
        mSource = new StringSource(text, charset);
        mIndex = new PageIndex(this);
        mConnection = null;
        mUrl = null;
        mBaseUrl = null;
    }

    public Page(String text)
    {
        this(text, null);
    }

    public Page(Source source)
    {
        if(null == source)
        {
            throw new IllegalArgumentException("source cannot be null");
        } else
        {
            mSource = source;
            mIndex = new PageIndex(this);
            mConnection = null;
            mUrl = null;
            mBaseUrl = null;
            return;
        }
    }

    public static ConnectionManager getConnectionManager()
    {
        return mConnectionManager;
    }

    public static void setConnectionManager(ConnectionManager manager)
    {
        mConnectionManager = manager;
    }

    public String getCharset(String content)
    {
        String CHARSET_STRING = "charset";
        String ret;
        if(null == mSource)
            ret = "ISO-8859-1";
        else
            ret = mSource.getEncoding();
        if(null != content)
        {
            int index = content.indexOf("charset");
            if(index != -1)
            {
                content = content.substring(index + "charset".length()).trim();
                if(content.startsWith("="))
                {
                    content = content.substring(1).trim();
                    index = content.indexOf(";");
                    if(index != -1)
                        content = content.substring(0, index);
                    if(content.startsWith("\"") && content.endsWith("\"") && 1 < content.length())
                        content = content.substring(1, content.length() - 1);
                    if(content.startsWith("'") && content.endsWith("'") && 1 < content.length())
                        content = content.substring(1, content.length() - 1);
                    ret = findCharset(content, ret);
                }
            }
        }
        return ret;
    }

    public static String findCharset(String name, String fallback)
    {
        String ret;
        try
        {
            Class cls = Class.forName("java.nio.charset.Charset");
            Method method = cls.getMethod("forName", new Class[] {
                java.lang.String.class
            });
            Object object = method.invoke(null, new Object[] {
                name
            });
            method = cls.getMethod("name", new Class[0]);
            object = method.invoke(object, new Object[0]);
            ret = (String)object;
        }
        catch(ClassNotFoundException cnfe)
        {
            ret = name;
        }
        catch(NoSuchMethodException nsme)
        {
            ret = name;
        }
        catch(IllegalAccessException ia)
        {
            ret = name;
        }
        catch(InvocationTargetException ita)
        {
            ret = fallback;
            System.out.println("unable to determine cannonical charset name for " + name + " - using " + fallback);
        }
        return ret;
    }

    private void writeObject(ObjectOutputStream out)
        throws IOException
    {
        if(null != getConnection())
        {
            out.writeBoolean(true);
            out.writeInt(mSource.offset());
            String href = getUrl();
            out.writeObject(href);
            setUrl(getConnection().getURL().toExternalForm());
            Source source = getSource();
            mSource = null;
            PageIndex index = mIndex;
            mIndex = null;
            out.defaultWriteObject();
            mSource = source;
            mIndex = index;
        } else
        {
            out.writeBoolean(false);
            String href = getUrl();
            out.writeObject(href);
            setUrl(null);
            out.defaultWriteObject();
            setUrl(href);
        }
    }

    private void readObject(ObjectInputStream in)
        throws IOException, ClassNotFoundException
    {
        boolean fromurl = in.readBoolean();
        if(fromurl)
        {
            int offset = in.readInt();
            String href = (String)in.readObject();
            in.defaultReadObject();
            if(null != getUrl())
            {
                URL url = new URL(getUrl());
                try
                {
                    setConnection(url.openConnection());
                }
                catch(ParserException pe)
                {
                    throw new IOException(pe.getMessage());
                }
            }
            Cursor cursor = new Cursor(this, 0);
            for(int i = 0; i < offset; i++)
                try
                {
                    getCharacter(cursor);
                }
                catch(ParserException pe)
                {
                    throw new IOException(pe.getMessage());
                }

            setUrl(href);
        } else
        {
            String href = (String)in.readObject();
            in.defaultReadObject();
            setUrl(href);
        }
    }

    public void reset()
    {
        getSource().reset();
        mIndex = new PageIndex(this);
    }

    public void close()
        throws IOException
    {
        if(null != getSource())
            getSource().destroy();
    }

    protected void finalize()
        throws Throwable
    {
        close();
    }

    public URLConnection getConnection()
    {
        return mConnection;
    }

    public void setConnection(URLConnection connection)
        throws ParserException
    {
        mConnection = connection;
        mConnection.setConnectTimeout(6000);
        mConnection.setReadTimeout(6000);
        try
        {
            getConnection().connect();
        }
        catch(UnknownHostException uhe)
        {
            throw new ParserException("Connect to " + mConnection.getURL().toExternalForm() + " failed.", uhe);
        }
        catch(IOException ioe)
        {
            throw new ParserException("Exception connecting to " + mConnection.getURL().toExternalForm() + " (" + ioe.getMessage() + ").", ioe);
        }
        String type = getContentType();
        String charset = getCharset(type);
        try
        {
            String contentEncoding = connection.getContentEncoding();
            System.out.println("contentEncoding="+contentEncoding);
            Stream stream;
            if(null != contentEncoding && -1 != contentEncoding.indexOf("gzip"))
                stream = new Stream(new GZIPInputStream(getConnection().getInputStream()));
            else
            if(null != contentEncoding && -1 != contentEncoding.indexOf("deflate"))
                stream = new Stream(new InflaterInputStream(getConnection().getInputStream(), new Inflater(true)));
            else{
                stream = new Stream(getConnection().getInputStream());
            }

            try
            {
		/*
            	 * 时间:2008年12月23日
            	 * 原因:当String charset = getCharset(type);返回来的是ISO-8859-1的时候,需要处理一下
            	 */
            	if(charset.indexOf("ISO-8859-1")!=-1){
            		charset = getQICHAODEFAULT_CHARSET();
            	}
		 mSource = new InputStreamSource(stream, charset);
            }
            catch(UnsupportedEncodingException uee)
            {
                charset = "ISO-8859-1";
                mSource = new InputStreamSource(stream, charset);
            }
        }
        catch(IOException ioe)
        {
            throw new ParserException("Exception getting input stream from " + mConnection.getURL().toExternalForm() + " (" + ioe.getMessage() + ").", ioe);
        }
        mUrl = connection.getURL().toExternalForm();
		mIndex = new PageIndex(this);
    }

    public String getUrl()
    {
        return mUrl;
    }

    public void setUrl(String url)
    {
        mUrl = url;
    }

    public String getBaseUrl()
    {
        return mBaseUrl;
    }

    public void setBaseUrl(String url)
    {
        mBaseUrl = url;
    }

    public Source getSource()
    {
        return mSource;
    }

    public String getContentType()
    {
        String ret = "text/html";
        URLConnection connection = getConnection();
        if(null != connection)
        {
            String content = connection.getHeaderField("Content-Type");
            if(null != content)
                ret = content;
        }
        return ret;
    }

    public char getCharacter(Cursor cursor)
        throws ParserException
    {
        int i = cursor.getPosition();
        int offset = mSource.offset();
        char ret;
        if(offset == i)
            try
            {
                i = mSource.read();
                if(-1 == i)
                {
                    ret = '\uFFFF';
                } else
                {
                    ret = (char)i;
                    cursor.advance();
                }
            }
            catch(IOException ioe)
            {
                throw new ParserException("problem reading a character at position " + cursor.getPosition(), ioe);
            }
        else
        if(offset > i)
        {
            try
            {
                ret = mSource.getCharacter(i);
            }
            catch(IOException ioe)
            {
                throw new ParserException("can't read a character at position " + i, ioe);
            }
            cursor.advance();
        } else
        {
            throw new ParserException("attempt to read future characters from source " + i + " > " + mSource.offset());
        }
        if('\r' == ret)
        {
            ret = '\n';
            if(mSource.offset() == cursor.getPosition())
                try
                {
                    i = mSource.read();
                    if(-1 != i)
                        if('\n' == (char)i)
                            cursor.advance();
                        else
                            try
                            {
                                mSource.unread();
                            }
                            catch(IOException ioe)
                            {
                                throw new ParserException("can't unread a character at position " + cursor.getPosition(), ioe);
                            }
                }
                catch(IOException ioe)
                {
                    throw new ParserException("problem reading a character at position " + cursor.getPosition(), ioe);
                }
            else
                try
                {
                    if('\n' == mSource.getCharacter(cursor.getPosition()))
                        cursor.advance();
                }
                catch(IOException ioe)
                {
                    throw new ParserException("can't read a character at position " + cursor.getPosition(), ioe);
                }
        }
        if('\n' == ret)
            mIndex.add(cursor);
        return ret;
    }

    public void ungetCharacter(Cursor cursor)
        throws ParserException
    {
        cursor.retreat();
        int i = cursor.getPosition();
        try
        {
            char ch = mSource.getCharacter(i);
            if('\n' == ch && 0 != i)
            {
                ch = mSource.getCharacter(i - 1);
                if('\r' == ch)
                    cursor.retreat();
            }
        }
        catch(IOException ioe)
        {
            throw new ParserException("can't read a character at position " + cursor.getPosition(), ioe);
        }
    }

    public String getEncoding()
    {
        return getSource().getEncoding();
    }

    public void setEncoding(String character_set)
        throws ParserException
    {
    	this.QICHAODEFAULT_CHARSET = character_set;
        getSource().setEncoding(character_set);
    }

    public URL constructUrl(String link, String base)
        throws MalformedURLException
    {
        return constructUrl(link, base, false);
    }

    public URL constructUrl(String link, String base, boolean strict)
        throws MalformedURLException
    {
        int index;
        URL url;
        if(!strict && '?' == link.charAt(0))
        {
            if(-1 != (index = base.lastIndexOf('?')))
                base = base.substring(0, index);
            url = new URL(base + link);
        } else
        {
            url = new URL(new URL(base), link);
        }
        String path = url.getFile();
        boolean modified = false;
        boolean absolute = link.startsWith("/");
        if(!absolute)
            do
            {
                if(!path.startsWith("/."))
                    break;
                if(path.startsWith("/../"))
                {
                    path = path.substring(3);
                    modified = true;
                    continue;
                }
                if(!path.startsWith("/./") && !path.startsWith("/."))
                    break;
                path = path.substring(2);
                modified = true;
            } while(true);
        while(-1 != (index = path.indexOf("/\\"))) 
        {
            path = path.substring(0, index + 1) + path.substring(index + 2);
            modified = true;
        }
        if(modified)
            url = new URL(url, path);
        return url;
    }

    public String getAbsoluteURL(String link)
    {
        return getAbsoluteURL(link, false);
    }

    public String getAbsoluteURL(String link, boolean strict)
    {
        String ret;
        if(null == link || "".equals(link))
            ret = "";
        else
            try
            {
                String base = getBaseUrl();
                if(null == base)
                    base = getUrl();
                if(null == base)
                {
                    ret = link;
                } else
                {
                    URL url = constructUrl(link, base, strict);
                    ret = url.toExternalForm();
                }
            }
            catch(MalformedURLException murle)
            {
                ret = link;
            }
        return ret;
    }

    public int row(Cursor cursor)
    {
        return mIndex.row(cursor);
    }

    public int row(int position)
    {
        return mIndex.row(position);
    }

    public int column(Cursor cursor)
    {
        return mIndex.column(cursor);
    }

    public int column(int position)
    {
        return mIndex.column(position);
    }

    public String getText(int start, int end)
        throws IllegalArgumentException
    {
        String ret;
        try
        {
            ret = mSource.getString(start, end - start);
        }
        catch(IOException ioe)
        {
            throw new IllegalArgumentException("can't get the " + (end - start) + "characters at position " + start + " - " + ioe.getMessage());
        }
        return ret;
    }

    public void getText(StringBuffer buffer, int start, int end)
        throws IllegalArgumentException
    {
        if(mSource.offset() < start || mSource.offset() < end)
            throw new IllegalArgumentException("attempt to extract future characters from source" + start + "|" + end + " > " + mSource.offset());
        int length;
        if(end < start)
        {
            length = end;
            end = start;
            start = length;
        }
        length = end - start;
        try
        {
            mSource.getCharacters(buffer, start, length);
        }
        catch(IOException ioe)
        {
            throw new IllegalArgumentException("can't get the " + (end - start) + "characters at position " + start + " - " + ioe.getMessage());
        }
    }

    public String getText()
    {
        return getText(0, mSource.offset());
    }

    public void getText(StringBuffer buffer)
    {
        getText(buffer, 0, mSource.offset());
    }

    public void getText(char array[], int offset, int start, int end)
        throws IllegalArgumentException
    {
        if(mSource.offset() < start || mSource.offset() < end)
            throw new IllegalArgumentException("attempt to extract future characters from source");
        int length;
        if(end < start)
        {
            length = end;
            end = start;
            start = length;
        }
        length = end - start;
        try
        {
            mSource.getCharacters(array, offset, start, end);
        }
        catch(IOException ioe)
        {
            throw new IllegalArgumentException("can't get the " + (end - start) + "characters at position " + start + " - " + ioe.getMessage());
        }
    }

    public String getLine(Cursor cursor)
    {
        int line = row(cursor);
        int size = mIndex.size();
        int start;
        int end;
        if(line < size)
        {
            start = mIndex.elementAt(line);
            if(++line <= size)
                end = mIndex.elementAt(line);
            else
                end = mSource.offset();
        } else
        {
            start = mIndex.elementAt(line - 1);
            end = mSource.offset();
        }
        return getText(start, end);
    }

    public String getLine(int position)
    {
        return getLine(new Cursor(this, position));
    }

    public String toString()
    {
        String ret;
        if(mSource.offset() > 0)
        {
            StringBuffer buffer = new StringBuffer(43);
            int start = mSource.offset() - 40;
            if(0 > start)
                start = 0;
            else
                buffer.append("...");
            getText(buffer, start, mSource.offset());
            ret = buffer.toString();
        } else
        {
            ret = super.toString();
        }
        return ret;
    }

    public static final String DEFAULT_CHARSET = "ISO-8859-1";
    public static String QICHAODEFAULT_CHARSET = "gb2312";
    public static final String DEFAULT_CONTENT_TYPE = "text/html";
    public static final char EOF = 65535;
    protected String mUrl;
    protected String mBaseUrl;
    protected Source mSource;
    protected PageIndex mIndex;
    protected transient URLConnection mConnection;
    protected static ConnectionManager mConnectionManager = new ConnectionManager();
	public static String getQICHAODEFAULT_CHARSET() {
		return QICHAODEFAULT_CHARSET;
	}

}
 

在调用的时候，代码如下:

			Parser parser = new Parser(url);
			parser.setEncoding(parser.getLexer().getPage().getQICHAODEFAULT_CHARSET());

  一般情况下，设置成这样应该是没问题的啦，但是，你有时候看到的编码方式并不一定是它该网页的编码方式。比如说，肉眼看到页面中有<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />，htmlparser可以正常的获取到，代码如下:

    public void doSemanticAction()
        throws ParserException
    {
        String httpEquiv = getHttpEquiv();
        if("Content-Type".equalsIgnoreCase(httpEquiv))
        {
            String charset = getPage().getCharset(getAttribute("CONTENT"));
            getPage().setEncoding(charset);
        }
    }

 但是，你不要认为这个就是它的编码方式啦，在htmlparser，还进行了一次判断，在类Page中，有个方法是获取报头字段Content-Type的。代码如下:

    public String getContentType()
    {
        String ret = "text/html";
        URLConnection connection = getConnection();
        if(null != connection)
        {
            String content = connection.getHeaderField("Content-Type");
            if(null != content)
                ret = content;
        }
        return ret;
    }

 两个进行比较，如果不一样的话，它就报了

org.htmlparser.util.EncodingChangeException: character mismatch (new: 中 [0x4e2d] != old:  [0xd6?]) for encoding change from ISO-8859-1 to GB2312 at character offset 23

 ，所以，我在类InputStreamSource再一次进行修改:

代码如下:

    public void setEncoding(String character_set)
        throws ParserException
    {
        String encoding = getEncoding();
        /**
         * time:2008年12月23日
         */
        if(encoding!=null){
        	character_set = encoding;
        }
        if(!encoding.equalsIgnoreCase(character_set))
        {
            InputStream stream = getStream();
            try
            {
                char buffer[] = mBuffer;
                int offset = mOffset;
                stream.reset();
                try
                {
                    mEncoding = character_set;
                    mReader = new InputStreamReader(stream, character_set);
                    mBuffer = new char[mBuffer.length];
                    mLevel = 0;
                    mOffset = 0;
                    mMark = -1;
                    if(0 != offset)
                    {
                        char new_chars[] = new char[offset];
                        if(offset != read(new_chars))
                            throw new ParserException("reset stream failed");
                        for(int i = 0; i < offset; i++)
                            if(new_chars[i] != buffer[i])
                                throw new EncodingChangeException("character mismatch (new: " + new_chars[i] + " [0x" + Integer.toString(new_chars[i], 16) + "] != old: " + " [0x" + Integer.toString(buffer[i], 16) + buffer[i] + "]) for encoding change from " + encoding + " to " + character_set + " at character offset " + i);

                    }
                }
                catch(IOException ioe)
                {
                    throw new ParserException(ioe.getMessage(), ioe);
                }
            }
            catch(IOException ioe)
            {
                throw new ParserException("Stream reset failed (" + ioe.getMessage() + "), try wrapping it with a org.htmlparser.lexer.Stream", ioe);
            }
        }
    }

 这样应该来说，不管什么方式都OK的。

 

分享到：
| 一种快速高效的文本分类方法（二）
评论
10 楼 qachenzude 2011-12-11  
在catch里面捕获到它的异常，然后进行修改，比如parser.setEncoding("gb2312")。这样就行了
这个方法最好的~~
9 楼 xredman 2010-08-27  
哦，太好了，我烦人的问他你总算解决了
8 楼 wokong 2010-05-20  
最好的方法。。。本人在采用 与楼主说的最后1条意思一致 通用无论什么编码都不怕

1.采用httpclient解析网页并返回html
2.直接调用 paser.setInputHTML(httpclient返回的html);

什么网页 什么编码都通用了。。。 
7 楼 lzj0470 2010-05-04  
p_x1984 写道
你好！我现在想在爬取的时候：比如说A网站的编码是:gb2312,B网站是iso-8859-1,C网站是：gbk，我能否修改它的源码，到时候抓取的都是统一的编码，这样入库也是统一的编码格式啊。我的QQ是：282215036，可以讨论下。万分感谢了！


想要做到编码统一，个人建议不要用htmlparser作为连接网络的部分。你把连接网络部分独立出来。htmlparser的优点就是对网页的解析。
6 楼 lzj0470 2010-05-04  
gbfd2012 写道
你修改的InputStreamSource貌似和源代码没有什么修改。

你用的是什么版本
5 楼 gbfd2012 2010-05-04  
你修改的InputStreamSource貌似和源代码没有什么修改。
4 楼 p_x1984 2009-04-15  
你好！我现在想在爬取的时候：比如说A网站的编码是:gb2312,B网站是iso-8859-1,C网站是：gbk，我能否修改它的源码，到时候抓取的都是统一的编码，这样入库也是统一的编码格式啊。我的QQ是：282215036，可以讨论下。万分感谢了！
3 楼 lzj0470 2009-01-13  
你不修改源码也行，你在catch里面捕获到它的异常，然后进行修改，比如parser.setEncoding("gb2312")。这样就行了
2 楼 ganting 2009-01-12  
急。。。。望大虾解决！！
1 楼 ganting 2009-01-12  
楼主太厉害了，请问：能不能不改源代码而解决上面的问题呢？
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    htmlparser.jar 源码加jar包 彻底解决乱码

    在解析HTML时，常见的乱码问题通常源于以下几个方面： 1. **编码识别不准确**：网页可以使用多种字符编码，如GBK、UTF-8等。如果解析器不能正确识别网页的编码，就可能导致乱码。HTMLParser.jar通过改进源码，增强...

    htmlparser1.6最新版

    5. **字符编码识别**：HTMLParser可以自动检测HTML文档的字符编码，确保正确地处理各种语言的字符。 6. **DOM树构建**：虽然HTMLParser主要是事件驱动的，但也可以通过`HTMLNode`类构建一个DOM树，便于对整个HTML...

    htmlparser的jar包

    `org.htmlparser.lexer.Source`类代表一个HTML源，`org.htmlparser.lexer.Page`类则封装了HTML页面的信息，包括字符编码、URL等。`Lexer`类则是词法分析的核心，它会生成一系列的标记，供`Parser`进一步处理。`Lexer...

    htmlparser2.1.jar

    5. **字符编码识别**：HTMLParser2.1能自动检测网页的字符编码，确保正确解析非ASCII字符，这对于处理包含多种语言的网页尤其重要。 6. **兼容性与效率**：作为Java库，HTMLParser2.1可以运行在任何支持Java的平台...

    HTMLParser 2.0

    同时，需要注意的是，HTMLParser默认不处理编码问题，所以在解析前需要确保HTML内容已经被正确地解码。 在实际开发中，结合requests库获取网页内容，然后使用HTMLParser进行解析，是构建网络爬虫的基本流程之一。...

    JAVA htmlparser 使用实例

    1. **字符编码**：在读取文件时，需要注意文件的编码格式，本例中使用的是“GBK”编码。 2. **异常处理**：在实际开发中，应该对可能出现的各种异常进行妥善处理，比如文件不存在、解析错误等。 3. **性能优化**：...

    HtmlParser提取网页信息的设计与实现

    - **AbstractNode**: 提供了Node的一些抽象实现，简化了实际开发过程中的编码工作。 - **Element**: 表示HTML文档中的具体元素，如标签、属性等。 #### 三、提取网页信息的设计与实现 ##### 3.1 解析HTML文档 ...

    HTMLParser使用详解

    在本文中，我们将深入探讨HTMLParser的使用，包括其核心类`Parser`以及如何初始化和使用它。 首先，`Parser`是HTMLParser库的核心组件，它负责解析HTML页面。`Parser`类提供了多个构造函数，以适应不同的初始化需求...

    htmlparser使用简单讲解

    // 设置编码 public static void main(String[] args) { // 从文件读取HTML parseFromFile("path_to_your_file.html"); // 从URL读取HTML parseFromUrl("http://example.com"); } private static void ...

    htmlparser抓取网页内容

    在处理网页内容时，还需要考虑网页编码问题，确保正确地解码和编码数据，避免出现乱码。此外，为了提高抓取效率和处理动态加载的网页，可能需要用到`BeautifulSoup`这样的库来辅助解析，或者配合Selenium等工具模拟...

    Java使用HtmlParser实现简单的网络爬虫

    以下是如何使用HtmlParser实现网络爬虫的关键知识点： 1. **HtmlParser库**：HtmlParser是一个强大的HTML解析器，它能够解析HTML文档，将其转换为一个可操作的节点树，方便开发者通过节点过滤和遍历来获取目标信息...

    网络爬虫 HTMLParser 使用指南

    在HTMLParser中设置页面编码的方式有两种：一种是使用Lexer，另一种是使用静态方法createParser。由于Lexer是一个高级功能，对于大多数中文页面来说，常用的方法是使用静态方法createParser来设置编码。 6. 示例...

    彻底 HtmlParser 重写的两个类文件，直接放在目录下面或者大宝到jar里面可以用

    在这个场景中，我们关注的是一个针对`HtmlParser`的优化，特别是针对乱码问题的解决方案。 首先，让我们深入理解`HtmlParser`库的工作原理。`HtmlParser`通常提供一种方法来解析HTML源代码，将其转换为DOM...

    java htmlparser

    根据给定文件的信息，本文将围绕“Java HTMLParser解析网页源码”的主题展开，深入探讨其功能、工作原理以及在不同场景下的应用方法。 ### Java HTMLParser简介 HTMLParser是用Java编写的开源HTML解析器，它能帮助...

    htmlparser抓取论坛帖子内容的代码

    记得在解析之前，先设置解析器的编码，以防止乱码问题： ```java Parser parser = new Parser(new StringReader(htmlSource), "UTF-8"); ``` 4. **处理异常和优化** 在实际使用中，由于网页结构的复杂性，可能...

    htmlparser 资料集合

    `Htmlparser.rar`可能是一个包含源码或者示例项目的压缩文件，供你下载后进行实际编码练习。通过查看和运行这些代码，你可以更直观地理解HTMLParser的工作原理。 `htmlparser使用指南 4_海起啦啦.txt`是关于使用...

    htmlparser解析html分页

    在实际使用中，可能需要处理不规范的HTML或编码问题。可以通过设置错误处理策略，如忽略或替换非法字符，确保解析过程的稳定性。 8. **注意事项** - HTMLParser不支持XML，如果你需要解析XML文档，应使用`xml....

    HTMLParser

    在解析 HTML 时，正确处理各种字符集和编码是非常重要的。 5. **Formatter.dcu**：可能提供了格式化 HTML 输出的功能，例如将 DOM 树重新转换为 HTML 字符串，或者进行一些格式调整。 6. **Entities.dcu**：可能...

    htmlparser实现网页上抓取数据

    在编写爬虫时，可能会遇到网络错误、编码问题或者解析异常。良好的异常处理机制能帮助我们捕获这些问题并采取适当的恢复策略。 总结，HTMLParser是Python中用于解析HTML的内建库，对于构建简单的爬虫或处理小规模...

Magicbox
Global site tag (gtag.js) - Google Analytics