用 Java 爬小姐姐图片，这个厉害了。。。

灰太狼 2022-09-10 09:24 195阅读 0赞

![0D5F937FE12312312D81F17F.jpg][]

程序员的成长之路

互联网/程序员/技术/资料共享

[关注][Link 1]

阅读本文大概需要 8.5 分钟。

来自：*blog.csdn.net/qq\_35402412/article/details/113627625*

### 目的 ###

爬取搜狗图片上千张美女图片并下载到本地

### 准备工作 ###

爬取地址：`https://pic.sogou.com/pics?query=美女`

![a934541ddf11ba41e5c975e96e9d1bf1.png][]

图片

### 分析 ###

打开上面的地址，按F12开发者工具 - NetWork - XHR - 页面往下滑动XHR栏出现请求信息如下：

Request URL ：`https://pic.sogou.com/napi/pc/searchList?mode=1&start=48&xml_len=48&query=美女`

分析这段请求URL的主要几个参数：

*  `start=48` 表示从第48张图片开始检索
 *  `xml_len=48` 从地48张往后获取48张图片
 *  `query=？`搜索关键词（例：美女，这里浏览器自动做了转码，不影响我们使用）

![54bec5d170e9d6bbfe014b67caaac37c.png][]

图片

点击Respose，找个JSON格式器辅助过去看看。

![cf6305d48a118ad688347ce3d5dc6507.png][]

图片

JSON格式：https://www.bejson.com/

分析Respose返回的信息，可以发现我们想要的图片地址放在 picUrl里，

![911f0826b9719366748170fa276bf0c2.png][]

图片

### 思路 ###

通过以上分析，不难实现下载方法，思路如下：

1.  设置URL请求参数
2.  访问URL请求，获取图片地址
3.  图片地址存入List
4.  遍历List，使用线程池下载到本地

### 代码 ###

SougouImgProcessor.java 爬取图片类

import com.alibaba.fastjson.JSONObject;  
    import us.codecraft.webmagic.utils.HttpClientUtils;  
    import victor.chang.crawler.pipeline.SougouImgPipeline;  
      
    import java.util.ArrayList;  
    import java.util.List;  
      
    /**  
     * A simple PageProcessor.  
     * @author code4crafter@gmail.com <br>  
     * @since 0.1.0  
     */  
    public class SougouImgProcessor {  
      
        private String url;  
        private SougouImgPipeline pipeline;  
        private List<JSONObject> dataList;  
        private List<String> urlList;  
        private String word;  
      
        public SougouImgProcessor(String url,String word) {  
            this.url = url;  
            this.word = word;  
            this.pipeline = new SougouImgPipeline();  
            this.dataList = new ArrayList<>();  
            this.urlList = new ArrayList<>();  
        }  
      
        public void process(int idx, int size) {  
            String res = HttpClientUtils.get(String.format(this.url, idx, size, this.word));  
            JSONObject object = JSONObject.parseObject(res);  
            List<JSONObject> items = (List<JSONObject>)((JSONObject)object.get("data")).get("items");  
            for(JSONObject item : items){  
                this.urlList.add(item.getString("picUrl"));  
            }  
            this.dataList.addAll(items);  
        }  
      
        // 下载  
        public void pipelineData(){  
            // 多线程  
            pipeline.processSync(this.urlList, this.word);  
        }  
      
      
        public static void main(String[] args) {  
            String url = "https://pic.sogou.com/napi/pc/searchList?mode=1&start=%s&xml_len=%s&query=%s";  
            SougouImgProcessor processor = new SougouImgProcessor(url,"美女");  
      
            int start = 0, size = 50, limit = 1000; // 定义爬取开始索引、每次爬取数量、总共爬取数量  
      
            for(int i=start;i<start+limit;i+=size)  
                processor.process(i, size);  
      
            processor.pipelineData();  
      
        }  
      
    }

SougouImgPipeline.java  图片下载类

