Java爬取网页的简易工具类
 
使用工具类前先导入依赖
 (jsoup解析网页 , 不能解析视频 , 音乐 )
 
<dependency>
    <groupId>org.jsoup</groupId>
    <artifactId>jsoup</artifactId>
    <version>1.10.2</version>
</dependency>
 
Java 工具类 解析网页, 打印出网页代码
 前提,需要联网
 
package util;

import entity.Content;
import org.jsoup.Jsoup;

import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

//爬虫解析页面的工具类
@Component  //可以作为工具类调用
public class Reptile {
    public static void main(String[] args) throws Exception {
        new Reptile().parseJD("java").forEach(System.out::println);

    }

    public List<Content> parseJD(String keywords) throws Exception {
        //获取请求   网址 https://search.jd.com/Search?keyword=java 京东搜索Java的页面网址
        //前提,需要联网
        String url = "https://search.jd.com/Search?keyword=" + keywords;
        //解析网页(jsoup返回document 就是 Document 对象)
        Document document = Jsoup.parse(new URL(url), 30000);
        //所有js可以使用的方法 document 都能用    byid 对应页面代码ID  getElementsByClass 对应页面代码的name
        Element element = document.getElementById("J_goodsList");    
        //获取页面中所有的li标签
        Elements elements = element.getElementsByTag("li");
        ArrayList<Content> goodlist = new ArrayList<>();
//        获取元素的内容 遍历打印出来  el 就是每个li标签
        for (Element el : elements) {
            //获取图片      img从页面代码查询
            //关于图片特别多的网站,都是延迟加载
            String img = el.getElementsByTag("img").eq(0).attr("src");
            //大公司一般注意性能问题,这样放图片性能更高  图片一般放入别的路径延迟加载source-data-lazy-advertisement
//            String img1 = el.getElementsByTag("img").eq(0).attr("source-data-lazy-advertisement");
            //获取价格
            String price = el.getElementsByClass("p-price").eq(0).text();
            //获取页面标题
            String title = el.getElementsByClass("p-name").eq(0).text();
            Content content = new Content();
            content.setImg(img);
            content.setTitle(title);
            content.setPrice(price);
            goodlist.add(content);
        }
        return goodlist;
    }
}

package entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

//爬虫的封装对象
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Content {
    //可以自己添加属性
    private  String img;
    private  String price;
    private  String title;
}

MinerUtil.java 爬虫工具类
 
package com.iteye.injavawetrust.miner;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TimeZone;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jsoup.Connection;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

/**
 * 爬虫工具类
 * @author InJavaWeTrust
 *
 */
public class MinerUtil {
	
	private static final Log LOG = LogFactory.getLog(MinerUtil.class);
	
	public static long starTime = 0;
	
	/**
	 * 判断是否为空
	 * @param param
	 * @return true-为空;false-非空
	 */
	public static boolean isBlank(String param) {
		return (null == param || "".equals(param.trim())) ? true : false;
	}
	
	/**
	 * URL是否以html结尾
	 * @param url
	 * @return true-是;false-否
	 */
	public static boolean checkURL(String url) {
		String html = url.substring(url.lastIndexOf(".") + 1);
		return "html".equals(html) ? true : false;
	}
	/**
	 * URL列表是否包含关键字
	 * @param key 关键字
	 * @param keys URL列表
	 * @return true-是;false-否
	 */
	public static boolean checkKeys(String key, List<String> keys) {
		boolean flag = false;
		for(String k : keys) {
			if(key.contains(k)){
				flag = true;
				break;
			}
		}
		return flag;
	}
	
	public static boolean isValidFileName(String fileName) {
		if (fileName == null || fileName.length() > 255){
			return false;
		} else {
			return fileName
					.matches("[^\\s\\\\/:\\*\\?\\\"<>\\|](\\x20|[^\\s\\\\/:\\*\\?\\\"<>\\|])*[^\\s\\\\/:\\*\\?\\\"<>\\|\\.]$");
		}
	} 
	