import java.io.File;  
    import java.io.FileOutputStream;  
    import java.io.InputStream;  
    import java.net.URL;  
    import java.net.URLConnection;  
    import java.util.List;  
    import java.util.Objects;  
    import java.util.concurrent.ExecutorService;  
    import java.util.concurrent.Executors;  
    import java.util.concurrent.TimeUnit;  
    import java.util.concurrent.atomic.AtomicInteger;  
      
    /**  
     * Store results in files.<br>  
     * @author code4crafter@gmail.com <br>  
     * @since 0.1.0  
     */  
    public class SougouImgPipeline {  
      
        private String extension = ".jpg";  
        private String path;  
      
        private volatile AtomicInteger suc;  
        private volatile AtomicInteger fails;  
      
        public SougouImgPipeline() {  
            setPath("E:/pipeline/sougou");  
            suc = new AtomicInteger();  
            fails = new AtomicInteger();  
        }  
      
        public SougouImgPipeline(String path) {  
            setPath(path);  
            suc = new AtomicInteger();  
            fails = new AtomicInteger();  
        }  
      
        public SougouImgPipeline(String path, String extension) {  
            setPath(path);  
            this.extension = extension;  
            suc = new AtomicInteger();  
            fails = new AtomicInteger();  
        }  
      
        public void setPath(String path) {  
            this.path = path;  
        }  
      
        /**  
         * 下载  
         * @param url  
         * @param cate  
         * @throws Exception  
         */  
        private void downloadImg(String url, String cate, String name) throws Exception {  
            String path = this.path + "/" + cate + "/";  
            File dir = new File(path);  
            if (!dir.exists()) {    // 目录不存在则创建目录  
                dir.mkdirs();  
            }  
            String realExt = url.substring(url.lastIndexOf("."));   // 获取扩展名  
            String fileName = name + realExt;  
            fileName = fileName.replace("-", "");  
            String filePath = path + fileName;  
            File img = new File(filePath);  
            if(img.exists()){   // 若文件之前已经下载过，则跳过  
                System.out.println(String.format("文件%s已存在本地目录",fileName));  
                return;  
            }  
      
            URLConnection con = new URL(url).openConnection();  
            con.setConnectTimeout(5000);  
            con.setReadTimeout(5000);  
            InputStream inputStream = con.getInputStream();  
            byte[] bs = new byte[1024];  
      
            File file = new File(filePath);  
            FileOutputStream os = new FileOutputStream(file, true);  
            // 开始读取 写入  
            int len;  
            while ((len = inputStream.read(bs)) != -1) {  
                os.write(bs, 0, len);  
            }  
            System.out.println("picUrl: " + url);  
            System.out.println(String.format("正在下载第%s张图片", suc.getAndIncrement()));  
        }  
      
        /**  
         * 单线程处理  
         *  
         * @param data  
         * @param word  
         */  
        public void process(List<String> data, String word) {  
            long start = System.currentTimeMillis();  
            for (String picUrl : data) {  
                if (picUrl == null)  
                    continue;  
                try {  
                    downloadImg(picUrl, word, picUrl);  
                } catch (Exception e) {  
                    fails.incrementAndGet();  
                }  
            }  
            System.out.println("下载成功: " + suc.get());  
            System.out.println("下载失败: " + fails.get());  
            long end = System.currentTimeMillis();  
            System.out.println("耗时：" + (end - start) / 1000 + "秒");  
        }  
      
      
        /**  
         * 多线程处理  
         *  
         * @param data  
         * @param word  
         */  
        public void processSync(List<String> data, String word) {  
            long start = System.currentTimeMillis();  
            int count = 0;  
            ExecutorService executorService = Executors.newCachedThreadPool(); // 创建缓存线程池  
            for (int i=0;i<data.size();i++) {  
                String picUrl = data.get(i);  
                if (picUrl == null)  
                    continue;  
                String name = "";  
                if(i<10){  
                    name="000"+i;  
                }else if(i<100){  
                    name="00"+i;  
                }else if(i<1000){  
                    name="0"+i;  
                }  
                String finalName = name;  
                executorService.execute(() -> {  
                    try {  
                        downloadImg(picUrl, word, finalName);  
                    } catch (Exception e) {  
                        fails.incrementAndGet();  
                    }  
                });  
                count++;  
            }  
            executorService.shutdown();  
            try {  
                if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {  
                    // 超时的时候向线程池中所有的线程发出中断(interrupted)。  
                    // executorService.shutdownNow();  
                }  
                System.out.println("AwaitTermination Finished");  
                System.out.println("共有URL: "+data.size());  
                System.out.println("下载成功: " + suc);  
                System.out.println("下载失败: " + fails);  
      
                File dir = new File(this.path + "/" + word + "/");  
                int len = Objects.requireNonNull(dir.list()).length;  
                System.out.println("当前共有文件： "+len);  
      
                long end = System.currentTimeMillis();  
                System.out.println("耗时：" + (end - start) / 1000.0 + "秒");  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
      
        }  
      
      
        /**  
         * 多线程分段处理  
         *  
         * @param data  
         * @param word  
         * @param threadNum  
         */  
        public void processSync2(List<String> data, final String word, int threadNum) {  
            if (data.size() < threadNum) {  
                process(data, word);  
            } else {  
                ExecutorService executorService = Executors.newCachedThreadPool();  
                int num = data.size() / threadNum;    //每段要处理的数量  
                for (int i = 0; i < threadNum; i++) {  
                    int start = i * num;  
                    int end = (i + 1) * num;  
                    if (i == threadNum - 1) {  
                        end = data.size();  
                    }  
                    final List<String> cutList = data.subList(start, end);  
                    executorService.execute(() -> process(cutList, word));  
                }  
                executorService.shutdown();  
            }  
        }  
      
    }

HttpClientUtils.java   http请求工具类

import org.apache.http.Header;  
    import org.apache.http.HttpEntity;  
    import org.apache.http.NameValuePair;  
    import org.apache.http.client.entity.UrlEncodedFormEntity;  
    import org.apache.http.client.methods.CloseableHttpResponse;  
    import org.apache.http.client.methods.HttpGet;  
    import org.apache.http.client.methods.HttpPost;  
    import org.apache.http.client.methods.HttpUriRequest;  
    import org.apache.http.conn.ssl.SSLConnectionSocketFactory;  
    import org.apache.http.conn.ssl.TrustStrategy;  
    import org.apache.http.entity.StringEntity;  
    import org.apache.http.impl.client.CloseableHttpClient;  
    import org.apache.http.impl.client.HttpClients;  
    import org.apache.http.message.BasicNameValuePair;  
    import org.apache.http.ssl.SSLContextBuilder;  
    import org.apache.http.util.EntityUtils;  
    import org.slf4j.Logger;  
    import org.slf4j.LoggerFactory;  
      
    import javax.net.ssl.HostnameVerifier;  
    import javax.net.ssl.SSLContext;  
    import javax.net.ssl.SSLSession;  
    import java.io.IOException;  
    import java.io.UnsupportedEncodingException;  
    import java.security.GeneralSecurityException;  
    import java.security.cert.CertificateException;  
    import java.security.cert.X509Certificate;  
    import java.util.ArrayList;  
    import java.util.HashMap;  
    import java.util.List;  
    import java.util.Map;  
      
    /**  
     * @author code4crafter@gmail.com  
     * Date: 17/3/27  
     */  
    public abstract class HttpClientUtils {  
      
        public static Map<String, List<String>> convertHeaders(Header[] headers) {  
            Map<String, List<String>> results = new HashMap<String, List<String>>();  
            for (Header header : headers) {  
                List<String> list = results.get(header.getName());  
                if (list == null) {  
                    list = new ArrayList<String>();  
                    results.put(header.getName(), list);  
                }  
                list.add(header.getValue());  
            }  
            return results;  
        }  
      
        /**  
         * http的get请求  
         * @param url  
         */  
        public static String get(String url) {  
            return get(url, "UTF-8");  
        }  
      
        public static Logger logger = LoggerFactory.getLogger(HttpClientUtils.class);  
      
        /**  
         * http的get请求  
         * @param url  
         */  
        public static String get(String url, String charset) {  
            HttpGet httpGet = new HttpGet(url);  
            return executeRequest(httpGet, charset);  
        }  
      
        /**  
         * http的get请求，增加异步请求头参数  
         * @param url  
         */  
        public static String ajaxGet(String url) {  
            return ajaxGet(url, "UTF-8");  
        }  
      
        /**  
         * http的get请求，增加异步请求头参数  
         *  
         * @param url  
         */  
        public static String ajaxGet(String url, String charset) {  
            HttpGet httpGet = new HttpGet(url);  
            httpGet.setHeader("X-Requested-With", "XMLHttpRequest");  
            return executeRequest(httpGet, charset);  
        }  
      
        /**  
         * @param url  
         * @return  
         */  
        public static String ajaxGet(CloseableHttpClient httpclient, String url) {  
            HttpGet httpGet = new HttpGet(url);  
            httpGet.setHeader("X-Requested-With", "XMLHttpRequest");  
            return executeRequest(httpclient, httpGet, "UTF-8");  
        }  
      
        /**  
         * http的post请求，传递map格式参数  
         */  
        public static String post(String url, Map<String, String> dataMap) {  
            return post(url, dataMap, "UTF-8");  
        }  
      
        /**  
         * http的post请求，传递map格式参数  
         */  
        public static String post(String url, Map<String, String> dataMap, String charset) {  
            HttpPost httpPost = new HttpPost(url);  
            try {  
                if (dataMap != null) {  
                    List<NameValuePair> nvps = new ArrayList<NameValuePair>();  
                    for (Map.Entry<String, String> entry : dataMap.entrySet()) {  
                        nvps.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));  
                    }  
                    UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nvps, charset);  
                    formEntity.setContentEncoding(charset);  
                    httpPost.setEntity(formEntity);  
                }  
            } catch (UnsupportedEncodingException e) {  
                e.printStackTrace();  
            }  
            return executeRequest(httpPost, charset);  
        }  
      
        /**  
         * http的post请求，增加异步请求头参数，传递map格式参数  
         */  
        public static String ajaxPost(String url, Map<String, String> dataMap) {  
            return ajaxPost(url, dataMap, "UTF-8");  
        }  
      
        /**  
         * http的post请求，增加异步请求头参数，传递map格式参数  
         */  
        public static String ajaxPost(String url, Map<String, String> dataMap, String charset) {  
            HttpPost httpPost = new HttpPost(url);  
            httpPost.setHeader("X-Requested-With", "XMLHttpRequest");  
            try {  
                if (dataMap != null) {  
                    List<NameValuePair> nvps = new ArrayList<NameValuePair>();  
                    for (Map.Entry<String, String> entry : dataMap.entrySet()) {  
                        nvps.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));  
                    }  
                    UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nvps, charset);  
                    formEntity.setContentEncoding(charset);  
                    httpPost.setEntity(formEntity);  
                }  
            } catch (UnsupportedEncodingException e) {  
                e.printStackTrace();  
            }  
            return executeRequest(httpPost, charset);  
        }  
      
        /**  
         * http的post请求，增加异步请求头参数，传递json格式参数  
         */  
        public static String ajaxPostJson(String url, String jsonString) {  
            return ajaxPostJson(url, jsonString, "UTF-8");  
        }  
      
        /**  
         * http的post请求，增加异步请求头参数，传递json格式参数  
         */  
        public static String ajaxPostJson(String url, String jsonString, String charset) {  
            HttpPost httpPost = new HttpPost(url);  
            httpPost.setHeader("X-Requested-With", "XMLHttpRequest");  
              
            StringEntity stringEntity = new StringEntity(jsonString, charset);// 解决中文乱码问题  
            stringEntity.setContentEncoding(charset);  
            stringEntity.setContentType("application/json");  
            httpPost.setEntity(stringEntity);  
            return executeRequest(httpPost, charset);  
        }  
      
        /**  
         * 执行一个http请求，传递HttpGet或HttpPost参数  
         */  
        public static String executeRequest(HttpUriRequest httpRequest) {  
            return executeRequest(httpRequest, "UTF-8");  
        }  
      
        /**  
         * 执行一个http请求，传递HttpGet或HttpPost参数  
         */  
        public static String executeRequest(HttpUriRequest httpRequest, String charset) {  
            CloseableHttpClient httpclient;  
            if ("https".equals(httpRequest.getURI().getScheme())) {  
                httpclient = createSSLInsecureClient();  
            } else {  
                httpclient = HttpClients.createDefault();  
            }  
            String result = "";  
            try {  
                try {  
                    CloseableHttpResponse response = httpclient.execute(httpRequest);  
                    HttpEntity entity = null;  
                    try {  
                        entity = response.getEntity();  
                        result = EntityUtils.toString(entity, charset);  
                    } finally {  
                        EntityUtils.consume(entity);  
                        response.close();  
                    }  
                } finally {  
                    httpclient.close();  
                }  
            } catch (IOException ex) {  
                ex.printStackTrace();  
            }  
            return result;  
        }  
      
        public static String executeRequest(CloseableHttpClient httpclient, HttpUriRequest httpRequest, String charset) {  
            String result = "";  
            try {  
                try {  
                    CloseableHttpResponse response = httpclient.execute(httpRequest);  
                    HttpEntity entity = null;  
                    try {  
                        entity = response.getEntity();  
                        result = EntityUtils.toString(entity, charset);  
                    } finally {  
                        EntityUtils.consume(entity);  
                        response.close();  
                    }  
                } finally {  
                    httpclient.close();  
                }  
            } catch (IOException ex) {  
                ex.printStackTrace();  
            }  
            return result;  
        }  
      
        /**  
         * 创建 SSL连接  
         */  
        public static CloseableHttpClient createSSLInsecureClient() {  
            try {  
                SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(new TrustStrategy() {  
                    @Override  
                    public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {  
                        return true;  
                    }  
                }).build();  
                SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext, new HostnameVerifier() {  
                    @Override  
                    public boolean verify(String hostname, SSLSession session) {  
                        return true;  
                    }  
                });  
                return HttpClients.custom().setSSLSocketFactory(sslsf).build();  
            } catch (GeneralSecurityException ex) {  
                throw new RuntimeException(ex);  
            }  
        }  
    }

### 运行 ###

由于网络等原因，我们发现并不能全部下载成功，不过可以多次运行尝试，可以实现较高的下载成功率。

![a662e62ca6a25c9ee11df312a2a57cc7.png][]

图片 ![89d909cdfd1e09e20e23ba84a01f0347.png][] 图片 ![4da8db458616cefbc174eea07c6050b8.png][] 图片

666，厉害了。。

<END>

**推荐阅读：**

[面试难题：6种分布式事务，那个最牛逼？][6]

[手写了一个简单的JSON解析器，网友直乎：牛！][JSON]

**互联网初中高级大厂面试题(9个G)**

内容包含Java基础、JavaWeb、MySQL性能优化、JVM、锁、百万并发、消息队列、高性能缓存、反射、Spring全家桶原理、微服务、Zookeeper、数据结构、限流熔断降级......等技术栈！

⬇戳阅读原文领取！                                       朕已阅 ![c4d165b75e1a6fef4acfdb48510b5e2f.gif][]

[0D5F937FE12312312D81F17F.jpg]: /images/20220829/5a8a9dffec5e48648d8519725286a3d2.png
[Link 1]: https://mp.weixin.qq.com/s?__biz=MzUyNDkzNzczNQ%3D%3D&chksm=fa24f0bacd5379ac93d74ffebac826d2401fd494f82e900e5102a8bf968f108e4ec72a4ad548&idx=3&lang=zh_CN&mid=2247487442&scene=21&sn=61e758d4bf9f15a3419fd028146469a3&token=1854383306#wechat_redirect
[a934541ddf11ba41e5c975e96e9d1bf1.png]: /images/20220829/c85421859cbb431abc23ff45841996d4.png
[54bec5d170e9d6bbfe014b67caaac37c.png]: /images/20220829/98189a99b75e4d5ca763de65c1a42f37.png
[cf6305d48a118ad688347ce3d5dc6507.png]: /images/20220829/429fbb2c24424eaab32ea5469fc34052.png
[911f0826b9719366748170fa276bf0c2.png]: /images/20220829/3a5b5bbf41774b37ad43a197382ab072.png
[a662e62ca6a25c9ee11df312a2a57cc7.png]: /images/20220829/eb76e2fe4611476694665e1cda5b7ce4.png
[89d909cdfd1e09e20e23ba84a01f0347.png]: https://img-blog.csdnimg.cn/img_convert/89d909cdfd1e09e20e23ba84a01f0347.png
[4da8db458616cefbc174eea07c6050b8.png]: /images/20220829/b0a3eb1a42504169b6306dce41b6b00f.png
[6]: http://mp.weixin.qq.com/s?__biz=MzUyNDkzNzczNQ%3D%3D&chksm=fa2753cdcd50dadb98907b1f1791d5127c32a7e8b256fd502281b84ebe86b6f088c1c389e4c7&idx=1&mid=2247511205&scene=21&sn=730bec80cb8f597d19ef0b5e467dec4f#wechat_redirect
[JSON]: http://mp.weixin.qq.com/s?__biz=MzUyNDkzNzczNQ%3D%3D&chksm=fa2753cdcd50dadb1b0521eadddee1ec30a35462bed2d2c6d342b9e93a08ef02752a690565e5&idx=2&mid=2247511205&scene=21&sn=b9e21556b4e4abcb9a579ad1f151e933#wechat_redirect
[c4d165b75e1a6fef4acfdb48510b5e2f.gif]: /images/20220829/538579ea6f9c4527b11504699f888142.png