	/**
	 * 获取URL
	 * @param url URL
	 * @return URL
	 */
	public static Set<String> getAllUrl(String url){
		Set<String> urls = new HashSet<String>();
		try {
			Connection conn = Jsoup.connect(url);
			conn.header("User-Agent", "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/525.13 (KHTML, like Gecko) Chrome/0.2.149.27 Safari/525.13");//模拟浏览器  
			Document document = conn.timeout(5000).get();
			Elements hrefs = document.select("a[href]");
			Iterator<Element> hrefIter = hrefs.iterator();
			while (hrefIter.hasNext()) {
				Element href = hrefIter.next();
				urls.add(href.attr("href"));
			}
		} catch (Exception e) {
			LOG.info("获取URL出现异常，异常URL[" + url + "]");
			LOG.info("异常信息[" + e.getMessage() + "]");
		}
		return urls;
	}
	
	/**
	 * 毫秒转换成hhmmss
	 * @param ms 毫秒
	 * @return hh:mm:ss
	 */
	public static String msToss(long ms) {
		SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss");
		formatter.setTimeZone(TimeZone.getTimeZone("GMT+00:00"));
		String ss = formatter.format(ms);
		return ss;
	}
	
	/**
	 * 将html写入本地文件
	 * @param htmlText html内容
	 * @param htmlName html名称
	 */
	public static void getHtmlToLocal(Map<String, String> map){
		Writer writer = null;
		try {
			String path = MinerConstanits.HTMLPATH + getToday();
			makeDir(path);
			writer = new OutputStreamWriter(new FileOutputStream(new File(path
					+ File.separator + map.get("title"))), "UTF-8");
			writer.write(map.get("html"));
			writer.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (writer != null) {
				try {
					writer.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	/**
	 * 文件名不能包含下列任何字符:<br>
	 * \/:*?"<>|
	 * @param title 标题
	 * @return 去掉文件名不能包含的字符
	 */
	public static String fileName(String title){
		return title
				.replaceAll("\\\\", "")
				.replaceAll("/", "")
				.replaceAll(":", "")
				.replaceAll("\\*", "")
				.replaceAll("\\?", "")
				.replaceAll("\"", "")
				.replaceAll("<", "")
				.replaceAll(">", "")
				.replaceAll("\\|", "");
	}
	/**
	 * 获取当天日期
	 * @return 当天日期
	 */
	public static String getToday(){
		String result = "";
		Date date = new Date();
		result = format(date);
		return result;
	}
	/**
	 * 格式化日期
	 * @param date 日期
	 * @return yyyymmdd 日期
	 */
	public static String format(Date date){
		String format = "yyyyMMdd";
		SimpleDateFormat fmt = new SimpleDateFormat(format);
		return fmt.format(date);
	}
	/**
	 * 创建存储目录
	 * @param path 存储目录
	 */
	public static void makeDir(String path) {
		File file = new File(path);
		if(!file.exists()){
			file.mkdirs();
			LOG.info("创建存储目录[" + path + "]");
		}
	}
	
	public static boolean checkBeforeStart(MinerConfig config) {
		if(null == config){
			LOG.info("config未配置！！！");
			return false;
		}
		if(null == config.getKeys() || 0 == config.getKeys().size()){
			LOG.info("包含关键字未配置！！！");
			return false;
		}
		if(null == config.getStoreType()){
			LOG.info("存储方式未配置！！！");
			return false;
		}
		if(config.getMaxDepth() < 1){
			LOG.info("爬取页面最大深度配置错误！！！");
			return false;
		}
		if(config.getMinerHtmlThreadNum() < 1){
			LOG.info("下载页面线程数配置错误！！！");
			return false;
		}
		if(config.getMiseringThreadNum() < 1){
			LOG.info("分析页面线程数配置错误！！！");
			return false;
		}
		if(config.getMinserStoreThreadNum() < 1){
			LOG.info("存储线程数配置错误！！！");
			return false;
		}
		return true;
	}
	
	public static void main(String[] args) {
		String path = MinerConstanits.HTMLPATH + File.separator + getToday();
		makeDir(path);
//		System.out.println(getToday());
//		String test = "http://my.163.com/2015/11/27/17763_578935.html";
//		System.out.println(fileName(test));
//		System.out.println(MinerUtil.isBlank(null));
//		System.out.println(MinerUtil.isBlank(""));
//		System.out.println(MinerUtil.isBlank(" "));
//		System.out.println(MinerUtil.isBlank("bbb"));
//		System.out.println(MinerUtil.isBlank(" bbb "));
		
//		String key = "http://www.jqu.net.cn";
//		List<String> keys = new ArrayList<String>();
//		keys.add("http://www.jqu.net.cn");
//		System.out.println(MinerUtil.checkKeys(key, keys));
	}

}
 
 
 
返回列表
 
 

Java爬虫
 
前言：之前就有好多小伙伴说道爬虫的事情，但是我们比较常见的都是用python爬虫，那么Java爬虫如何操作呢？接下来我将会介绍一个详细的流程供大家参考，我们就以豆瓣视频为例
 
 
寻找爬虫入口
 
此处建议使用谷大爷浏览器
 
首先我们找到豆瓣视频的官网网址：https://movie.douban.com
 
打开开发者工具如下，看到数据如下：
 
 
之后我们再看下请求头信息如下：
 
 
最后找到的爬取的入口为：
 
https://movie.douban.com/j/new_search_subjects?sort=U&range=0,10&tags=&start=0
 
 
开始爬取数据
 
1.创建Maven工程
 
 
2.添加所需依赖至pom.xml文件
 
<dependencies>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
    <dependency>
        <groupId>org.json</groupId>
        <artifactId>json</artifactId>
        <version>20140107</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.47</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.1</version>
    </dependency>
</dependencies>
 
3.创建项目完成之后目录如下
 
 
4.在model包中根据豆瓣影视的字段创建实体类对象
 
 
public class Movie {

    private String id;
    private String directors;
    private String title;
    private String cover;
    private String rate;
    private String casts;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getDirectors() {
        return directors;
    }

    public void setDirectors(String directors) {
        this.directors = directors;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getCover() {
        return cover;
    }

    public void setCover(String cover) {
        this.cover = cover;
    }

    public String getRate() {
        return rate;
    }

    public void setRate(String rate) {
        this.rate = rate;
    }

    public String getCasts() {
        return casts;
    }

    public void setCasts(String casts) {
        this.casts = casts;
    }
}
 
5.创建mapper接口
 
public interface MovieMapper {

    public void insert(Movie movie);

    List<Movie> findAll();
}
 
6.在resources下创建数据连接配置文件jdbc.properties
 
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/movie
username=root
password=XXXXXX
 
7.创建mybatis配置文件 mybatis-config.xml
 
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <properties resource="jdbc.properties"></properties>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="MovieMapper.xml"/>
    </mappers>

</configuration>
 
8.创建mapper.xml映射文件
 
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.wxy.mapper.MovieMapper">
    <select id="findAll" resultType="com.wxy.model.Movie">
        select * from movie
    </select>
    <insert id="insert" parameterType="com.wxy.model.Movie">
        insert into movie (id,directors,title,cover,rate,casts) values (#{id},#{directors},#{title},#{cover},#{rate},#{casts})
    </insert>
</mapper>
 
9.通过原生Java的Http协议进行爬取，工具类如下
 
public class GetJson {
    public JSONObject getHttpJson(String url, int comefrom) throws Exception {
        try {
            URL realUrl = new URL(url);
            HttpURLConnection connection = (HttpURLConnection) realUrl.openConnection();
            connection.setRequestProperty("accept", "*/*");
            connection.setRequestProperty("connection", "Keep-Alive");
            connection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            // 建立连接
            connection.connect();
            //请求成功
            if (connection.getResponseCode() == 200) {
                InputStream is = connection.getInputStream();
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                //10MB的缓存
                byte[] buffer = new byte[10485760];
                int len = 0;
                while ((len = is.read(buffer)) != -1) {
                    baos.write(buffer, 0, len);
                }
                String jsonString = baos.toString();
                baos.close();
                is.close();
                //转换成json数据处理
                // getHttpJson函数的后面的参数1，表示返回的是json数据，2表示http接口的数据在一个（）中的数据
                JSONObject jsonArray = getJsonString(jsonString, comefrom);
                return jsonArray;
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        return null;
    }

    public JSONObject getJsonString(String str, int comefrom) throws Exception{
        JSONObject jo = null;
        if(comefrom==1){
            return new JSONObject(JSON.parseObject(str));
        }else if(comefrom==2){
            int indexStart = 0;
            //字符处理
            for(int i=0;i<str.length();i++){
                if(str.charAt(i)=='('){
                    indexStart = i;
                    break;
                }
            }
            String strNew = "";
            //分割字符串
            for(int i=indexStart+1;i<str.length()-1;i++){
                strNew += str.charAt(i);
            }
            return new JSONObject(JSON.parseObject(strNew));
        }
        return jo;
    }
}
 
10.爬取豆瓣电影数据启动类
 
public class App {
    public static  void  main(String [] args) {

        String resource = "mybatis-config.xml"; //定义配置文件路径
        InputStream inputStream = null;
        try {
            inputStream = Resources.getResourceAsStream(resource);//读取配置文件
        } catch (IOException e) {
            e.printStackTrace();
        }

        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);//注册mybatis 工厂

        SqlSession sqlSession = sqlSessionFactory.openSession();//得到连接对象

        MovieMapper movieMapper = sqlSession.getMapper(MovieMapper.class);//从mybatis中得到dao对象

        int start;//每页多少条
        int total = 0;//记录数
        int end = 10000;//总共10000条数据
        for (start  = 0; start <= end; start += 20)  {
            try {

                String address = "https://Movie.douban.com/j/new_search_subjects?sort=U&range=0,10&tags=&start=" + start;

                JSONObject dayLine = new GetJson().getHttpJson(address, 1);

                System.out.println(dayLine+"-----------------");
                System.out.println("start:" + start);
                JSONArray json = dayLine.getJSONArray("data");

                System.out.println(json+"===================");
                List<Movie> list = JSON.parseArray(json.toString(), Movie.class);

                if (start >= end){
                    System.out.println("爬取到底");
                    sqlSession.close();
                }
                for (Movie movie : list) {
                    movieMapper.insert(movie);
                    sqlSession.commit();
                }
                total += list.size();
                System.out.println("正在爬取中 -- 共抓取:" + total + "条数据");

            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }

}
 
11.创建数据库
 
此处我们使用mysql数据库，根据上述字段创建数据库以及对应表和字段，如下为运行之后的爬取结果：
 
 
爬完总结
 
我们爬完数据之后，看到满满的数据库数据，很是爽啊，但是你可以试试将数据库里面的数据全部清掉，再爬一次（也就是在运行一下我们的项目），运行完之后有的人可能就懵掉了，控制台报错了，如下：
 
 这是什么情况？难道是项目出问题了，别急，我们再来通过浏览器访问下该url,结果发现，，，
 
 
没数据了，其实现在好多网站为了防止爬虫，对访问IP进行了限制，关于限制多长时间，是随机性还是固定性就没准了，比如博主就是爬完第一次之后的半个小时之后才能在爬第二次，但感觉这样也不是最有效的解决办法啊。其实解决办法也不是没有，比如通过设置Http请求头直接绕过、使用代理IP等，大家可以自行去百度啦

jsoup 简介

Java 程序在解析 HTML 文档时，相信大家都接触过 htmlparser 这个开源项目，我曾经在 IBM DW 上发表过两篇关于 htmlparser 的文章，分别是：从HTML中攫取你所需的信息 和扩展 HTMLParser 对自定义标签的处理能力。但现在我已经不再使用 htmlparser 了，原因是 htmlparser 很少更新，但最重要的是有了 jsoup 。

jsoup 是一款 Java 的HTML 解析器，可直接解析某个URL地址、HTML文本内容。它提供了一套非常省力的API，可通过DOM，CSS以及类似于jQuery的操作方法来取出和操作数据。

jsoup的主要功能如下：

   1. 从一个URL，文件或字符串中解析HTML；
   2. 使用DOM或CSS选择器来查找、取出数据；
   3. 可操作HTML元素、属性、文本；

jsoup是基于MIT协议发布的，可放心使用于商业项目。

jsoup 的主要类层次结构如下图所示：



接下来我们专门针对几种常见的应用场景举例说明 jsoup 是如何优雅的进行 HTML 文档处理的。

文档输入

jsoup 可以从包括字符串、URL地址以及本地文件来加载 HTML 文档，并生成 Document 对象实例。

下面是相关代码：
// 直接从字符串中输入 HTML 文档String html = "<html><head><title>开源中国社区</title></head>"
  + "<body><p>这里是 jsoup 项目的相关文章</p></body></html>";
Document doc = Jsoup.parse(html);// 从URL直接加载 HTML 文档Document doc = Jsoup.connect("http://www.oschina.net/").get();
String title = doc.title();

Document doc = Jsoup.connect("http://www.oschina.net/")
  .data("query", "Java")   //请求参数
  .userAgent("I’m jsoup") //设置User-Agent
  .cookie("auth", "token") //设置cookie
  .timeout(3000)           //设置连接超时时间
  .post();                 //使用POST方法访问URL// 从文件中加载 HTML 文档File input = new File("D:/test.html");
Document doc = Jsoup.parse(input,"UTF-8","http://www.oschina.net/");

请大家注意最后一种 HTML 文档输入方式中的 parse 的第三个参数，为什么需要在这里指定一个网址呢（虽然可以不指定，如第一种方法）？因为 HTML 文档中会有很多例如链接、图片以及所引用的外部脚本、css文件等，而第三个名为 baseURL 的参数的意思就是当 HTML 文档使用相对路径方式引用外部文件时，jsoup 会自动为这些 URL 加上一个前缀，也就是这个 baseURL。 



例如 <a href=/project>开源软件</a> 会被转换成 <a href=http://www.oschina.net/project>开源软件</a>。 




解析并提取 HTML 元素 



这部分涉及一个 HTML 解析器最基本的功能，但 jsoup 使用一种有别于其他开源项目的方式——选择器，我们将在最后一部分详细介绍 jsoup 选择器，本节中你将看到 jsoup 是如何用最简单的代码实现。 



不过 jsoup 也提供了传统的 DOM 方式的元素解析，看看下面的代码：
File input = new File("D:/test.html");
Document doc = Jsoup.parse(input, "UTF-8", "http://www.oschina.net/");

Element content = doc.getElementById("content");
Elements links = content.getElementsByTag("a");for (Element link : links) {
  String linkHref = link.attr("href");
  String linkText = link.text();
}
你可能会觉得 jsoup 的方法似曾相识，没错，像 getElementById 和 getElementsByTag 方法跟 JavaScript 的方法名称是一样的，功能也完全一致。你可以根据节点名称或者是 HTML 元素的 id 来获取对应的元素或者元素列表。 



与 htmlparser 项目不同的是，jsoup 并没有为 HTML 元素定义一个对应的类，一般一个 HTML 元素的组成部分包括：节点名、属性和文本，jsoup 提供简单的方法供你自己检索这些数据，这也是 jsoup 保持瘦身的原因。 



而在元素检索方面，jsoup 的选择器简直无所不能，
File input = new File("D:\test.html");
Document doc = Jsoup.parse(input,"UTF-8","http://www.oschina.net/");

Elements links = doc.select("a[href]"); // 具有 href 属性的链接Elements pngs = doc.select("img[src$=.png]");//所有引用png图片的元素Element masthead = doc.select("div.masthead").first();// 找出定义了 class=masthead 的元素Elements resultLinks = doc.select("h3.r > a"); // direct a after h3
这是 jsoup 真正让我折服的地方，jsoup 使用跟 jQuery 一模一样的选择器对元素进行检索，以上的检索方法如果换成是其他的 HTML 解释器，至少都需要很多行代码，而 jsoup 只需要一行代码即可完成。

jsoup 的选择器还支持表达式功能，我们将在最后一节介绍这个超强的选择器。
修改数据

在解析文档的同时，我们可能会需要对文档中的某些元素进行修改，例如我们可以为文档中的所有图片增加可点击链接、修改链接地址或者是修改文本等。

下面是一些简单的例子：
doc.select("div.comments a").attr("rel", "nofollow");//为所有链接增加 rel=nofollow 属性doc.select("div.comments a").addClass("mylinkclass");//为所有链接增加 class=mylinkclass 属性doc.select("img").removeAttr("onclick"); //删除所有图片的onclick属性doc.select("input[type=text]").val(""); //清空所有文本输入框中的文本


道理很简单，你只需要利用 jsoup 的选择器找出元素，然后就可以通过以上的方法来进行修改，除了无法修改标签名外（可以删除后再插入新的元素），包括元素的属性和文本都可以修改。

修改完直接调用 Element(s) 的 html() 方法就可以获取修改完的 HTML 文档。
HTML 文档清理

jsoup 在提供强大的 API 同时，人性化方面也做得非常好。在做网站的时候，经常会提供用户评论的功能。有些用户比较淘气，会搞一些脚本到评论内容中，而这些脚本可能会破坏整个页面的行为，更严重的是获取一些机要信息，例如 XSS 跨站点攻击之类的。

jsoup 对这方面的支持非常强大，使用非常简单。看看下面这段代码：
String unsafe = "<p><a href='http://www.oschina.net/' οnclick='stealCookies()'>开源中国社区</a></p>";
String safe = Jsoup.clean(unsafe, Whitelist.basic());// 输出: // <p><a href="http://www.oschina.net/" rel="nofollow">开源中国社区</a></p>


jsoup 使用一个 Whitelist 类用来对 HTML 文档进行过滤，该类提供几个常用方法：

如果这五个过滤器都无法满足你的要求呢，例如你允许用户插入 flash 动画，没关系，Whitelist 提供扩展功能，例如 whitelist.addTags("embed","object","param","span","div"); 也可调用 addAttributes 为某些元素增加属性。
jsoup 的过人之处——选择器

前面我们已经简单的介绍了 jsoup 是如何使用选择器来对元素进行检索的。本节我们把重点放在选择器本身强大的语法上。下表是 jsoup 选择器的所有语法详细列表。

基本用法

以上是最基本的选择器语法，这些语法也可以组合起来使用，下面是 jsoup 支持的组合用法：

除了一些基本的语法以及这些语法进行组合外，jsoup 还支持使用表达式进行元素过滤选择。下面是 jsoup 支持的所有表达式一览表：

总结

jsoup 的基本功能到这里就介绍完毕，但由于 jsoup 良好的可扩展性 API 设计，你可以通过选择器的定义来开发出非常强大的 HTML 解析功能。再加上 jsoup 项目本身的开发也非常活跃，因此如果你正在使用 Java ，需要对 HTML 进行处理，不妨试试。